--- /srv/reproducible-results/rbuild-debian/r-b-build.KA92l4bn/b1/libtorrent-rasterbar_2.0.11-1_arm64.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.KA92l4bn/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 │ - db11e98dc1b81f5a2e53a6969fb5ee5a 1669540 doc optional libtorrent-rasterbar-doc_2.0.11-1_all.deb │ + 7ec1da8ba9e530b5020684b1da8ebdb9 1669900 doc optional libtorrent-rasterbar-doc_2.0.11-1_all.deb │ e6156e96d36de4cf42aee101bebd9b59 50632164 debug optional libtorrent-rasterbar2.0t64-dbgsym_2.0.11-1_arm64.deb │ 54f49ceb5f788a4d068ebbca3c6bcfb0 1490920 libs optional libtorrent-rasterbar2.0t64_2.0.11-1_arm64.deb │ 4a71d2444899a0639fd02d2cff7ce19a 13137228 debug optional python3-libtorrent-dbgsym_2.0.11-1_arm64.deb │ e499c73b029b4ec1126c793da002b8c6 672852 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 1665716 2025-01-28 14:33:12.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 3624 2025-01-28 14:33:12.000000 control.tar.xz │ │ +-rw-r--r-- 0 0 0 1666084 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 │ │ │ │┄ Ordering differences only │ │ │ │ @@ -48,20 +48,20 @@ │ │ │ │ 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);
│ │ │ │ -   T* get () const;
│ │ │ │     explicit operator T () const;
│ │ │ │ +   T* get () const;
│ │ │ │     operator void const* () const = delete;
│ │ │ │ -   operator void* () const = delete;
│ │ │ │ -   client_data_t& operator= (void*) = delete;
│ │ │ │     client_data_t& operator= (void const*) = delete;
│ │ │ │ +   client_data_t& operator= (void*) = delete;
│ │ │ │ +   operator void* () const = delete;
│ │ │ │  
│ │ │ │     template <typename T, typename U  = typename std::enable_if<std::is_pointer<T>::value>::type>
│ │ │ │  };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │

client_data_t()

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

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

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

we don't allow type-unsafe operations

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

add_torrent_params

│ │ │ │

Declared in "libtorrent/add_torrent_params.hpp"

│ │ │ │ ├── html2text {} │ │ │ │ │ @@ -14,34 +14,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); │ │ │ │ │ - T* ggeett () const; │ │ │ │ │ explicit operator TT () const; │ │ │ │ │ + T* ggeett () const; │ │ │ │ │ operator void ccoonnsstt** () const = delete; │ │ │ │ │ - operator vvooiidd** () const = delete; │ │ │ │ │ - client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ client_data_t& ooppeerraattoorr== (void const*) = delete; │ │ │ │ │ + client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ + operator vvooiidd** () 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**(()) ooppeerraattoorr==(()) vvooiidd**(()) ********** │ │ │ │ │ operator void ccoonnsstt** () const = delete; │ │ │ │ │ -operator vvooiidd** () const = delete; │ │ │ │ │ -client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ client_data_t& ooppeerraattoorr== (void const*) = delete; │ │ │ │ │ +client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ +operator vvooiidd** () 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 │ │ │ │ @@ -94,15 +94,15 @@ │ │ │ │
  • piece_finished_alert
    • │ │ │ │
  • request_dropped_alert
    • │ │ │ │
  • block_timeout_alert
    • │ │ │ │
  • block_finished_alert
    • │ │ │ │
  • block_downloading_alert
    • │ │ │ │
  • unwanted_block_alert
    • │ │ │ │
  • storage_moved_alert │ │ │ │
    • │ │ │ │
  • storage_moved_failed_alert │ │ │ │
    • │ │ │ │
  • torrent_deleted_alert
    • │ │ │ │ @@ -199,20 +199,20 @@ │ │ │ │ │ │ │ │ │ │ │ │
  • dht_get_peers_reply_alert
    • │ │ │ │
  • dht_direct_response_alert
    • │ │ │ │
  • picker_log_alert
    • │ │ │ │
  • session_error_alert
    • │ │ │ │
  • dht_live_nodes_alert │ │ │ │
    • │ │ │ │
  • session_stats_header_alert
    • │ │ │ │
  • dht_sample_infohashes_alert │ │ │ │
    • │ │ │ │
  • block_uploaded_alert
    • │ │ │ │
  • alerts_dropped_alert
    • │ │ │ │
  • socks5_alert
    • │ │ │ │ @@ -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]
    │ │ │ │ -

    old_path() storage_path()

    │ │ │ │ + │ │ │ │ +[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"

    │ │ │ │ @@ -2951,17 +2951,17 @@ │ │ │ │ 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()

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

    nodes() num_nodes()

    │ │ │ │ 
    │ │ │ │  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
    │ │ │ │ @@ -3005,17 +3005,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]
    │ │ │ │ -

    num_samples() samples()

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

    samples() num_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().

    │ │ │ │ @@ -3079,16 +3079,16 @@ │ │ │ │

    this alert is posted to indicate to the client that some alerts were │ │ │ │ dropped. Dropped meaning that the alert failed to be delivered to the │ │ │ │ client. The most common cause of such failure is that the internal alert │ │ │ │ queue grew too big (controlled by alert_queue_size).

    │ │ │ │ 
    │ │ │ │  struct alerts_dropped_alert final : alert
│ │ │ │  {
│ │ │ │ -   std::string message () const override;
│ │ │ │     static_assert (num_alert_types <= abi_alert_count, "need to increase bitset. This is an ABI break");
│ │ │ │ +   std::string message () const override;
│ │ │ │  
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::error;
│ │ │ │     std::bitset<abi_alert_count> dropped_alerts;
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │
    dropped_alerts
    │ │ │ │ @@ -3299,16 +3299,16 @@ │ │ │ │
    list of trackers and their status for the torrent
    │ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    alert_cast()

    │ │ │ │

    Declared in "libtorrent/alert.hpp"

    │ │ │ │ 
    │ │ │ │ -template <typename T> T* alert_cast (alert* a);
│ │ │ │  template <typename T> T const* alert_cast (alert const* a);
│ │ │ │ +template <typename T> T* alert_cast (alert* 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

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -47,15 +47,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 _o_l_d___p_a_t_h_(_)_ _s_t_o_r_a_g_e___p_a_t_h_(_) │ │ │ │ │ + o _s_t_o_r_a_g_e___p_a_t_h_(_)_ _o_l_d___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 │ │ │ │ │ @@ -120,18 +120,18 @@ │ │ │ │ │ o _p_k_t___b_u_f_(_) │ │ │ │ │ o _e_n_u_m_ _d_i_r_e_c_t_i_o_n___t │ │ │ │ │ * _d_h_t___g_e_t___p_e_e_r_s___r_e_p_l_y___a_l_e_r_t │ │ │ │ │ * _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_(_) │ │ │ │ │ + o _n_o_d_e_s_(_)_ _n_u_m___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 _n_u_m___s_a_m_p_l_e_s_(_)_ _s_a_m_p_l_e_s_(_) │ │ │ │ │ + o _s_a_m_p_l_e_s_(_)_ _n_u_m___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 │ │ │ │ │ @@ -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] │ │ │ │ │ -********** oolldd__ppaatthh(()) ssttoorraaggee__ppaatthh(()) ********** │ │ │ │ │ -char const* ssttoorraaggee__ppaatthh () const; │ │ │ │ │ +********** ssttoorraaggee__ppaatthh(()) oolldd__ppaatthh(()) ********** │ │ │ │ │ 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 │ │ │ │ │ @@ -2295,15 +2295,15 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ +********** nnooddeess(()) nnuumm__nnooddeess(()) ********** │ │ │ │ │ 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] │ │ │ │ │ @@ -2339,15 +2339,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] │ │ │ │ │ -********** nnuumm__ssaammpplleess(()) ssaammpplleess(()) ********** │ │ │ │ │ +********** ssaammpplleess(()) nnuumm__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; │ │ │ │ │ @@ -2394,17 +2394,17 @@ │ │ │ │ │ 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 _a_l_e_r_t is posted to indicate to the client that some alerts were dropped. │ │ │ │ │ Dropped meaning that the _a_l_e_r_t failed to be delivered to the client. The most │ │ │ │ │ common cause of such failure is that the internal _a_l_e_r_t queue grew too big │ │ │ │ │ (controlled by alert_queue_size). │ │ │ │ │ struct alerts_dropped_alert final : alert │ │ │ │ │ { │ │ │ │ │ - std::string mmeessssaaggee () const override; │ │ │ │ │ ssttaattiicc__aasssseerrtt (num_alert_types <= abi_alert_count, "need to increase bitset. │ │ │ │ │ This is an ABI break"); │ │ │ │ │ + std::string mmeessssaaggee () const override; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category::error; │ │ │ │ │ std::bitset dropped_alerts; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ dropped_alerts │ │ │ │ │ a bitmask indicating which alerts were dropped. Each bit represents the │ │ │ │ │ @@ -2574,16 +2574,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* aalleerrtt__ccaasstt (alert* a); │ │ │ │ │ template T const* aalleerrtt__ccaasstt (alert const* a); │ │ │ │ │ +template T* aalleerrtt__ccaasstt (alert* 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" │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Bdecoding.html │ │ │ │ @@ -30,23 +30,23 @@ │ │ │ │ │ │ │ │

    home

    │ │ │ │
    │ │ │ │

    Table of contents

    │ │ │ │
      │ │ │ │
    • bdecode_node │ │ │ │ @@ -63,45 +63,45 @@ │ │ │ │ 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&&) & = default;
│ │ │ │ -   bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │     bdecode_node (bdecode_node const&);
│ │ │ │     bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ +   bdecode_node& operator= (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::int64_t list_int_value_at (int i
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │     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::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_int (string_view key) const;
│ │ │ │     string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) 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_dict (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_dict (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;
│ │ │ │     int dict_size () const;
│ │ │ │ -   bdecode_node dict_find_int (string_view key) const;
│ │ │ │     std::int64_t int_value () const;
│ │ │ │ -   int string_length () const;
│ │ │ │ +   string_view string_value () const;
│ │ │ │     std::ptrdiff_t string_offset () const;
│ │ │ │     char const* string_ptr () const;
│ │ │ │ -   string_view string_value () const;
│ │ │ │ +   int string_length () 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,23 +116,23 @@
│ │ │ │
      │ │ │ │ [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&&) & = default;
│ │ │ │ -bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │  bdecode_node (bdecode_node const&);
│ │ │ │  bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ +bdecode_node& operator= (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()

      │ │ │ │ 
      │ │ │ │ @@ -164,57 +164,57 @@
│ │ │ │
      │ │ │ │

      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_int_value_at() list_string_value_at() list_size()

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

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

      │ │ │ │ 
      │ │ │ │  std::int64_t list_int_value_at (int i
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │  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;
│ │ │ │
      │ │ │ │

      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_list() dict_at() dict_find_dict() dict_find_int_value() dict_find_string_value() dict_find_string() dict_find() dict_size()

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

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

      │ │ │ │ 
      │ │ │ │ -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_int (string_view key) const;
│ │ │ │  string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) 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_dict (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_dict (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;
│ │ │ │  int dict_size () 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_ptr() string_length() string_value() string_offset()

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

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

      │ │ │ │ 
      │ │ │ │ -int string_length () const;
│ │ │ │ +string_view string_value () const;
│ │ │ │  std::ptrdiff_t string_offset () const;
│ │ │ │  char const* string_ptr () const;
│ │ │ │ -string_view string_value () const;
│ │ │ │ +int string_length () 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,20 +345,20 @@ │ │ │ │

      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
│ │ │ │ +bdecode_node bdecode (span<char const> buffer
│ │ │ │     , 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
│ │ │ │ +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 │ │ │ │ ├── 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___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_(_) │ │ │ │ │ - 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___l_i_s_t_(_)_ _d_i_c_t___a_t_(_) │ │ │ │ │ - _d_i_c_t___f_i_n_d___d_i_c_t_(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _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___s_t_r_i_n_g_(_)_ _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___s_i_z_e_(_) │ │ │ │ │ + o _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___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_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)_ _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___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___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_) │ │ │ │ │ o _i_n_t___v_a_l_u_e_(_) │ │ │ │ │ - o _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_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_) │ │ │ │ │ + o _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___p_t_r_(_) │ │ │ │ │ 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_(_) │ │ │ │ │ @@ -31,45 +31,45 @@ │ │ │ │ │ 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&&) & = default; │ │ │ │ │ - bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node const&); │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node&&) noexcept; │ │ │ │ │ + bdecode_node& ooppeerraattoorr== (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::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ 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::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__iinntt (string_view key) const; │ │ │ │ │ string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key │ │ │ │ │ , string_view default_value = string_view()) 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__ddiicctt (string_view key) const; │ │ │ │ │ + std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ std::pair ddiicctt__aatt__nnooddee (int i) const; │ │ │ │ │ bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ int ddiicctt__ssiizzee () const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ std::int64_t iinntt__vvaalluuee () const; │ │ │ │ │ - int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ + string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ char const* ssttrriinngg__ppttrr () const; │ │ │ │ │ - string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ + int ssttrriinngg__lleennggtthh () 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,19 +82,19 @@ │ │ │ │ │ }; │ │ │ │ │ }; │ │ │ │ │ [_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==(()) ********** │ │ │ │ │ +********** ooppeerraattoorr==(()) bbddeeccooddee__nnooddee(()) ********** │ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default; │ │ │ │ │ -bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node const&); │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node&&) noexcept; │ │ │ │ │ +bdecode_node& ooppeerraattoorr== (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] │ │ │ │ │ @@ -112,41 +112,41 @@ │ │ │ │ │ span ddaattaa__sseeccttiioonn () 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__iinntt__vvaalluuee__aatt(()) lliisstt__ssttrriinngg__vvaalluuee__aatt(()) lliisstt__ssiizzee(()) ********** │ │ │ │ │ +********** lliisstt__ssiizzee(()) lliisstt__iinntt__vvaalluuee__aatt(()) lliisstt__aatt(()) lliisstt__ssttrriinngg__vvaalluuee__aatt(()) ********** │ │ │ │ │ std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ 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; │ │ │ │ │ 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__lliisstt(()) ddiicctt__aatt(()) ddiicctt__ffiinndd__ddiicctt │ │ │ │ │ -(()) ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) ddiicctt__ffiinndd__ssttrriinngg(()) ddiicctt__ffiinndd │ │ │ │ │ -(()) ddiicctt__ssiizzee(()) ********** │ │ │ │ │ -std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ +********** ddiicctt__aatt(()) ddiicctt__ffiinndd(()) ddiicctt__ffiinndd__ssttrriinngg(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) │ │ │ │ │ +ddiicctt__ffiinndd__iinntt(()) ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__aatt__nnooddee(()) ddiicctt__ssiizzee(()) ddiicctt__ffiinndd__iinntt__vvaalluuee │ │ │ │ │ +(()) ddiicctt__ffiinndd__lliisstt(()) ********** │ │ │ │ │ +std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key │ │ │ │ │ + , std::int64_t default_val = 0) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key │ │ │ │ │ , string_view default_value = string_view()) 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__ddiicctt (string_view key) const; │ │ │ │ │ +std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ std::pair ddiicctt__aatt__nnooddee (int i) const; │ │ │ │ │ bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ int ddiicctt__ssiizzee () 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__ppttrr(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__vvaalluuee(()) ssttrriinngg__ooffffsseett(()) ********** │ │ │ │ │ -int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ +********** ssttrriinngg__vvaalluuee(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__ooffffsseett(()) ssttrriinngg__ppttrr(()) ********** │ │ │ │ │ +string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ char const* ssttrriinngg__ppttrr () const; │ │ │ │ │ -string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ +int ssttrriinngg__lleennggtthh () 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,20 +214,20 @@ │ │ │ │ │ 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 │ │ │ │ │ +bdecode_node bbddeeccooddee (span buffer │ │ │ │ │ , 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 │ │ │ │ │ +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 │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Bencoding.html │ │ │ │ @@ -34,15 +34,15 @@ │ │ │ │

        │ │ │ │
      • entry │ │ │ │
        • │ │ │ │ @@ -69,46 +69,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 (integer_type);
│ │ │ │ -   entry (span<char const>);
│ │ │ │     entry (list_type);
│ │ │ │ +   entry (span<char const>);
│ │ │ │     entry (U v);
│ │ │ │     entry (data_type t);
│ │ │ │     entry (bdecode_node const& n);
│ │ │ │     entry& operator= (entry&&) & noexcept;
│ │ │ │ -   entry& operator= (preformatted_type) &;
│ │ │ │ +   entry& operator= (list_type) &;
│ │ │ │     entry& operator= (entry const&) &;
│ │ │ │ +   entry& operator= (preformatted_type) &;
│ │ │ │ +   entry& operator= (dictionary_type) &;
│ │ │ │ +   entry& operator= (span<char const>) &;
│ │ │ │     entry& operator= (bdecode_node const&) &;
│ │ │ │     entry& operator= (integer_type) &;
│ │ │ │ -   entry& operator= (list_type) &;
│ │ │ │ -   entry& operator= (span<char const>) &;
│ │ │ │ -   entry& operator= (dictionary_type) &;
│ │ │ │     entry& operator= (U v) &;
│ │ │ │ -   dictionary_type const& dict () const;
│ │ │ │ +   integer_type& integer ();
│ │ │ │ +   string_type const& string () const;
│ │ │ │     string_type& string ();
│ │ │ │ +   preformatted_type const& preformatted () const;
│ │ │ │ +   preformatted_type& preformatted ();
│ │ │ │     integer_type const& integer () const;
│ │ │ │ -   integer_type& integer ();
│ │ │ │ +   dictionary_type const& dict () const;
│ │ │ │     list_type const& list () const;
│ │ │ │     dictionary_type& dict ();
│ │ │ │ -   preformatted_type const& preformatted () const;
│ │ │ │     list_type& list ();
│ │ │ │ -   string_type const& string () const;
│ │ │ │ -   preformatted_type& preformatted ();
│ │ │ │     void swap (entry& e);
│ │ │ │ -   entry const& operator[] (string_view key) const;
│ │ │ │     entry& operator[] (string_view key);
│ │ │ │ -   entry* find_key (string_view key);
│ │ │ │ +   entry const& operator[] (string_view key) const;
│ │ │ │     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,
│ │ │ │ @@ -124,19 +124,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 (integer_type);
│ │ │ │ -entry (span<char const>);
│ │ │ │  entry (list_type);
│ │ │ │ +entry (span<char const>);
│ │ │ │
      │ │ │ │

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

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

      entry()

      │ │ │ │ @@ -153,42 +153,42 @@ │ │ │ │ │ │ │ │

      construct from bdecode_node parsed form (see bdecode())

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

      operator=()

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

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

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

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

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

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

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

      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,32 +232,32 @@ │ │ │ │ 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.

      │ │ │ │

      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]
      │ │ │ │ ├── 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 _i_n_t_e_g_e_r_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _d_i_c_t_(_)_ _l_i_s_t_(_)_ _s_t_r_i_n_g_(_) │ │ │ │ │ + o _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_(_)_ _i_n_t_e_g_e_r_(_) │ │ │ │ │ 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,46 +35,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 (integer_type); │ │ │ │ │ - eennttrryy (span); │ │ │ │ │ eennttrryy (list_type); │ │ │ │ │ + eennttrryy (span); │ │ │ │ │ eennttrryy (U v); │ │ │ │ │ eennttrryy (data_type t); │ │ │ │ │ eennttrryy (bdecode_node const& n); │ │ │ │ │ entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ - entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ + entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (span) &; │ │ │ │ │ entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ - entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ - entry& ooppeerraattoorr== (span) &; │ │ │ │ │ - entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ entry& ooppeerraattoorr== (U v) &; │ │ │ │ │ - dictionary_type const& ddiicctt () const; │ │ │ │ │ + integer_type& iinntteeggeerr (); │ │ │ │ │ + string_type const& ssttrriinngg () const; │ │ │ │ │ string_type& ssttrriinngg (); │ │ │ │ │ + preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ + preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ integer_type const& iinntteeggeerr () const; │ │ │ │ │ - integer_type& iinntteeggeerr (); │ │ │ │ │ + dictionary_type const& ddiicctt () const; │ │ │ │ │ list_type const& lliisstt () const; │ │ │ │ │ dictionary_type& ddiicctt (); │ │ │ │ │ - preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ list_type& lliisstt (); │ │ │ │ │ - string_type const& ssttrriinngg () const; │ │ │ │ │ - preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ void sswwaapp (entry& e); │ │ │ │ │ - entry const& ooppeerraattoorr[[]] (string_view key) const; │ │ │ │ │ entry& ooppeerraattoorr[[]] (string_view key); │ │ │ │ │ - entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ + entry const& ooppeerraattoorr[[]] (string_view key) const; │ │ │ │ │ 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, │ │ │ │ │ @@ -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 (integer_type); │ │ │ │ │ eennttrryy (dictionary_type); │ │ │ │ │ eennttrryy (preformatted_type); │ │ │ │ │ -eennttrryy (integer_type); │ │ │ │ │ -eennttrryy (span); │ │ │ │ │ eennttrryy (list_type); │ │ │ │ │ +eennttrryy (span); │ │ │ │ │ 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== (entry&&) & noexcept; │ │ │ │ │ -entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ +entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (span) &; │ │ │ │ │ entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ -entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ -entry& ooppeerraattoorr== (span) &; │ │ │ │ │ -entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ 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(()) pprreeffoorrmmaatttteedd(()) ddiicctt(()) lliisstt(()) ssttrriinngg(()) ********** │ │ │ │ │ -dictionary_type const& ddiicctt () const; │ │ │ │ │ +********** ddiicctt(()) lliisstt(()) pprreeffoorrmmaatttteedd(()) ssttrriinngg(()) iinntteeggeerr(()) ********** │ │ │ │ │ +integer_type& iinntteeggeerr (); │ │ │ │ │ +string_type const& ssttrriinngg () const; │ │ │ │ │ string_type& ssttrriinngg (); │ │ │ │ │ +preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ +preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ integer_type const& iinntteeggeerr () const; │ │ │ │ │ -integer_type& iinntteeggeerr (); │ │ │ │ │ +dictionary_type const& ddiicctt () const; │ │ │ │ │ list_type const& lliisstt () const; │ │ │ │ │ dictionary_type& ddiicctt (); │ │ │ │ │ -preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ list_type& lliisstt (); │ │ │ │ │ -string_type const& ssttrriinngg () const; │ │ │ │ │ -preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ 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,27 +161,27 @@ │ │ │ │ │ _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. │ │ │ │ │ [_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(()) ********** │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Core.html │ │ │ │ @@ -45,15 +45,15 @@ │ │ │ │
    │ │ │ │ │ │ │ │
  • piece_block
    • │ │ │ │
  • peer_request │ │ │ │
    • │ │ │ │ -
  • load_torrent_buffer() load_torrent_parsed() load_torrent_file()
    • │ │ │ │ +
  • load_torrent_file() load_torrent_parsed() load_torrent_buffer()
    • │ │ │ │
  • make_magnet_uri()
    • │ │ │ │
  • parse_magnet_uri()
    • │ │ │ │
  • torrent_peer_equal()
    • │ │ │ │
  • truncate_files()
    • │ │ │ │
  • version()
    • │ │ │ │
  • enum socket_type_t
    • │ │ │ │
  • enum protocol_version
    • │ │ │ │ @@ -565,20 +565,20 @@ │ │ │ │

    Note

    │ │ │ │

    If has_v2() is false then the v1 hash might actually be a truncated │ │ │ │ v2 hash

    │ │ │ │
    │ │ │ │ 
    │ │ │ │  struct info_hash_t
│ │ │ │  {
│ │ │ │ -   info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │     explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ -   info_hash_t () noexcept = default;
│ │ │ │     explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ -   bool has (protocol_version v) const;
│ │ │ │ +   info_hash_t () noexcept = default;
│ │ │ │ +   info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │     bool has_v1 () const;
│ │ │ │ +   bool has (protocol_version v) 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;
│ │ │ │     template <typename F> void for_each (F f) const;
│ │ │ │     bool operator< (info_hash_t const& o) const;
│ │ │ │ @@ -587,32 +587,32 @@
│ │ │ │     sha1_hash v1;
│ │ │ │     sha256_hash v2;
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    info_hash_t()

    │ │ │ │ 
    │ │ │ │ -info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │  explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ -info_hash_t () noexcept = default;
│ │ │ │  explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ +info_hash_t () noexcept = default;
│ │ │ │ +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_v1() has_v2() has()

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

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

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

    get()

    │ │ │ │ @@ -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;
│ │ │ │ @@ -689,34 +689,34 @@
│ │ │ │  
    start
    
│ │ │ │  
    The byte offset within that piece where the range starts.
    
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │
    length
    │ │ │ │
    The size of the range, in bytes.
    │ │ │ │
    │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ +[report issue]
    │ │ │ │
    │ │ │ │ -
    │ │ │ │ -

    load_torrent_buffer() load_torrent_parsed() load_torrent_file()

    │ │ │ │ +
    │ │ │ │ +

    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_parsed (
│ │ │ │ -   bdecode_node const& torrent_file, 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_file (
│ │ │ │     std::string const& filename);
│ │ │ │ +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_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:

    │ │ │ │ @@ -729,16 +729,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, │ │ │ │ @@ -758,17 +758,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"

    │ │ │ │ 
    │ │ │ │ -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);
│ │ │ │ +void parse_magnet_uri (string_view uri, add_torrent_params& p, 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]
    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -10,15 +10,15 @@ │ │ │ │ │ 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___b_u_f_f_e_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___f_i_l_e_(_) │ │ │ │ │ + * _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_(_) │ │ │ │ │ * _m_a_k_e___m_a_g_n_e_t___u_r_i_(_) │ │ │ │ │ * _p_a_r_s_e___m_a_g_n_e_t___u_r_i_(_) │ │ │ │ │ * _t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_) │ │ │ │ │ * _t_r_u_n_c_a_t_e___f_i_l_e_s_(_) │ │ │ │ │ * _v_e_r_s_i_o_n_(_) │ │ │ │ │ * _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t │ │ │ │ │ * _e_n_u_m_ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n │ │ │ │ │ @@ -413,20 +413,20 @@ │ │ │ │ │ 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 │ │ │ │ │ { │ │ │ │ │ - iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ │ explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ - iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept; │ │ │ │ │ - bool hhaass (protocol_version v) const; │ │ │ │ │ + iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ + iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ │ bool hhaass__vv11 () const; │ │ │ │ │ + bool hhaass (protocol_version v) 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) │ │ │ │ │ noexcept; │ │ │ │ │ template void ffoorr__eeaacchh (F f) const; │ │ │ │ │ @@ -434,26 +434,26 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ -iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ │ explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ -iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept; │ │ │ │ │ +iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ +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__vv11(()) hhaass__vv22(()) hhaass(()) ********** │ │ │ │ │ -bool hhaass (protocol_version v) const; │ │ │ │ │ bool hhaass__vv11 () const; │ │ │ │ │ +bool hhaass (protocol_version v) 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; │ │ │ │ │ returns the has for the specified protocol version │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ @@ -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; │ │ │ │ │ @@ -506,41 +506,41 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ start │ │ │ │ │ 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__bbuuffffeerr(()) llooaadd__ttoorrrreenntt__ppaarrsseedd(()) llooaadd__ttoorrrreenntt__ffiillee(()) ************ │ │ │ │ │ +************ 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__ppaarrsseedd ( │ │ │ │ │ - bdecode_node const& torrent_file, 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__ffiillee ( │ │ │ │ │ std::string const& filename); │ │ │ │ │ +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__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 (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 │ │ │ │ │ @@ -555,17 +555,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" │ │ │ │ │ -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); │ │ │ │ │ +void ppaarrssee__mmaaggnneett__uurrii (string_view uri, add_torrent_params& p, 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(()) ************ │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Create_Torrents.html │ │ │ │ @@ -30,33 +30,33 @@ │ │ │ │ │ │ │ │

    home

    │ │ │ │
    │ │ │ │

    Table of contents

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

    This section describes the functions and classes that are used │ │ │ │ @@ -108,29 +108,29 @@ │ │ │ │ .torrent file using bencode().

    │ │ │ │ 
    │ │ │ │  struct create_torrent
│ │ │ │  {
│ │ │ │     explicit create_torrent (torrent_info const& ti);
│ │ │ │     explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ │        , create_flags_t flags = {});
│ │ │ │ -   entry generate () const;
│ │ │ │     std::vector<char> generate_buf () const;
│ │ │ │ +   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_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;
│ │ │ │ +   void set_priv (bool p);
│ │ │ │     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;
│ │ │ │ @@ -175,21 +175,21 @@
│ │ │ │  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_buf() generate()

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

    generate() generate_buf()

    │ │ │ │ 
    │ │ │ │ -entry generate () const;
│ │ │ │  std::vector<char> generate_buf () const;
│ │ │ │ +entry generate () 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.

    │ │ │ │

    The function returning an entry may be useful to add custom entries │ │ │ │ to the torrent file before bencoding it and saving it to disk.

    │ │ │ │

    Whether the resulting torrent object is v1, v2 or hybrid depends on │ │ │ │ @@ -272,18 +272,18 @@ │ │ │ │ 16 kiB blocks. Note that piece sizes must 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 generate(). │ │ │ │ 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()

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

    add_url_seed() add_http_seed()

    │ │ │ │ 
    │ │ │ │  void add_url_seed (string_view url);
│ │ │ │  void add_http_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 │ │ │ │ @@ -320,21 +320,21 @@ │ │ │ │ │ │ │ │

    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]
    │ │ │ │ -
    │ │ │ │ -

    set_priv() priv()

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

    priv() set_priv()

    │ │ │ │ 
    │ │ │ │ -void set_priv (bool p);
│ │ │ │  bool priv () const;
│ │ │ │ +void set_priv (bool p);
│ │ │ │
    │ │ │ │

    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.

    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │ @@ -369,29 +369,29 @@ │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    total_size()

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

    the total number of bytes of all files and pad files

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

    piece_size() piece_length()

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

    piece_length() piece_size()

    │ │ │ │ 
    │ │ │ │  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]
    │ │ │ │ -
    │ │ │ │ -

    add_collection() add_similar_torrent()

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

    add_similar_torrent() add_collection()

    │ │ │ │ 
    │ │ │ │  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 │ │ │ │ @@ -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:

    │ │ │ │ 
    │ │ │ │ @@ -482,29 +482,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"

    │ │ │ │ 
    │ │ │ │ +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);
│ │ │ │ -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
│ │ │ │     , std::function<void(piece_index_t)> const& f);
│ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p);
│ │ │ │  void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │     , 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);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ +   , settings_interface const& settings
│ │ │ │ +   , 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 {}
│ │ │ │ │ @@ -1,33 +1,33 @@
│ │ │ │ │  >
│ │ │ │ │  _[_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_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___b_u_f_(_)_ _g_e_n_e_r_a_t_e_(_)
│ │ │ │ │ +          o _g_e_n_e_r_a_t_e_(_)_ _g_e_n_e_r_a_t_e___b_u_f_(_)
│ │ │ │ │            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___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)
│ │ │ │ │ +          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 _s_e_t___p_r_i_v_(_)_ _p_r_i_v_(_)
│ │ │ │ │ +          o _p_r_i_v_(_)_ _s_e_t___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___s_i_z_e_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ -          o _a_d_d___c_o_l_l_e_c_t_i_o_n_(_)_ _a_d_d___s_i_m_i_l_a_r___t_o_r_r_e_n_t_(_)
│ │ │ │ │ +          o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ +          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_(_)
│ │ │ │ │  This section describes the functions and classes that are used to create
│ │ │ │ │  torrent files. It is a layered API with low level classes and higher level
│ │ │ │ │  convenience functions. A torrent is created in 4 steps:
│ │ │ │ │     1. first the files that will be part of the torrent are determined.
│ │ │ │ │     2. the torrent properties are set, such as tracker url, web seeds, DHT nodes
│ │ │ │ │ @@ -69,30 +69,30 @@
│ │ │ │ │  _e_n_t_r_y that's returned can then be bencoded into a .torrent file using _b_e_n_c_o_d_e
│ │ │ │ │  _(_).
│ │ │ │ │  struct create_torrent
│ │ │ │ │  {
│ │ │ │ │     explicit ccrreeaattee__ttoorrrreenntt (torrent_info const& ti);
│ │ │ │ │     explicit ccrreeaattee__ttoorrrreenntt (file_storage& fs, int piece_size = 0
│ │ │ │ │        , create_flags_t flags = {});
│ │ │ │ │ -   entry ggeenneerraattee () const;
│ │ │ │ │     std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │ +   entry ggeenneerraattee () const;
│ │ │ │ │     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__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;
│ │ │ │ │ +   void sseett__pprriivv (bool p);
│ │ │ │ │     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;
│ │ │ │ │ @@ -131,17 +131,17 @@
│ │ │ │ │  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__bbuuff(()) ggeenneerraattee(()) **********
│ │ │ │ │ -entry ggeenneerraattee () const;
│ │ │ │ │ +********** ggeenneerraattee(()) ggeenneerraattee__bbuuff(()) **********
│ │ │ │ │  std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │ +entry ggeenneerraattee () 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.
│ │ │ │ │  Whether the resulting torrent object is v1, v2 or hybrid depends on whether any
│ │ │ │ │  of the v1_only or v2_only flags were set on the constructor. If neither were
│ │ │ │ │ @@ -198,15 +198,15 @@
│ │ │ │ │  the merkle tree formed by the piece's 16 kiB blocks. Note that piece sizes must
│ │ │ │ │  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(()) **********
│ │ │ │ │ +********** aadddd__uurrll__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │  void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │  void aadddd__hhttttpp__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.
│ │ │ │ │ @@ -235,17 +235,17 @@
│ │ │ │ │  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]
│ │ │ │ │ -********** sseett__pprriivv(()) pprriivv(()) **********
│ │ │ │ │ -void sseett__pprriivv (bool p);
│ │ │ │ │ +********** pprriivv(()) sseett__pprriivv(()) **********
│ │ │ │ │  bool pprriivv () const;
│ │ │ │ │ +void sseett__pprriivv (bool p);
│ │ │ │ │  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(()) **********
│ │ │ │ │  int nnuumm__ppiieecceess () const;
│ │ │ │ │  returns the number of pieces in the associated _f_i_l_e___s_t_o_r_a_g_e object.
│ │ │ │ │ @@ -263,22 +263,22 @@
│ │ │ │ │  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__ssiizzee(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ +********** ppiieeccee__lleennggtthh(()) ppiieeccee__ssiizzee(()) **********
│ │ │ │ │  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__ccoolllleeccttiioonn(()) aadddd__ssiimmiillaarr__ttoorrrreenntt(()) **********
│ │ │ │ │ +********** aadddd__ssiimmiillaarr__ttoorrrreenntt(()) aadddd__ccoolllleeccttiioonn(()) **********
│ │ │ │ │  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.
│ │ │ │ │ @@ -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
│ │ │ │ │ @@ -348,30 +348,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"
│ │ │ │ │ +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);
│ │ │ │ │ -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
│ │ │ │ │     , std::function const& f);
│ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p);
│ │ │ │ │  void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │     , 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);
│ │ │ │ │ +inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ +   , settings_interface const& settings
│ │ │ │ │ +   , 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
│ │ │ │ @@ -32,15 +32,15 @@
│ │ │ │  
    
│ │ │ │  
    Table of contents
    
│ │ │ │  
    
│ │ │ │ -
    
│ │ │ │ -
    async_write() async_read()
    
│ │ │ │ +
│ │ │ │ +[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
│ │ │ │ @@ -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 ();
│ │ │ │     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 (storage_holder const&) = delete;
│ │ │ │     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;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [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 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 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 void set_int (int name, int val) = 0;
│ │ │ │     virtual int get_int (int name) const = 0;
│ │ │ │ +   virtual std::string const& get_str (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 {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │  VVeerrssiioonn:: 2.0.11
│ │ │ │ │  _h_o_m_e
│ │ │ │ │  Table of contents
│ │ │ │ │      * _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
│ │ │ │ │            o _n_e_w___t_o_r_r_e_n_t_(_)
│ │ │ │ │            o _r_e_m_o_v_e___t_o_r_r_e_n_t_(_)
│ │ │ │ │ -          o _a_s_y_n_c___w_r_i_t_e_(_)_ _a_s_y_n_c___r_e_a_d_(_)
│ │ │ │ │ +          o _a_s_y_n_c___r_e_a_d_(_)_ _a_s_y_n_c___w_r_i_t_e_(_)
│ │ │ │ │            o _a_s_y_n_c___h_a_s_h_(_)
│ │ │ │ │            o _a_s_y_n_c___h_a_s_h_2_(_)
│ │ │ │ │            o _a_s_y_n_c___m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ │            o _a_s_y_n_c___r_e_l_e_a_s_e___f_i_l_e_s_(_)
│ │ │ │ │            o _a_s_y_n_c___c_h_e_c_k___f_i_l_e_s_(_)
│ │ │ │ │            o _a_s_y_n_c___s_t_o_p___t_o_r_r_e_n_t_(_)
│ │ │ │ │            o _a_s_y_n_c___r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ @@ -159,15 +159,15 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** 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__wwrriittee(()) aassyynncc__rreeaadd(()) **********
│ │ │ │ │ +********** 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;
│ │ │ │ │ @@ -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 ();
│ │ │ │ │     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 ();
│ │ │ │ │ -   ssttoorraaggee__hhoollddeerr (storage_holder const&) = delete;
│ │ │ │ │     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;
│ │ │ │ │  };
│ │ │ │ │  [_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 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 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 void sseett__iinntt (int name, int val) = 0;
│ │ │ │ │     virtual int ggeett__iinntt (int name) const = 0;
│ │ │ │ │ +   virtual std::string const& ggeett__ssttrr (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-Filter.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -56,19 +56,19 @@
│ │ │ │  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&&);
│ │ │ │     ip_filter& operator= (ip_filter&&);
│ │ │ │ -   ip_filter ();
│ │ │ │     ip_filter& operator= (ip_filter const&);
│ │ │ │ +   ip_filter ();
│ │ │ │     ~ip_filter ();
│ │ │ │ -   ip_filter (ip_filter&&);
│ │ │ │     ip_filter (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
│ │ │ │ @@ -154,19 +154,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&&);
│ │ │ │ -   ~port_filter ();
│ │ │ │     port_filter& operator= (port_filter&&);
│ │ │ │ +   port_filter& operator= (port_filter const&);
│ │ │ │     port_filter (port_filter const&);
│ │ │ │     port_filter ();
│ │ │ │ -   port_filter& operator= (port_filter const&);
│ │ │ │ +   ~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,19 +19,19 @@
│ │ │ │ │  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&&);
│ │ │ │ │     ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │ -   iipp__ffiilltteerr ();
│ │ │ │ │     ip_filter& ooppeerraattoorr== (ip_filter const&);
│ │ │ │ │ +   iipp__ffiilltteerr ();
│ │ │ │ │     ~~iipp__ffiilltteerr ();
│ │ │ │ │ -   iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │     iipp__ffiilltteerr (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;
│ │ │ │ │  
│ │ │ │ │ @@ -82,19 +82,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&&);
│ │ │ │ │ -   ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │     port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ +   port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │     ppoorrtt__ffiilltteerr (port_filter const&);
│ │ │ │ │     ppoorrtt__ffiilltteerr ();
│ │ │ │ │ -   port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │ +   ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │     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-PeerClass.html
│ │ │ │ @@ -30,15 +30,15 @@
│ │ │ │  
│ │ │ │  
    home
    
│ │ │ │  
    
│ │ │ │  
    Table of contents
    
│ │ │ │  
│ │ │ │  
    
│ │ │ │ @@ -104,16 +104,16 @@
│ │ │ │  
    Declared in "libtorrent/peer_class_type_filter.hpp"
    
│ │ │ │  
    peer_class_type_filter is a simple container for rules for adding and subtracting
│ │ │ │  peer-classes from peers. It is applied after the peer class filter is applied (which
│ │ │ │  is based on the peer's IP address).
    
│ │ │ │  
    │ │ │ │  struct peer_class_type_filter
│ │ │ │  {
│ │ │ │ -   void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │     void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ +   void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │     void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │     void allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │     std::uint32_t apply (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │     friend bool operator== (peer_class_type_filter const& lhs
│ │ │ │        , peer_class_type_filter const& rhs);
│ │ │ │  
│ │ │ │     enum socket_type_t
│ │ │ │ @@ -123,20 +123,20 @@
│ │ │ │        ssl_tcp_socket,
│ │ │ │        ssl_utp_socket,
│ │ │ │        i2p_socket,
│ │ │ │        num_socket_types,
│ │ │ │     };
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    add() remove()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    remove() add()
    
│ │ │ │  
    │ │ │ │ -void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │  void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ +void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │  
    
│ │ │ │  
    add() and remove() adds and removes a peer class to be added
│ │ │ │  to new peers based on socket type.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    disallow() allow()
    
│ │ │ │ ├── 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
│ │ │ │ │      * _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 _a_d_d_(_)_ _r_e_m_o_v_e_(_)
│ │ │ │ │ +          o _r_e_m_o_v_e_(_)_ _a_d_d_(_)
│ │ │ │ │            o _d_i_s_a_l_l_o_w_(_)_ _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
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ ppeeeerr__ccllaassss__iinnffoo ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_l_a_s_s_._h_p_p"
│ │ │ │ │  holds settings for a peer class. Used in _s_e_t___p_e_e_r___c_l_a_s_s_(_) and _g_e_t___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ @@ -59,16 +59,16 @@
│ │ │ │ │  ************ ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_._h_p_p"
│ │ │ │ │  peer_class_type_filter is a simple container for rules for adding and
│ │ │ │ │  subtracting peer-classes from peers. It is applied aafftteerr the peer class filter
│ │ │ │ │  is applied (which is based on the peer's IP address).
│ │ │ │ │  struct peer_class_type_filter
│ │ │ │ │  {
│ │ │ │ │ -   void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │     void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +   void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │     void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │     void aallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │     std::uint32_t aappppllyy (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │ │     friend bool ooppeerraattoorr==== (peer_class_type_filter const& lhs
│ │ │ │ │        , peer_class_type_filter const& rhs);
│ │ │ │ │  
│ │ │ │ │     enum socket_type_t
│ │ │ │ │ @@ -78,17 +78,17 @@
│ │ │ │ │        ssl_tcp_socket,
│ │ │ │ │        ssl_utp_socket,
│ │ │ │ │        i2p_socket,
│ │ │ │ │        num_socket_types,
│ │ │ │ │     };
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd(()) rreemmoovvee(()) **********
│ │ │ │ │ -void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +********** rreemmoovvee(()) aadddd(()) **********
│ │ │ │ │  void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │  add() and remove() adds and removes a peer class to be added to new peers based
│ │ │ │ │  on socket type.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ddiissaallllooww(()) aallllooww(()) **********
│ │ │ │ │  void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │  void aallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │  disallow() and allow() adds and removes a peer class to be removed from new
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Plugins.html
│ │ │ │ @@ -46,37 +46,37 @@
│ │ │ │  
  • on_tick()
    • 
│ │ │ │  
  • get_unchoke_priority()
    • 
│ │ │ │  
  • load_state()
    • 
│ │ │ │  
│ │ │ │  
│ │ │ │  
  • torrent_plugin
│ │ │ │  
    • 
│ │ │ │  
  • peer_plugin
│ │ │ │  
    • 
│ │ │ │  
  • crypto_plugin
│ │ │ │ @@ -345,16 +345,16 @@
│ │ │ │  
    Torrent plugins are associated with a single torrent and have a number
│ │ │ │  of functions called at certain events. Many of its functions have the
│ │ │ │  ability to change or override the default libtorrent behavior.
    
│ │ │ │  
    │ │ │ │  struct torrent_plugin
│ │ │ │  {
│ │ │ │     virtual std::shared_ptr<peer_plugin> new_connection (peer_connection_handle const&);
│ │ │ │ -   virtual void on_piece_pass (piece_index_t);
│ │ │ │     virtual void on_piece_failed (piece_index_t);
│ │ │ │ +   virtual void on_piece_pass (piece_index_t);
│ │ │ │     virtual void tick ();
│ │ │ │     virtual bool on_pause ();
│ │ │ │     virtual bool on_resume ();
│ │ │ │     virtual void on_files_checked ();
│ │ │ │     virtual void on_state (torrent_status::state_t);
│ │ │ │     virtual void on_add_peer (tcp::endpoint const&,
│ │ │ │        peer_source_flags_t, add_peer_flags_t);
│ │ │ │ @@ -376,38 +376,38 @@
│ │ │ │  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_failed() on_piece_pass()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_piece_pass() on_piece_failed()
    
│ │ │ │  
    │ │ │ │ -virtual void on_piece_pass (piece_index_t);
│ │ │ │  virtual void on_piece_failed (piece_index_t);
│ │ │ │ +virtual void on_piece_pass (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.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    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_pause() on_resume()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_resume() on_pause()
    
│ │ │ │  
    │ │ │ │  virtual bool on_pause ();
│ │ │ │  virtual bool on_resume ();
│ │ │ │  
    
│ │ │ │  
    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,51 +475,51 @@
│ │ │ │  {
│ │ │ │     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_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +   virtual bool on_have_all ();
│ │ │ │     virtual bool on_have_none ();
│ │ │ │     virtual bool on_choke ();
│ │ │ │ -   virtual bool on_unchoke ();
│ │ │ │ +   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │     virtual bool on_have (piece_index_t);
│ │ │ │ -   virtual bool on_dont_have (piece_index_t);
│ │ │ │ +   virtual bool on_not_interested ();
│ │ │ │     virtual bool on_request (peer_request const&);
│ │ │ │ +   virtual bool on_unchoke ();
│ │ │ │ +   virtual bool on_dont_have (piece_index_t);
│ │ │ │     virtual bool on_interested ();
│ │ │ │ -   virtual bool on_not_interested ();
│ │ │ │ -   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ -   virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ -   virtual bool on_have_all ();
│ │ │ │     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_allow_fast (piece_index_t);
│ │ │ │ -   virtual void sent_have_all ();
│ │ │ │ -   virtual void sent_choke ();
│ │ │ │ -   virtual void sent_reject_request (peer_request const&);
│ │ │ │ +   virtual void sent_suggest (piece_index_t);
│ │ │ │     virtual void sent_request (peer_request const&);
│ │ │ │ +   virtual void sent_reject_request (peer_request const&);
│ │ │ │     virtual void sent_cancel (peer_request const&);
│ │ │ │ +   virtual void sent_choke ();
│ │ │ │ +   virtual void sent_allow_fast (piece_index_t);
│ │ │ │ +   virtual void sent_have_all ();
│ │ │ │     virtual void sent_have_none ();
│ │ │ │ -   virtual void sent_suggest (piece_index_t);
│ │ │ │ -   virtual void sent_interested ();
│ │ │ │ -   virtual void sent_piece (peer_request const&);
│ │ │ │     virtual void sent_unchoke ();
│ │ │ │ -   virtual void sent_not_interested ();
│ │ │ │ +   virtual void sent_interested ();
│ │ │ │     virtual void sent_have (piece_index_t);
│ │ │ │ +   virtual void sent_not_interested ();
│ │ │ │ +   virtual void sent_piece (peer_request const&);
│ │ │ │     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);
│ │ │ │     virtual void on_piece_failed (piece_index_t);
│ │ │ │ +   virtual void on_piece_pass (piece_index_t);
│ │ │ │     virtual void tick ();
│ │ │ │     virtual bool write_request (peer_request const&);
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    type()
    
│ │ │ │  
    │ │ │ │ @@ -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_unchoke() on_interested() on_choke() on_have_none() on_have_all() on_allowed_fast() on_have() on_request() on_dont_have() on_not_interested() on_bitfield()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_bitfield() on_dont_have() on_have_none() on_unchoke() on_not_interested() on_interested() on_have() on_have_all() on_choke() on_request() on_allowed_fast()
    
│ │ │ │  
    │ │ │ │ +virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +virtual bool on_have_all ();
│ │ │ │  virtual bool on_have_none ();
│ │ │ │  virtual bool on_choke ();
│ │ │ │ -virtual bool on_unchoke ();
│ │ │ │ +virtual bool on_allowed_fast (piece_index_t);
│ │ │ │  virtual bool on_have (piece_index_t);
│ │ │ │ -virtual bool on_dont_have (piece_index_t);
│ │ │ │ +virtual bool on_not_interested ();
│ │ │ │  virtual bool on_request (peer_request const&);
│ │ │ │ +virtual bool on_unchoke ();
│ │ │ │ +virtual bool on_dont_have (piece_index_t);
│ │ │ │  virtual bool on_interested ();
│ │ │ │ -virtual bool on_not_interested ();
│ │ │ │ -virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ -virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ -virtual bool on_have_all ();
│ │ │ │  
    
│ │ │ │  
    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]
    
│ │ │ │ @@ -614,26 +614,26 @@
│ │ │ │  
    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_interested() sent_have() sent_not_interested() sent_unchoke() sent_piece()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    sent_interested() sent_piece() sent_not_interested() sent_unchoke() sent_have()
    
│ │ │ │  
    │ │ │ │ -virtual void sent_interested ();
│ │ │ │ -virtual void sent_piece (peer_request const&);
│ │ │ │  virtual void sent_unchoke ();
│ │ │ │ -virtual void sent_not_interested ();
│ │ │ │ +virtual void sent_interested ();
│ │ │ │  virtual void sent_have (piece_index_t);
│ │ │ │ +virtual void sent_not_interested ();
│ │ │ │ +virtual void sent_piece (peer_request const&);
│ │ │ │  
    
│ │ │ │  
    called after a choke message has been sent to the peer
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    sent_payload()
    
│ │ │ │  
    │ │ │ │  virtual void sent_payload (int /* bytes */);
│ │ │ │ @@ -669,21 +669,21 @@
│ │ │ │  
    
│ │ │ │  
    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_failed() on_piece_pass()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_piece_pass() on_piece_failed()
    
│ │ │ │  
    │ │ │ │ -virtual void on_piece_pass (piece_index_t);
│ │ │ │  virtual void on_piece_failed (piece_index_t);
│ │ │ │ +virtual void on_piece_pass (piece_index_t);
│ │ │ │  
    
│ │ │ │  
    called when a piece that this peer participated in either
│ │ │ │  fails or passes the hash_check
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    tick()
    
│ │ │ │  
    │ │ │ │ @@ -703,16 +703,16 @@
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    crypto_plugin
    
│ │ │ │  
    Declared in "libtorrent/extensions.hpp"
    
│ │ │ │  
    │ │ │ │  struct crypto_plugin
│ │ │ │  {
│ │ │ │ -   virtual void set_outgoing_key (span<char const> key) = 0;
│ │ │ │     virtual void set_incoming_key (span<char const> key) = 0;
│ │ │ │ +   virtual void set_outgoing_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()
    
│ │ │ │  
    │ │ │ │ @@ -744,22 +744,22 @@
│ │ │ │     void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │     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_peer_interested () const;
│ │ │ │ +   bool has_peer_choked () const;
│ │ │ │     void maybe_unchoke_this_peer ();
│ │ │ │     void choke_this_peer ();
│ │ │ │     void get_peer_info (peer_info& p) const;
│ │ │ │     torrent_handle associated_torrent () const;
│ │ │ │ -   tcp::endpoint local_endpoint () const;
│ │ │ │     tcp::endpoint const& remote () const;
│ │ │ │ +   tcp::endpoint local_endpoint () 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 ignore_unchoke_slots () const;
│ │ │ │     bool on_local_network () const;
│ │ │ │ @@ -767,18 +767,18 @@
│ │ │ │     void peer_log (peer_log_alert::direction_t direction
│ │ │ │        , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT(4,5);
│ │ │ │     bool should_log (peer_log_alert::direction_t direction) const;
│ │ │ │     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;
│ │ │ │ +   time_point time_of_last_unchoke () 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
    
│ │ │ │ @@ -789,16 +789,16 @@
│ │ │ │  
    │ │ │ │  struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │  {
│ │ │ │     explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ │     bool packet_finished () const;
│ │ │ │     bool support_extensions () 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 {}
│ │ │ │ │ @@ -15,38 +15,38 @@
│ │ │ │ │            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___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_)
│ │ │ │ │ +          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 _t_i_c_k_(_)
│ │ │ │ │ -          o _o_n___p_a_u_s_e_(_)_ _o_n___r_e_s_u_m_e_(_)
│ │ │ │ │ +          o _o_n___r_e_s_u_m_e_(_)_ _o_n___p_a_u_s_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___u_n_c_h_o_k_e_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___c_h_o_k_e_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___h_a_v_e___a_l_l
│ │ │ │ │ -            _(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___h_a_v_e_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)
│ │ │ │ │ -            _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)
│ │ │ │ │ +          o _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___u_n_c_h_o_k_e_(_)
│ │ │ │ │ +            _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___h_a_v_e_(_)_ _o_n___h_a_v_e___a_l_l_(_)
│ │ │ │ │ +            _o_n___c_h_o_k_e_(_)_ _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___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___u_n_c_h_o_k_e_(_)
│ │ │ │ │ -            _s_e_n_t___p_i_e_c_e_(_)
│ │ │ │ │ +          o _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)_ _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___u_n_c_h_o_k_e_(_)
│ │ │ │ │ +            _s_e_n_t___h_a_v_e_(_)
│ │ │ │ │            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 _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 _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_(_)
│ │ │ │ │ @@ -256,16 +256,16 @@
│ │ │ │ │  Torrent plugins are associated with a single torrent and have a number of
│ │ │ │ │  functions called at certain events. Many of its functions have the ability to
│ │ │ │ │  change or override the default libtorrent behavior.
│ │ │ │ │  struct torrent_plugin
│ │ │ │ │  {
│ │ │ │ │     virtual std::shared_ptr nneeww__ccoonnnneeccttiioonn (peer_connection_handle
│ │ │ │ │  const&);
│ │ │ │ │ -   virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │     virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ +   virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │     virtual void ttiicckk ();
│ │ │ │ │     virtual bool oonn__ppaauussee ();
│ │ │ │ │     virtual bool oonn__rreessuummee ();
│ │ │ │ │     virtual void oonn__ffiilleess__cchheecckkeedd ();
│ │ │ │ │     virtual void oonn__ssttaattee (torrent_status::state_t);
│ │ │ │ │     virtual void oonn__aadddd__ppeeeerr (tcp::endpoint const&,
│ │ │ │ │        peer_source_flags_t, add_peer_flags_t);
│ │ │ │ │ @@ -285,28 +285,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__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │ -virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ +********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) **********
│ │ │ │ │  virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ +virtual void oonn__ppiieeccee__ppaassss (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__ppaauussee(()) oonn__rreessuummee(()) **********
│ │ │ │ │ +********** oonn__rreessuummee(()) oonn__ppaauussee(()) **********
│ │ │ │ │  virtual bool oonn__ppaauussee ();
│ │ │ │ │  virtual bool oonn__rreessuummee ();
│ │ │ │ │  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,51 +354,51 @@
│ │ │ │ │  {
│ │ │ │ │     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__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ +   virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │     virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │     virtual bool oonn__cchhookkee ();
│ │ │ │ │ -   virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ +   virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │     virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ -   virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ +   virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │     virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +   virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ +   virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │     virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ -   virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ -   virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ -   virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ -   virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │     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__aallllooww__ffaasstt (piece_index_t);
│ │ │ │ │ -   virtual void sseenntt__hhaavvee__aallll ();
│ │ │ │ │ -   virtual void sseenntt__cchhookkee ();
│ │ │ │ │ -   virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +   virtual void sseenntt__ssuuggggeesstt (piece_index_t);
│ │ │ │ │     virtual void sseenntt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +   virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │     virtual void sseenntt__ccaanncceell (peer_request const&);
│ │ │ │ │ +   virtual void sseenntt__cchhookkee ();
│ │ │ │ │ +   virtual void sseenntt__aallllooww__ffaasstt (piece_index_t);
│ │ │ │ │ +   virtual void sseenntt__hhaavvee__aallll ();
│ │ │ │ │     virtual void sseenntt__hhaavvee__nnoonnee ();
│ │ │ │ │ -   virtual void sseenntt__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ -   virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ -   virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │     virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ -   virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +   virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │     virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ +   virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +   virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │     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);
│ │ │ │ │     virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ +   virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │     virtual void ttiicckk ();
│ │ │ │ │     virtual bool wwrriittee__rreeqquueesstt (peer_request const&);
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttyyppee(()) **********
│ │ │ │ │  virtual string_view ttyyppee () const;
│ │ │ │ │  This function is expected to return the name of the _p_l_u_g_i_n.
│ │ │ │ │ @@ -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__uunncchhookkee(()) oonn__iinntteerreesstteedd(()) oonn__cchhookkee(()) oonn__hhaavvee__nnoonnee(()) oonn__hhaavvee__aallll(())
│ │ │ │ │ -oonn__aalllloowweedd__ffaasstt(()) oonn__hhaavvee(()) oonn__rreeqquueesstt(()) oonn__ddoonntt__hhaavvee(()) oonn__nnoott__iinntteerreesstteedd(())
│ │ │ │ │ -oonn__bbiittffiieelldd(()) **********
│ │ │ │ │ +********** oonn__bbiittffiieelldd(()) oonn__ddoonntt__hhaavvee(()) oonn__hhaavvee__nnoonnee(()) oonn__uunncchhookkee(())
│ │ │ │ │ +oonn__nnoott__iinntteerreesstteedd(()) oonn__iinntteerreesstteedd(()) oonn__hhaavvee(()) oonn__hhaavvee__aallll(()) oonn__cchhookkee(())
│ │ │ │ │ +oonn__rreeqquueesstt(()) oonn__aalllloowweedd__ffaasstt(()) **********
│ │ │ │ │ +virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ +virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │  virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │  virtual bool oonn__cchhookkee ();
│ │ │ │ │ -virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ +virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │  virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ +virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │  virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ +virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │  virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ -virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ -virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ -virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ -virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │  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__iinntteerreesstteedd(()) sseenntt__hhaavvee(()) sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__uunncchhookkee(())
│ │ │ │ │ -sseenntt__ppiieeccee(()) **********
│ │ │ │ │ -virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ -virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ +********** sseenntt__iinntteerreesstteedd(()) sseenntt__ppiieeccee(()) sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__uunncchhookkee(())
│ │ │ │ │ +sseenntt__hhaavvee(()) **********
│ │ │ │ │  virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ -virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │  virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ +virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │  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]
│ │ │ │ │ @@ -490,17 +490,17 @@
│ │ │ │ │  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__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │ -virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ +********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) **********
│ │ │ │ │  virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ +virtual void oonn__ppiieeccee__ppaassss (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 ();
│ │ │ │ │  called approximately once every second
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -510,16 +510,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__oouuttggooiinngg__kkeeyy (span key) = 0;
│ │ │ │ │     virtual void sseett__iinnccoommiinngg__kkeeyy (span key) = 0;
│ │ │ │ │ +   virtual void sseett__oouuttggooiinngg__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**//) =
│ │ │ │ │ @@ -546,22 +546,22 @@
│ │ │ │ │     void aadddd__eexxtteennssiioonn (std::shared_ptr);
│ │ │ │ │     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__ppeeeerr__iinntteerreesstteedd () const;
│ │ │ │ │ +   bool hhaass__ppeeeerr__cchhookkeedd () const;
│ │ │ │ │     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 llooccaall__eennddppooiinntt () 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__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 iiggnnoorree__uunncchhookkee__sslloottss () const;
│ │ │ │ │     bool oonn__llooccaall__nneettwwoorrkk () const;
│ │ │ │ │ @@ -570,18 +570,18 @@
│ │ │ │ │        , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT
│ │ │ │ │  (4,5);
│ │ │ │ │     bool sshhoouulldd__lloogg (peer_log_alert::direction_t direction) const;
│ │ │ │ │     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;
│ │ │ │ │ +   time_point ttiimmee__ooff__llaasstt__uunncchhookkee () 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
│ │ │ │ │ @@ -589,16 +589,16 @@
│ │ │ │ │  libtorrent versions.
│ │ │ │ │  struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │ │  {
│ │ │ │ │     explicit bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (peer_connection_handle pc);
│ │ │ │ │     bool ppaacckkeett__ffiinniisshheedd () const;
│ │ │ │ │     bool ssuuppppoorrtt__eexxtteennssiioonnss () 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
│ │ │ │ @@ -29,31 +29,31 @@
│ │ │ │  
│ │ │ │  
│ │ │ │  
    home
    
│ │ │ │  
    
│ │ │ │  
    Table of contents
    
│ │ │ │  
│ │ │ │  
    
│ │ │ │  [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 (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 (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
│ │ │ │ +   , error_code& ec, 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
│ │ │ │ @@ -61,33 +61,33 @@
│ │ │ │  
    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_buf() write_resume_data()
    
│ │ │ │ +
│ │ │ │ +[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_buf() write_torrent_file()
    
│ │ │ │  
    Declared in "libtorrent/write_resume_data.hpp"
    
│ │ │ │  
    │ │ │ │ -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);
│ │ │ │  std::vector<char> write_torrent_file_buf (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:
    
│ │ │ │  
      
│ │ │ │  
    • The add_torrent_params object passed to this function does not contain the
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,27 +1,27 @@
│ │ │ │ │  >
│ │ │ │ │  _[_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
│ │ │ │ │      * _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___b_u_f_(_)_ _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_(_)_ _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___t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ │  [_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 (bdecode_node const& rd
│ │ │ │ │ -   , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ │ -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 (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
│ │ │ │ │ +   , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ │  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.
│ │ │ │ │ @@ -29,26 +29,26 @@
│ │ │ │ │  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__bbuuff(()) wwrriittee__rreessuummee__ddaattaa(()) ************
│ │ │ │ │ +************ wwrriittee__rreessuummee__ddaattaa(()) wwrriittee__rreessuummee__ddaattaa__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__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(()) ************
│ │ │ │ │  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);
│ │ │ │ │  entry wwrriittee__ttoorrrreenntt__ffiillee (add_torrent_params const& atp, write_torrent_flags_t
│ │ │ │ │  flags);
│ │ │ │ │ -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);
│ │ │ │ │  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
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Session.html
│ │ │ │ @@ -34,109 +34,109 @@
│ │ │ │  
│ │ │ │  
    
│ │ │ │  [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 ();
│ │ │ │     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);
│ │ │ │ +   session_params (settings_pack const& 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 ();
│ │ │ │  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 const& sp
│ │ │ │ -      , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │  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);
│ │ │ │  
    
│ │ │ │  
    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
    
│ │ │ │  
    
│ │ │ │ @@ -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 const&);
│ │ │ │ -   ~session_proxy ();
│ │ │ │ -   session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ +   session_proxy ();
│ │ │ │     session_proxy (session_proxy&&) noexcept;
│ │ │ │ +   session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │     session_proxy& operator= (session_proxy const&) &;
│ │ │ │ -   session_proxy ();
│ │ │ │ +   ~session_proxy ();
│ │ │ │ +   session_proxy (session_proxy const&);
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    session_proxy() ~session_proxy() operator=()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    operator=() session_proxy() ~session_proxy()
    
│ │ │ │  
    │ │ │ │ -session_proxy (session_proxy const&);
│ │ │ │ -~session_proxy ();
│ │ │ │ -session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ +session_proxy ();
│ │ │ │  session_proxy (session_proxy&&) noexcept;
│ │ │ │ +session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │  session_proxy& operator= (session_proxy const&) &;
│ │ │ │ -session_proxy ();
│ │ │ │ +~session_proxy ();
│ │ │ │ +session_proxy (session_proxy const&);
│ │ │ │  
    
│ │ │ │  
    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 ();
│ │ │ │     explicit session (session_params&& params);
│ │ │ │ -   explicit session (session_params const& params);
│ │ │ │     session (session_params&& params, session_flags_t flags);
│ │ │ │ -   session ();
│ │ │ │ -   session (session_params&& params, io_context& ios);
│ │ │ │ -   session (session_params const& params, io_context& ios);
│ │ │ │ -   session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +   session (session_params const& params, session_flags_t flags);
│ │ │ │ +   explicit session (session_params const& params);
│ │ │ │     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_params&& params, io_context& ios);
│ │ │ │     ~session ();
│ │ │ │     session_proxy abort ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    session()
    
│ │ │ │  
    │ │ │ │ -session (session_params const& params, session_flags_t flags);
│ │ │ │ +session ();
│ │ │ │  explicit session (session_params&& params);
│ │ │ │ -explicit session (session_params const& params);
│ │ │ │  session (session_params&& params, session_flags_t flags);
│ │ │ │ -session ();
│ │ │ │ +session (session_params const& params, session_flags_t flags);
│ │ │ │ +explicit session (session_params const& params);
│ │ │ │  
    
│ │ │ │  
    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 (session_params const& params, io_context& ios);
│ │ │ │ -session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │  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_params&& 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.
    
│ │ │ │  
    
│ │ │ │ @@ -328,24 +328,24 @@
│ │ │ │        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 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 find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ +   void async_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);
│ │ │ │ +   torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │     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 async_add_torrent (add_torrent_params&& params);
│ │ │ │ -   bool is_paused () const;
│ │ │ │     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());
│ │ │ │ @@ -358,35 +358,35 @@
│ │ │ │     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);
│ │ │ │ -   ip_filter get_ip_filter () const;
│ │ │ │     void set_ip_filter (ip_filter f);
│ │ │ │ +   ip_filter get_ip_filter () const;
│ │ │ │     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 ssl_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_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);
│ │ │ │ -   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 set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │     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&&);
│ │ │ │ -   void apply_settings (settings_pack const&);
│ │ │ │     void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ -   alert* wait_for_alert (time_duration max_wait);
│ │ │ │     void set_alert_notify (std::function<void()> const& fun);
│ │ │ │ +   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 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;
│ │ │ │ @@ -420,18 +420,18 @@
│ │ │ │  
    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]
    
│ │ │ │ -
    
│ │ │ │ -
    get_torrent_status() refresh_torrent_status()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    refresh_torrent_status() get_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;
│ │ │ │  
    
│ │ │ │ @@ -507,41 +507,41 @@
│ │ │ │  
    │ │ │ │  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()
    
│ │ │ │  
    │ │ │ │ -torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │  std::vector<torrent_handle> get_torrents () const;
│ │ │ │ +torrent_handle find_torrent (sha1_hash const& info_hash) 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]
    
│ │ │ │  
    
│ │ │ │  
    add_torrent() async_add_torrent()
    
│ │ │ │  
    │ │ │ │ +void async_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);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │  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 async_add_torrent (add_torrent_params&& params);
│ │ │ │  
    
│ │ │ │  
    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
│ │ │ │ @@ -566,22 +566,22 @@
│ │ │ │  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]
    
│ │ │ │ -
    
│ │ │ │ -
    pause() is_paused() resume()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    resume() is_paused() pause()
    
│ │ │ │  
    │ │ │ │ -bool is_paused () const;
│ │ │ │  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
│ │ │ │ @@ -690,18 +690,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_announce() dht_get_peers()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    dht_get_peers() dht_announce()
    
│ │ │ │  
    │ │ │ │  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.
    
│ │ │ │ @@ -792,16 +792,16 @@
│ │ │ │  ses.add_extension(&lt::create_smart_ban_plugin);
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    set_ip_filter() get_ip_filter()
    
│ │ │ │  
    │ │ │ │ -ip_filter get_ip_filter () const;
│ │ │ │  void set_ip_filter (ip_filter f);
│ │ │ │ +ip_filter get_ip_filter () const;
│ │ │ │  
    
│ │ │ │  
    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
│ │ │ │ @@ -813,33 +813,33 @@
│ │ │ │  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]
    │ │ │ │ -
    │ │ │ │ -

    listen_port() is_listening() ssl_listen_port()

    │ │ │ │ + │ │ │ │ +[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 ssl_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()

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

    get_peer_class_filter() set_peer_class_filter()

    │ │ │ │ 
    │ │ │ │  void set_peer_class_filter (ip_filter const& f);
│ │ │ │  ip_filter get_peer_class_filter () const;
│ │ │ │
    │ │ │ │

    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.

    │ │ │ │ @@ -867,16 +867,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:

    │ │ │ │
      │ │ │ │ @@ -915,21 +915,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()

    │ │ │ │ 
    │ │ │ │ -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 set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │
    │ │ │ │

    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 │ │ │ │ @@ -974,30 +974,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&);
│ │ │ │  settings_pack get_settings () const;
│ │ │ │  void apply_settings (settings_pack&&);
│ │ │ │ -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]
    │ │ │ │ -
    │ │ │ │ -

    wait_for_alert() set_alert_notify() pop_alerts()

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

    pop_alerts() set_alert_notify() wait_for_alert()

    │ │ │ │ 
    │ │ │ │  void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ -alert* wait_for_alert (time_duration max_wait);
│ │ │ │  void set_alert_notify (std::function<void()> const& fun);
│ │ │ │ +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 │ │ │ │ @@ -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] │ │ │ │ │ │ │ │ -
    │ │ │ │ -

    read_session_params() write_session_params() write_session_params_buf()

    │ │ │ │ +
    │ │ │ │ +

    write_session_params() read_session_params() write_session_params_buf()

    │ │ │ │

    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());
│ │ │ │ +session_params read_session_params (bdecode_node const& e
│ │ │ │ +   , 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 (span<char const> buf
│ │ │ │     , 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());
│ │ │ │
    │ │ │ │

    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,95 +3,95 @@ │ │ │ │ │ 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 _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_(_) │ │ │ │ │ * _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 _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 _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 _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 _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_(_)_ _i_s___p_a_u_s_e_d_(_)_ _r_e_s_u_m_e_(_) │ │ │ │ │ + o _r_e_s_u_m_e_(_)_ _i_s___p_a_u_s_e_d_(_)_ _p_a_u_s_e_(_) │ │ │ │ │ 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___a_n_n_o_u_n_c_e_(_)_ _d_h_t___g_e_t___p_e_e_r_s_(_) │ │ │ │ │ + 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 _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 _l_i_s_t_e_n___p_o_r_t_(_)_ _i_s___l_i_s_t_e_n_i_n_g_(_)_ _s_s_l___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 _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 _g_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)_ _s_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 _w_a_i_t___f_o_r___a_l_e_r_t_(_)_ _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _p_o_p___a_l_e_r_t_s_(_) │ │ │ │ │ + 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 _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_(_) │ │ │ │ │ - * _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_(_)_ _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 (); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack const& sp); │ │ │ │ │ - sseessssiioonn__ppaarraammss (settings_pack const& sp │ │ │ │ │ - , std::vector> exts); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp │ │ │ │ │ , std::vector> exts); │ │ │ │ │ + sseessssiioonn__ppaarraammss (settings_pack const& 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 (); │ │ │ │ │ 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 const& sp │ │ │ │ │ - , std::vector> exts); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp │ │ │ │ │ , std::vector> exts); │ │ │ │ │ +sseessssiioonn__ppaarraammss (settings_pack const& 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 │ │ │ │ │ @@ -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 (session_proxy const&); │ │ │ │ │ - ~~sseessssiioonn__pprrooxxyy (); │ │ │ │ │ - session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept; │ │ │ │ │ + sseessssiioonn__pprrooxxyy (); │ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept; │ │ │ │ │ + session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept; │ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy const&) &; │ │ │ │ │ - sseessssiioonn__pprrooxxyy (); │ │ │ │ │ + ~~sseessssiioonn__pprrooxxyy (); │ │ │ │ │ + sseessssiioonn__pprrooxxyy (session_proxy const&); │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseessssiioonn__pprrooxxyy(()) ~~sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) ********** │ │ │ │ │ -sseessssiioonn__pprrooxxyy (session_proxy const&); │ │ │ │ │ -~~sseessssiioonn__pprrooxxyy (); │ │ │ │ │ -session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept; │ │ │ │ │ +********** ooppeerraattoorr==(()) sseessssiioonn__pprrooxxyy(()) ~~sseessssiioonn__pprrooxxyy(()) ********** │ │ │ │ │ +sseessssiioonn__pprrooxxyy (); │ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept; │ │ │ │ │ +session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept; │ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy const&) &; │ │ │ │ │ -sseessssiioonn__pprrooxxyy (); │ │ │ │ │ +~~sseessssiioonn__pprrooxxyy (); │ │ │ │ │ +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 │ │ │ │ │ @@ -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 (); │ │ │ │ │ explicit sseessssiioonn (session_params&& params); │ │ │ │ │ - explicit sseessssiioonn (session_params const& params); │ │ │ │ │ sseessssiioonn (session_params&& params, session_flags_t flags); │ │ │ │ │ - sseessssiioonn (); │ │ │ │ │ - sseessssiioonn (session_params&& params, io_context& ios); │ │ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ + sseessssiioonn (session_params const& params, session_flags_t flags); │ │ │ │ │ + explicit sseessssiioonn (session_params const& params); │ │ │ │ │ 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_params&& params, io_context& ios); │ │ │ │ │ ~~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 (); │ │ │ │ │ explicit sseessssiioonn (session_params&& params); │ │ │ │ │ -explicit sseessssiioonn (session_params const& params); │ │ │ │ │ sseessssiioonn (session_params&& params, session_flags_t flags); │ │ │ │ │ -sseessssiioonn (); │ │ │ │ │ +sseessssiioonn (session_params const& params, session_flags_t flags); │ │ │ │ │ +explicit sseessssiioonn (session_params const& params); │ │ │ │ │ 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); │ │ │ │ │ -sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ -sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ 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_params&& 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 │ │ │ │ │ @@ -242,25 +242,25 @@ │ │ │ │ │ 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 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 ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const; │ │ │ │ │ + void aassyynncc__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 const& params); │ │ │ │ │ - torrent_handle 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); │ │ │ │ │ - bool iiss__ppaauusseedd () const; │ │ │ │ │ + void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ 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()); │ │ │ │ │ @@ -276,35 +276,35 @@ │ │ │ │ │ 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); │ │ │ │ │ - ip_filter ggeett__iipp__ffiilltteerr () const; │ │ │ │ │ void sseett__iipp__ffiilltteerr (ip_filter f); │ │ │ │ │ + ip_filter ggeett__iipp__ffiilltteerr () const; │ │ │ │ │ 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 ssssll__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__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); │ │ │ │ │ - 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 sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci); │ │ │ │ │ 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&&); │ │ │ │ │ - void aappppllyy__sseettttiinnggss (settings_pack const&); │ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts); │ │ │ │ │ - alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun); │ │ │ │ │ + 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 rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options = │ │ │ │ │ reopen_map_ports); │ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const; │ │ │ │ │ │ │ │ │ │ @@ -333,15 +333,15 @@ │ │ │ │ │ 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] │ │ │ │ │ -********** ggeett__ttoorrrreenntt__ssttaattuuss(()) rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) ********** │ │ │ │ │ +********** rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) ggeett__ttoorrrreenntt__ssttaattuuss(()) ********** │ │ │ │ │ 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; │ │ │ │ │ Note │ │ │ │ │ these calls are potentially expensive and won't scale well with lots of │ │ │ │ │ @@ -397,31 +397,31 @@ │ │ │ │ │ ********** sseett__ddhhtt__ssttaattee(()) ********** │ │ │ │ │ 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(()) ********** │ │ │ │ │ -torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const; │ │ │ │ │ +********** ggeett__ttoorrrreennttss(()) ffiinndd__ttoorrrreenntt(()) ********** │ │ │ │ │ std::vector ggeett__ttoorrrreennttss () const; │ │ │ │ │ +torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) 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] │ │ │ │ │ ********** aadddd__ttoorrrreenntt(()) aassyynncc__aadddd__ttoorrrreenntt(()) ********** │ │ │ │ │ +void aassyynncc__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); │ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec); │ │ │ │ │ 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); │ │ │ │ │ -void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ 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 │ │ │ │ │ @@ -442,17 +442,17 @@ │ │ │ │ │ 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] │ │ │ │ │ -********** ppaauussee(()) iiss__ppaauusseedd(()) rreessuummee(()) ********** │ │ │ │ │ -bool iiss__ppaauusseedd () const; │ │ │ │ │ +********** rreessuummee(()) iiss__ppaauusseedd(()) ppaauussee(()) ********** │ │ │ │ │ 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] │ │ │ │ │ @@ -529,15 +529,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__aannnnoouunnccee(()) ddhhtt__ggeett__ppeeeerrss(()) ********** │ │ │ │ │ +********** ddhhtt__ggeett__ppeeeerrss(()) ddhhtt__aannnnoouunnccee(()) ********** │ │ │ │ │ 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 │ │ │ │ │ @@ -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] │ │ │ │ │ ********** sseett__iipp__ffiilltteerr(()) ggeett__iipp__ffiilltteerr(()) ********** │ │ │ │ │ -ip_filter ggeett__iipp__ffiilltteerr () const; │ │ │ │ │ void sseett__iipp__ffiilltteerr (ip_filter f); │ │ │ │ │ +ip_filter ggeett__iipp__ffiilltteerr () const; │ │ │ │ │ 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,25 +615,25 @@ │ │ │ │ │ ********** 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] │ │ │ │ │ -********** lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) ssssll__lliisstteenn__ppoorrtt(()) ********** │ │ │ │ │ -unsigned short ssssll__lliisstteenn__ppoorrtt () const; │ │ │ │ │ +********** lliisstteenn__ppoorrtt(()) ssssll__lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) ********** │ │ │ │ │ unsigned short lliisstteenn__ppoorrtt () const; │ │ │ │ │ bool iiss__lliisstteenniinngg () const; │ │ │ │ │ +unsigned short ssssll__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(()) ********** │ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) sseett__ppeeeerr__ccllaassss__ffiilltteerr(()) ********** │ │ │ │ │ void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f); │ │ │ │ │ ip_filter ggeett__ppeeeerr__ccllaassss__ffiilltteerr () const; │ │ │ │ │ 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 │ │ │ │ │ @@ -653,16 +653,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 │ │ │ │ │ @@ -690,17 +690,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(()) ********** │ │ │ │ │ -void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci); │ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss(()) sseett__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); │ │ │ │ │ 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 │ │ │ │ │ @@ -731,25 +731,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&); │ │ │ │ │ settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&); │ │ │ │ │ -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] │ │ │ │ │ -********** wwaaiitt__ffoorr__aalleerrtt(()) sseett__aalleerrtt__nnoottiiffyy(()) ppoopp__aalleerrttss(()) ********** │ │ │ │ │ +********** 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); │ │ │ │ │ +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. │ │ │ │ │ @@ -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] │ │ │ │ │ -************ rreeaadd__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) │ │ │ │ │ +************ 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" │ │ │ │ │ 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()); │ │ │ │ │ entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp │ │ │ │ │ , 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()); │ │ │ │ │ -session_params rreeaadd__sseessssiioonn__ppaarraammss (bdecode_node const& e │ │ │ │ │ - , 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,33 +29,33 @@ │ │ │ │ │ │ │ │ │ │ │ │

    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().

    │ │ │ │ @@ -4598,24 +4598,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_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ -   void set_bool (int name, bool val) override;
│ │ │ │ +   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;
│ │ │ │     bool has_val (int name) const override;
│ │ │ │     void clear ();
│ │ │ │     void clear (int name);
│ │ │ │ -   bool get_bool (int name) const override;
│ │ │ │     std::string const& get_str (int name) const override;
│ │ │ │     int get_int (int name) const override;
│ │ │ │ +   bool get_bool (int name) const override;
│ │ │ │     void for_each (Fun&& f) const;
│ │ │ │  
│ │ │ │     enum type_bases
│ │ │ │     {
│ │ │ │        string_type_base,
│ │ │ │        int_type_base,
│ │ │ │        bool_type_base,
│ │ │ │ @@ -4686,22 +4686,22 @@
│ │ │ │        socks5_pw,
│ │ │ │        http,
│ │ │ │        http_pw,
│ │ │ │     };
│ │ │ │  };
│ │ │ │
    │ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -

    set_str() set_int() set_bool()

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

    set_str() set_bool() set_int()

    │ │ │ │ 
    │ │ │ │ -void set_int (int name, int val) override;
│ │ │ │  void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ -void set_bool (int name, bool val) override;
│ │ │ │ +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;
│ │ │ │
    │ │ │ │

    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()

    │ │ │ │ @@ -4721,23 +4721,23 @@ │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    clear()

    │ │ │ │ 
    │ │ │ │  void clear (int name);
│ │ │ │
    │ │ │ │

    clear a specific setting from the pack

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

    get_bool() get_str() get_int()

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

    get_str() get_int() get_bool()

    │ │ │ │ 
    │ │ │ │ -bool get_bool (int name) const override;
│ │ │ │  std::string const& get_str (int name) const override;
│ │ │ │  int get_int (int name) const override;
│ │ │ │ +bool get_bool (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]
    │ │ │ │ @@ -5154,18 +5154,18 @@ │ │ │ │ Tribler │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │

    There's an informal directory of client id's here.

    │ │ │ │

    The major, minor, revision and tag parameters are used to │ │ │ │ identify the version of your client.

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

    high_performance_seed() min_memory_usage()

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

    min_memory_usage() high_performance_seed()

    │ │ │ │

    Declared in "libtorrent/session.hpp"

    │ │ │ │ 
    │ │ │ │  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 │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,30 +1,30 @@ │ │ │ │ │ > │ │ │ │ │ _[_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___s_t_r_(_)_ _s_e_t___i_n_t_(_)_ _s_e_t___b_o_o_l_(_) │ │ │ │ │ + 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 _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 │ │ │ │ │ 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_(_) │ │ │ │ │ - * _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)_ _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_) │ │ │ │ │ + * _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_(_) │ │ │ │ │ * _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 │ │ │ │ │ @@ -1435,24 +1435,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__iinntt (int name, flags::bitfield_flag const val); │ │ │ │ │ - void sseett__bbooooll (int name, bool val) override; │ │ │ │ │ + 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; │ │ │ │ │ bool hhaass__vvaall (int name) const override; │ │ │ │ │ void cclleeaarr (); │ │ │ │ │ void cclleeaarr (int name); │ │ │ │ │ - bool ggeett__bbooooll (int name) const override; │ │ │ │ │ std::string const& ggeett__ssttrr (int name) const override; │ │ │ │ │ int ggeett__iinntt (int name) const override; │ │ │ │ │ + bool ggeett__bbooooll (int name) const override; │ │ │ │ │ void ffoorr__eeaacchh (Fun&& f) const; │ │ │ │ │ │ │ │ │ │ enum type_bases │ │ │ │ │ { │ │ │ │ │ string_type_base, │ │ │ │ │ int_type_base, │ │ │ │ │ bool_type_base, │ │ │ │ │ @@ -1522,19 +1522,19 @@ │ │ │ │ │ socks5, │ │ │ │ │ socks5_pw, │ │ │ │ │ http, │ │ │ │ │ http_pw, │ │ │ │ │ }; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseett__ssttrr(()) sseett__iinntt(()) sseett__bbooooll(()) ********** │ │ │ │ │ -void sseett__iinntt (int name, int 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__iinntt (int name, int val) override; │ │ │ │ │ void sseett__ssttrr (int name, std::string val) override; │ │ │ │ │ +void sseett__bbooooll (int name, bool 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 │ │ │ │ │ @@ -1545,18 +1545,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__ssttrr(()) ggeett__iinntt(()) ********** │ │ │ │ │ -bool ggeett__bbooooll (int name) const override; │ │ │ │ │ +********** ggeett__ssttrr(()) ggeett__iinntt(()) ggeett__bbooooll(()) ********** │ │ │ │ │ std::string const& ggeett__ssttrr (int name) const override; │ │ │ │ │ int ggeett__iinntt (int name) const override; │ │ │ │ │ +bool ggeett__bbooooll (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" │ │ │ │ │ @@ -1708,15 +1708,15 @@ │ │ │ │ │ |_D_E_ _ _ _ _ _ _|_D_e_l_u_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ | │ │ │ │ │ |_A_Z_ _ _ _ _ _ _|_A_z_u_r_e_u_s_ _ _ _ _ _ _ _ _ _ _ _ _ | │ │ │ │ │ |_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] │ │ │ │ │ -************ hhiigghh__ppeerrffoorrmmaannccee__sseeeedd(()) mmiinn__mmeemmoorryy__uussaaggee(()) ************ │ │ │ │ │ +************ 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 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. │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Stats.html │ │ │ │ @@ -29,15 +29,15 @@ │ │ │ │ │ │ │ │ │ │ │ │

    home

    │ │ │ │
    │ │ │ │

    Table of contents

    │ │ │ │ │ │ │ │ @@ -45,28 +45,28 @@ │ │ │ │ [report issue]
    │ │ │ │

    counters

    │ │ │ │

    Declared in "libtorrent/performance_counters.hpp"

    │ │ │ │ 
    │ │ │ │  struct counters
│ │ │ │  {
│ │ │ │     counters () ;
│ │ │ │ -   counters& operator= (counters const&) & ;
│ │ │ │     counters (counters const&) ;
│ │ │ │ -   std::int64_t operator[] (int i) const ;
│ │ │ │ +   counters& operator= (counters const&) & ;
│ │ │ │     std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ +   std::int64_t operator[] (int i) const ;
│ │ │ │     void set_value (int c, std::int64_t value) ;
│ │ │ │     void blend_stats_counter (int c, std::int64_t value, int ratio) ;
│ │ │ │  };
│ │ │ │
    │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -

    operator[]() inc_stats_counter()

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

    inc_stats_counter() operator[]()

    │ │ │ │ 
    │ │ │ │ -std::int64_t operator[] (int i) const ;
│ │ │ │  std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ +std::int64_t operator[] (int i) const ;
│ │ │ │
    │ │ │ │

    returns the new value

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

    stats_metric

    │ │ │ │

    Declared in "libtorrent/session_stats.hpp"

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,35 +1,35 @@ │ │ │ │ │ > │ │ │ │ │ _[_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_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 │ │ │ │ │ [_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 ooppeerraattoorr[[]] (int i) const ; │ │ │ │ │ + counters& ooppeerraattoorr== (counters const&) & ; │ │ │ │ │ std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ; │ │ │ │ │ + std::int64_t ooppeerraattoorr[[]] (int i) const ; │ │ │ │ │ void sseett__vvaalluuee (int c, std::int64_t value) ; │ │ │ │ │ void bblleenndd__ssttaattss__ccoouunntteerr (int c, std::int64_t value, int ratio) ; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ooppeerraattoorr[[]](()) iinncc__ssttaattss__ccoouunntteerr(()) ********** │ │ │ │ │ -std::int64_t ooppeerraattoorr[[]] (int i) const ; │ │ │ │ │ +********** iinncc__ssttaattss__ccoouunntteerr(()) ooppeerraattoorr[[]](()) ********** │ │ │ │ │ std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ; │ │ │ │ │ +std::int64_t ooppeerraattoorr[[]] (int i) const ; │ │ │ │ │ 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 │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Storage.html │ │ │ │ @@ -40,29 +40,29 @@ │ │ │ │
  • 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()
    • │ │ │ │ +
  • name() set_name()
    • │ │ │ │
  • swap()
    • │ │ │ │
  • canonicalize()
    • │ │ │ │ -
  • hash() file_path() file_name() mtime() root_ptr() file_size() pad_file_at() file_offset() symlink() root()
    • │ │ │ │ +
  • file_offset() root_ptr() mtime() file_name() file_path() hash() symlink() root() file_size() pad_file_at()
    • │ │ │ │
  • file_num_pieces() file_piece_range() file_num_blocks()
    • │ │ │ │ -
  • file_first_piece_node() file_first_block_node()
    • │ │ │ │ +
  • file_first_block_node() file_first_piece_node()
    • │ │ │ │
  • file_path_hash()
    • │ │ │ │
  • all_path_hashes()
    • │ │ │ │
  • file_flags()
    • │ │ │ │
  • file_absolute_path()
    • │ │ │ │
  • file_index_at_piece() file_index_at_offset()
    • │ │ │ │
  • file_index_for_root()
    • │ │ │ │
  • piece_index_at_file()
    • │ │ │ │ @@ -121,64 +121,64 @@ │ │ │ │ { │ │ │ │ bool is_valid () const; │ │ │ │ void reserve (int num_files); │ │ │ │ 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 (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_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 (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; │ │ │ │ - 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); │ │ │ │ + std::string const& name () const; │ │ │ │ void swap (file_storage& ti) noexcept; │ │ │ │ void canonicalize (); │ │ │ │ - std::int64_t file_offset (file_index_t index) const; │ │ │ │ - char const* root_ptr (file_index_t const index) const; │ │ │ │ std::time_t mtime (file_index_t index) const; │ │ │ │ - sha1_hash hash (file_index_t index) const; │ │ │ │ - bool pad_file_at (file_index_t index) const; │ │ │ │ - sha256_hash root (file_index_t index) const; │ │ │ │ - std::int64_t file_size (file_index_t index) const; │ │ │ │ string_view file_name (file_index_t index) const; │ │ │ │ std::string symlink (file_index_t index) const; │ │ │ │ + bool pad_file_at (file_index_t index) const; │ │ │ │ + std::int64_t file_size (file_index_t index) const; │ │ │ │ + char const* root_ptr (file_index_t const index) const; │ │ │ │ + sha1_hash hash (file_index_t index) const; │ │ │ │ + sha256_hash root (file_index_t index) const; │ │ │ │ + std::int64_t file_offset (file_index_t index) const; │ │ │ │ std::string file_path (file_index_t index, std::string const& save_path = "") 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_num_blocks (file_index_t index) const; │ │ │ │ int file_first_block_node (file_index_t index) const; │ │ │ │ int file_first_piece_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; │ │ │ │ @@ -217,28 +217,28 @@ │ │ │ │
    │ │ │ │

    add_file_borrow() add_file()

    │ │ │ │ 
    │ │ │ │  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 (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_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 (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,21 +370,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]
    │ │ │ │ -
    │ │ │ │ -

    set_piece_length() piece_length()

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

    piece_length() set_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()

    │ │ │ │ 
    │ │ │ │ @@ -413,21 +413,21 @@
│ │ │ │  
    
│ │ │ │  
    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]
    
│ │ │ │ -
    
│ │ │ │ -
    set_name() name()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    name() set_name()
    
│ │ │ │  
    │ │ │ │ -std::string const& name () const;
│ │ │ │  void set_name (std::string const& n);
│ │ │ │ +std::string const& name () const;
│ │ │ │  
    
│ │ │ │  
    set and get the name of this torrent. For multi-file torrents, this is also
│ │ │ │  the name of the root directory all the files are stored in.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    swap()
    
│ │ │ │  
    │ │ │ │ @@ -438,36 +438,36 @@
│ │ │ │  
    
│ │ │ │  
    canonicalize()
    
│ │ │ │  
    │ │ │ │  void canonicalize ();
│ │ │ │  
    
│ │ │ │  
    arrange files and padding to match the canonical form required
│ │ │ │  by BEP 52
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
    
│ │ │ │  
    file_num_pieces() file_piece_range() file_num_blocks()
    
│ │ │ │  
    │ │ │ │ +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_num_blocks (file_index_t index) 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()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    file_first_block_node() file_first_piece_node()
    
│ │ │ │  
    │ │ │ │  int file_first_block_node (file_index_t index) const;
│ │ │ │  int file_first_piece_node (file_index_t index) const;
│ │ │ │  
    
│ │ │ │  
    index of first piece node in the merkle tree
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -11,30 +11,30 @@
│ │ │ │ │            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 _n_a_m_e_(_)_ _s_e_t___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_(_)_ _f_i_l_e___p_a_t_h_(_)_ _f_i_l_e___n_a_m_e_(_)_ _m_t_i_m_e_(_)_ _r_o_o_t___p_t_r_(_)_ _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_(_)_ _s_y_m_l_i_n_k_(_)_ _r_o_o_t_(_)
│ │ │ │ │ +          o _f_i_l_e___o_f_f_s_e_t_(_)_ _r_o_o_t___p_t_r_(_)_ _m_t_i_m_e_(_)_ _f_i_l_e___n_a_m_e_(_)_ _f_i_l_e___p_a_t_h_(_)_ _h_a_s_h_(_)
│ │ │ │ │ +            _s_y_m_l_i_n_k_(_)_ _r_o_o_t_(_)_ _f_i_l_e___s_i_z_e_(_)_ _p_a_d___f_i_l_e___a_t_(_)
│ │ │ │ │            o _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_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_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___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___p_i_e_c_e___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___f_o_r___r_o_o_t_(_)
│ │ │ │ │            o _p_i_e_c_e___i_n_d_e_x___a_t___f_i_l_e_(_)
│ │ │ │ │ @@ -82,66 +82,66 @@
│ │ │ │ │     bool iiss__vvaalliidd () const;
│ │ │ │ │     void rreesseerrvvee (int num_files);
│ │ │ │ │     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 (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__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 (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;
│ │ │ │ │ -   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);
│ │ │ │ │ +   std::string const& nnaammee () const;
│ │ │ │ │     void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │     void ccaannoonniiccaalliizzee ();
│ │ │ │ │ -   std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ -   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │     std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ -   sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ -   bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ -   sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ -   std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │     string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │     std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +   bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ +   std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ +   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +   sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ +   sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +   std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │     std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │  "") 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__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │     int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │     int ffiillee__ffiirrsstt__ppiieeccee__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;
│ │ │ │ │ @@ -171,28 +171,28 @@
│ │ │ │ │  is known up-front.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__ffiillee__bboorrrrooww(()) aadddd__ffiillee(()) **********
│ │ │ │ │  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 (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__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 (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,17 +282,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]
│ │ │ │ │ -********** sseett__ppiieeccee__lleennggtthh(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ -int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +********** 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;
│ │ │ │ │  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.
│ │ │ │ │ @@ -309,39 +309,39 @@
│ │ │ │ │  returns the number of blocks in the specified piece, for v2 torrents.
│ │ │ │ │  [_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]
│ │ │ │ │ -********** sseett__nnaammee(()) nnaammee(()) **********
│ │ │ │ │ -std::string const& nnaammee () const;
│ │ │ │ │ +********** nnaammee(()) sseett__nnaammee(()) **********
│ │ │ │ │  void sseett__nnaammee (std::string const& n);
│ │ │ │ │ +std::string const& nnaammee () const;
│ │ │ │ │  set and get the name of this torrent. For multi-file torrents, this is also the
│ │ │ │ │  name of the root directory all the files are stored in.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sswwaapp(()) **********
│ │ │ │ │  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(()) ffiillee__ppaatthh(()) ffiillee__nnaammee(()) mmttiimmee(()) rroooott__ppttrr(()) ffiillee__ssiizzee(()) ppaadd__ffiillee__aatt
│ │ │ │ │ -(()) ffiillee__ooffffsseett(()) ssyymmlliinnkk(()) rroooott(()) **********
│ │ │ │ │ -std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +********** ffiillee__ooffffsseett(()) rroooott__ppttrr(()) mmttiimmee(()) ffiillee__nnaammee(()) ffiillee__ppaatthh(()) hhaasshh(()) ssyymmlliinnkk(())
│ │ │ │ │ +rroooott(()) ffiillee__ssiizzee(()) ppaadd__ffiillee__aatt(()) **********
│ │ │ │ │  std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ -sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ -bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ -sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ -std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │  string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │  std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ +std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ +sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │  std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │  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
│ │ │ │ │ @@ -357,23 +357,23 @@
│ │ │ │ │  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__ppiieecceess(()) ffiillee__ppiieeccee__rraannggee(()) ffiillee__nnuumm__bblloocckkss(()) **********
│ │ │ │ │ +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__nnuumm__bblloocckkss (file_index_t index) 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(()) **********
│ │ │ │ │ +********** ffiillee__ffiirrsstt__bblloocckk__nnooddee(()) ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) **********
│ │ │ │ │  int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │  int ffiillee__ffiirrsstt__ppiieeccee__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;
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Handle.html
│ │ │ │ @@ -39,52 +39,52 @@
│ │ │ │  
│ │ │ │  
  • 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]
    
│ │ │ │  
    set_peer() 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,94 +263,94 @@
│ │ │ │  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, 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 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 get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │     void post_peer_info () 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;
│ │ │ │ +   void post_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;
│ │ │ │ -   std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │     void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ -   void clear_piece_deadlines () const;
│ │ │ │     void set_piece_deadline (piece_index_t index, int deadline, deadline_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;
│ │ │ │ +   void clear_piece_deadlines () 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 add_tracker (announce_entry const&) const;
│ │ │ │     void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ -   void post_trackers () const;
│ │ │ │     std::vector<announce_entry> trackers () const;
│ │ │ │ +   void add_tracker (announce_entry const&) const;
│ │ │ │ +   void post_trackers () const;
│ │ │ │ +   std::set<std::string> url_seeds () 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 remove_http_seed (std::string const& url) const;
│ │ │ │ +   void add_http_seed (std::string const& url) const;
│ │ │ │     std::set<std::string> http_seeds () 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 pause (pause_flags_t flags = {}) 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 set_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 () const;
│ │ │ │     bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ +   bool need_save_resume_data () const;
│ │ │ │     void queue_position_bottom () const;
│ │ │ │ -   void queue_position_down () const;
│ │ │ │     queue_position_t queue_position () const;
│ │ │ │ -   void queue_position_up () const;
│ │ │ │     void queue_position_top () const;
│ │ │ │ +   void queue_position_up () const;
│ │ │ │ +   void queue_position_down () 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::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │ -   void piece_availability (std::vector<int>& avail) const;
│ │ │ │     void post_piece_availability () const;
│ │ │ │ -   std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ +   void piece_availability (std::vector<int>& avail) const;
│ │ │ │     void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ -   void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ -   download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ +   std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │     void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ -   void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │ +   download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ +   void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │     std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ -   download_priority_t file_priority (file_index_t index) const;
│ │ │ │ +   void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │     void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ -   void force_dht_announce () const;
│ │ │ │ +   download_priority_t file_priority (file_index_t index) 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 scrape_tracker (int idx = -1) const;
│ │ │ │ -   int download_limit () const;
│ │ │ │ +   void set_download_limit (int limit) const;
│ │ │ │     int upload_limit () const;
│ │ │ │     void set_upload_limit (int limit) const;
│ │ │ │ -   void set_download_limit (int limit) const;
│ │ │ │ +   int download_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;
│ │ │ │ @@ -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, 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 add_piece (piece_index_t piece, char const* 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
│ │ │ │ @@ -444,39 +444,39 @@
│ │ │ │  
    
│ │ │ │  
    have_piece()
    
│ │ │ │  
    │ │ │ │  bool have_piece (piece_index_t piece) const;
│ │ │ │  
    
│ │ │ │  
    Returns true if this piece has been completely downloaded and written
│ │ │ │  to disk, and false otherwise.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    post_peer_info() get_peer_info()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    get_peer_info() post_peer_info()
    
│ │ │ │  
    │ │ │ │  void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │  void post_peer_info () const;
│ │ │ │  
    
│ │ │ │  
    Query information about connected peers for this torrent. If the
│ │ │ │  torrent_handle is invalid, it will throw a system_error exception.
    
│ │ │ │  
    post_peer_info() is asynchronous and will trigger the posting of
│ │ │ │  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()
    
│ │ │ │  
    │ │ │ │ -void post_status (status_flags_t flags = status_flags_t::all()) 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;
│ │ │ │  
    
│ │ │ │  
    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
│ │ │ │ @@ -486,38 +486,38 @@
│ │ │ │  instead call post_status(). It will trigger posting of a
│ │ │ │  state_update_alert with a single torrent_status object for this
│ │ │ │  torrent.
    
│ │ │ │  
    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 include are defined in this class.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    post_download_queue() get_download_queue()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    get_download_queue() post_download_queue()
    
│ │ │ │  
    │ │ │ │ +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;
│ │ │ │ -std::vector<partial_piece_info> get_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() reset_piece_deadline() set_piece_deadline()
    
│ │ │ │  
    │ │ │ │  void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ -void clear_piece_deadlines () const;
│ │ │ │  void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) 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()
    
│ │ │ │  
    │ │ │ │ -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;
│ │ │ │  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).
│ │ │ │  Where n is the number of files, m is the number of currently
│ │ │ │ @@ -572,25 +572,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]
    
│ │ │ │ -
    
│ │ │ │ -
    trackers() add_tracker() replace_trackers() post_trackers()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    post_trackers() trackers() add_tracker() replace_trackers()
    
│ │ │ │  
    │ │ │ │ -void add_tracker (announce_entry const&) const;
│ │ │ │  void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ -void post_trackers () 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
│ │ │ │ @@ -602,41 +602,41 @@
│ │ │ │  
    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]
    
│ │ │ │ -
    
│ │ │ │ -
    remove_url_seed() add_url_seed() url_seeds()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_url_seed() url_seeds() remove_url_seed()
    
│ │ │ │  
    │ │ │ │ +std::set<std::string> url_seeds () 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;
│ │ │ │  
    
│ │ │ │  
    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]
    
│ │ │ │ -
    
│ │ │ │ -
    add_http_seed() http_seeds() remove_http_seed()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    http_seeds() add_http_seed() remove_http_seed()
    
│ │ │ │  
    │ │ │ │ -void add_http_seed (std::string const& url) const;
│ │ │ │  void remove_http_seed (std::string const& url) const;
│ │ │ │ +void add_http_seed (std::string const& url) const;
│ │ │ │  std::set<std::string> http_seeds () 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]
    
│ │ │ │  
    
│ │ │ │ @@ -679,18 +679,18 @@
│ │ │ │  afterward.
    
│ │ │ │  
    Clients should only use is_valid() to determine if the result of
│ │ │ │  session::find_torrent() was successful.
    
│ │ │ │  
    Unlike other member functions which return a value, is_valid()
│ │ │ │  completes immediately, without blocking on a result from the
│ │ │ │  network thread. Also unlike other functions, it never throws
│ │ │ │  the system_error exception.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    pause() resume()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    resume() pause()
    
│ │ │ │  
    │ │ │ │  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
│ │ │ │ @@ -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]
    
│ │ │ │ -
    
│ │ │ │ -
    set_flags() unset_flags() flags()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    flags() set_flags() unset_flags()
    
│ │ │ │  
    │ │ │ │ -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 set_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
│ │ │ │ @@ -858,16 +858,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
│ │ │ │ @@ -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_up() queue_position_down() queue_position_bottom() queue_position() queue_position_top()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    queue_position() queue_position_top() queue_position_up() queue_position_down() queue_position_bottom()
    
│ │ │ │  
    │ │ │ │  void queue_position_bottom () const;
│ │ │ │ -void queue_position_down () const;
│ │ │ │  queue_position_t queue_position () const;
│ │ │ │ -void queue_position_up () const;
│ │ │ │  void queue_position_top () const;
│ │ │ │ +void queue_position_up () const;
│ │ │ │ +void queue_position_down () 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
│ │ │ │ @@ -951,18 +951,18 @@
│ │ │ │  
    Note that when a torrent first starts up, and it needs a certificate,
│ │ │ │  it will 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 torrent_need_cert_alert, 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.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    torrent_file() torrent_file_with_hashes()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    torrent_file_with_hashes() torrent_file()
    
│ │ │ │  
    │ │ │ │  std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │  std::shared_ptr<torrent_info> torrent_file_with_hashes () 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
│ │ │ │ @@ -1002,37 +1002,37 @@
│ │ │ │  vector. This is a blocking call that will synchronize with the
│ │ │ │  libtorrent network thread.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    piece_availability() post_piece_availability()
    
│ │ │ │  
    │ │ │ │ -void piece_availability (std::vector<int>& avail) const;
│ │ │ │  void post_piece_availability () const;
│ │ │ │ +void piece_availability (std::vector<int>& avail) 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>
│ │ │ │  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]
    
│ │ │ │ -
    
│ │ │ │ -
    prioritize_pieces() piece_priority() get_piece_priorities()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    prioritize_pieces() get_piece_priorities() piece_priority()
    
│ │ │ │  
    │ │ │ │ -std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │  void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ -void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ -download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ +std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │  void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ +download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ +void prioritize_pieces (std::vector<download_priority_t> const& pieces) 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]
    
│ │ │ │ -
    
│ │ │ │ -
    get_file_priorities() prioritize_files() file_priority()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    prioritize_files() file_priority() get_file_priorities()
    
│ │ │ │  
    │ │ │ │ -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 file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │  void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ +download_priority_t file_priority (file_index_t index) 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.
    
│ │ │ │ @@ -1100,17 +1100,17 @@
│ │ │ │  been created, it will not be moved into the partfile.
    
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    force_lsd_announce() force_reannounce() force_dht_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_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
│ │ │ │ @@ -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]
    
│ │ │ │ -
    
│ │ │ │ -
    set_upload_limit() upload_limit() download_limit() set_download_limit()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    upload_limit() set_upload_limit() download_limit() set_download_limit()
    
│ │ │ │  
    │ │ │ │ -int download_limit () const;
│ │ │ │ +void set_download_limit (int limit) const;
│ │ │ │  int upload_limit () const;
│ │ │ │  void set_upload_limit (int limit) const;
│ │ │ │ -void set_download_limit (int limit) const;
│ │ │ │ +int download_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
│ │ │ │ @@ -1184,32 +1184,32 @@
│ │ │ │  
    clear_peers()
    
│ │ │ │  
    │ │ │ │  void clear_peers ();
│ │ │ │  
    
│ │ │ │  
    This will disconnect all peers and clear the peer list for this
│ │ │ │  torrent. New peers will have to be acquired before resuming, from
│ │ │ │  trackers, DHT or local service discovery, for example.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    max_uploads() set_max_uploads()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    set_max_uploads() max_uploads()
    
│ │ │ │  
    │ │ │ │  void set_max_uploads (int max_uploads) const;
│ │ │ │  int max_uploads () 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
│ │ │ │  settings_pack.
    
│ │ │ │  
    max_uploads() returns the current settings.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    set_max_connections() max_connections()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    max_connections() set_max_connections()
    
│ │ │ │  
    │ │ │ │  int max_connections () const;
│ │ │ │  void set_max_connections (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
│ │ │ │ @@ -1289,19 +1289,19 @@
│ │ │ │  
│ │ │ │  
    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;
│ │ │ │  
    
│ │ │ │  
    comparison operators. The order of the torrents is unspecified
│ │ │ │  but stable.
    
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -8,68 +8,68 @@
│ │ │ │ │            o _e_n_u_m_ _b_l_o_c_k___s_t_a_t_e___t
│ │ │ │ │      * _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 _p_o_s_t___p_e_e_r___i_n_f_o_(_)_ _g_e_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___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 _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 _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_(_)_ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_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 _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)_ _a_d_d___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_(_)_ _h_t_t_p___s_e_e_d_s_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ +          o _p_o_s_t___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_(_)_ _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_(_)_ _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___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 _s_e_t___f_l_a_g_s_(_)_ _u_n_s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)
│ │ │ │ │ +          o _r_e_s_u_m_e_(_)_ _p_a_u_s_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 _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___u_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_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_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___u_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_(_)
│ │ │ │ │            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 _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)_ _t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │            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 _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_(_)_ _f_i_l_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ │ +          o _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)_ _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_(_)
│ │ │ │ │ +          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___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 _s_c_r_a_p_e___t_r_a_c_k_e_r_(_)
│ │ │ │ │ -          o _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_(_)_ _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ +          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 _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 _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 _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 _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 _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]
│ │ │ │ │  ********** sseett__ppeeeerr(()) 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,104 +175,104 @@
│ │ │ │ │  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, 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 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 ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │     void ppoosstt__ppeeeerr__iinnffoo () 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;
│ │ │ │ │ +   void ppoosstt__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;
│ │ │ │ │ -   std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │     void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ -   void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │     void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │ -   void ffiillee__pprrooggrreessss (std::vector& progress,
│ │ │ │ │ -file_progress_flags_t flags = {}) 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 aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │     void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ -   void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │     std::vector ttrraacckkeerrss () const;
│ │ │ │ │ +   void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ +   void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ +   std::set uurrll__sseeeeddss () 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 rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +   void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │     std::set hhttttpp__sseeeeddss () 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 ppaauussee (pause_flags_t flags = {}) 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 sseett__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 () const;
│ │ │ │ │     bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ +   bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ -   void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │     queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ -   void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ +   void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ +   void qquueeuuee__ppoossiittiioonn__ddoowwnn () 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::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │ -   void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │     void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ -   std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ +   void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │     void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ │  const;
│ │ │ │ │ -   void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces)
│ │ │ │ │ -const;
│ │ │ │ │ -   download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ +   std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │     void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ -   void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │ +   download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ +   void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces)
│ │ │ │ │ +const;
│ │ │ │ │     std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ -   download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ +   void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │     void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ -   void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ +   download_priority_t ffiillee__pprriioorriittyy (file_index_t index) 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 ssccrraappee__ttrraacckkeerr (int idx = -1) const;
│ │ │ │ │ -   int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ +   void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │     int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │     void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ -   void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ +   int ddoowwnnllooaadd__lliimmiitt () 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;
│ │ │ │ │ @@ -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, 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 aadddd__ppiieeccee (piece_index_t piece, char const* 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
│ │ │ │ │ @@ -354,30 +354,30 @@
│ │ │ │ │  to finish in the same order as you initiated them.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** hhaavvee__ppiieeccee(()) **********
│ │ │ │ │  bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │  Returns true if this piece has been completely downloaded and written to disk,
│ │ │ │ │  and false otherwise.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppoosstt__ppeeeerr__iinnffoo(()) ggeett__ppeeeerr__iinnffoo(()) **********
│ │ │ │ │ +********** ggeett__ppeeeerr__iinnffoo(()) ppoosstt__ppeeeerr__iinnffoo(()) **********
│ │ │ │ │  void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │  void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │  Query information about connected peers for this torrent. If the _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │  is invalid, it will throw a system_error exception.
│ │ │ │ │  post_peer_info() is asynchronous and will trigger the posting of a
│ │ │ │ │  _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(()) **********
│ │ │ │ │ -void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +********** ppoosstt__ssttaattuuss(()) ssttaattuuss(()) **********
│ │ │ │ │  torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +void ppoosstt__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
│ │ │ │ │ @@ -385,29 +385,29 @@
│ │ │ │ │  It will trigger posting of a _s_t_a_t_e___u_p_d_a_t_e___a_l_e_r_t with a single _t_o_r_r_e_n_t___s_t_a_t_u_s
│ │ │ │ │  object for this torrent.
│ │ │ │ │  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]
│ │ │ │ │ -********** ppoosstt__ddoowwnnllooaadd__qquueeuuee(()) ggeett__ddoowwnnllooaadd__qquueeuuee(()) **********
│ │ │ │ │ +********** ggeett__ddoowwnnllooaadd__qquueeuuee(()) ppoosstt__ddoowwnnllooaadd__qquueeuuee(()) **********
│ │ │ │ │ +std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │  void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │  void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ -std::vector ggeett__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(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) sseett__ppiieeccee__ddeeaaddlliinnee(()) **********
│ │ │ │ │  void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ -void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │  void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │  flags = {}) 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(()) **********
│ │ │ │ │ -void ffiillee__pprrooggrreessss (std::vector& progress, file_progress_flags_t
│ │ │ │ │ -flags = {}) const;
│ │ │ │ │ +********** ffiillee__pprrooggrreessss(()) ppoosstt__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
│ │ │ │ │  number of blocks in a piece.
│ │ │ │ │  The flags parameter can be used to specify the granularity of the file
│ │ │ │ │ @@ -449,19 +449,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]
│ │ │ │ │ -********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) rreeppllaaccee__ttrraacckkeerrss(()) ppoosstt__ttrraacckkeerrss(()) **********
│ │ │ │ │ -void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ +********** ppoosstt__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) rreeppllaaccee__ttrraacckkeerrss(()) **********
│ │ │ │ │  void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ -void ppoosstt__ttrraacckkeerrss () 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.
│ │ │ │ │ @@ -470,29 +470,29 @@
│ │ │ │ │  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]
│ │ │ │ │ -********** rreemmoovvee__uurrll__sseeeedd(()) aadddd__uurrll__sseeeedd(()) uurrll__sseeeeddss(()) **********
│ │ │ │ │ +********** aadddd__uurrll__sseeeedd(()) uurrll__sseeeeddss(()) rreemmoovvee__uurrll__sseeeedd(()) **********
│ │ │ │ │ +std::set uurrll__sseeeeddss () const;
│ │ │ │ │  void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │  void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ -std::set uurrll__sseeeeddss () 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]
│ │ │ │ │ -********** aadddd__hhttttpp__sseeeedd(()) hhttttpp__sseeeeddss(()) rreemmoovvee__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +********** hhttttpp__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) rreemmoovvee__hhttttpp__sseeeedd(()) **********
│ │ │ │ │  void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │  std::set hhttttpp__sseeeeddss () 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 (
│ │ │ │ │ @@ -524,15 +524,15 @@
│ │ │ │ │  and false afterward.
│ │ │ │ │  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(()) **********
│ │ │ │ │ +********** rreessuummee(()) ppaauussee(()) **********
│ │ │ │ │  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.
│ │ │ │ │ @@ -541,19 +541,19 @@
│ │ │ │ │  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]
│ │ │ │ │ -********** sseett__ffllaaggss(()) uunnsseett__ffllaaggss(()) ffllaaggss(()) **********
│ │ │ │ │ -void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ -void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ +********** ffllaaggss(()) sseett__ffllaaggss(()) uunnsseett__ffllaaggss(()) **********
│ │ │ │ │  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 sseett__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
│ │ │ │ │ @@ -663,35 +663,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__uupp(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) qquueeuuee__ppoossiittiioonn__bboottttoomm(())
│ │ │ │ │ -qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__ttoopp(()) **********
│ │ │ │ │ +********** qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__uupp(())
│ │ │ │ │ +qquueeuuee__ppoossiittiioonn__ddoowwnn(()) qquueeuuee__ppoossiittiioonn__bboottttoomm(()) **********
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │  queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__ddoowwnn () 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.
│ │ │ │ │ @@ -734,15 +734,15 @@
│ │ │ │ │  Note that when a torrent first starts up, and it needs a certificate, it will
│ │ │ │ │  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(()) **********
│ │ │ │ │ +********** ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess(()) ttoorrrreenntt__ffiillee(()) **********
│ │ │ │ │  std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │  std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () 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.
│ │ │ │ │ @@ -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 ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │  void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ +void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) 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(()) **********
│ │ │ │ │ -std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ +********** pprriioorriittiizzee__ppiieecceess(()) ggeett__ppiieeccee__pprriioorriittiieess(()) ppiieeccee__pprriioorriittyy(()) **********
│ │ │ │ │  void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ │ -void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) const;
│ │ │ │ │ -download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ +std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │  void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ +download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ +void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) 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]
│ │ │ │ │ -********** ggeett__ffiillee__pprriioorriittiieess(()) pprriioorriittiizzee__ffiilleess(()) ffiillee__pprriioorriittyy(()) **********
│ │ │ │ │ -void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │ +********** pprriioorriittiizzee__ffiilleess(()) ffiillee__pprriioorriittyy(()) ggeett__ffiillee__pprriioorriittiieess(()) **********
│ │ │ │ │  std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ -download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ +void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │  void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ +download_priority_t ffiillee__pprriioorriittyy (file_index_t index) 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
│ │ │ │ │ @@ -848,18 +848,18 @@
│ │ │ │ │  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(()) **********
│ │ │ │ │ -void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │  void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │  void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t = {})
│ │ │ │ │  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 -
│ │ │ │ │ @@ -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]
│ │ │ │ │ -********** sseett__uuppllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(())
│ │ │ │ │ +********** uuppllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(())
│ │ │ │ │  **********
│ │ │ │ │ -int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ +void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │  int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │  void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ -void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ +int ddoowwnnllooaadd__lliimmiitt () 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.
│ │ │ │ │ @@ -913,24 +913,24 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclleeaarr__ppeeeerrss(()) **********
│ │ │ │ │  void cclleeaarr__ppeeeerrss ();
│ │ │ │ │  This will disconnect all peers and clear the peer list for this torrent. New
│ │ │ │ │  peers will have to be acquired before resuming, from trackers, DHT or local
│ │ │ │ │  service discovery, for example.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** mmaaxx__uuppllooaaddss(()) sseett__mmaaxx__uuppllooaaddss(()) **********
│ │ │ │ │ +********** sseett__mmaaxx__uuppllooaaddss(()) mmaaxx__uuppllooaaddss(()) **********
│ │ │ │ │  void sseett__mmaaxx__uuppllooaaddss (int max_uploads) const;
│ │ │ │ │  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]
│ │ │ │ │ -********** sseett__mmaaxx__ccoonnnneeccttiioonnss(()) mmaaxx__ccoonnnneeccttiioonnss(()) **********
│ │ │ │ │ +********** mmaaxx__ccoonnnneeccttiioonnss(()) sseett__mmaaxx__ccoonnnneeccttiioonnss(()) **********
│ │ │ │ │  int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │  void sseett__mmaaxx__ccoonnnneeccttiioonnss (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 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
│ │ │ │ │ @@ -991,15 +991,15 @@
│ │ │ │ │  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;
│ │ │ │ │  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;
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Info.html
│ │ │ │ @@ -42,22 +42,22 @@
│ │ │ │  
  • torrent_info
      
│ │ │ │  
    • torrent_info()
      • 
│ │ │ │  
    • ~torrent_info()
      • 
│ │ │ │  
    • files() orig_files()
      • 
│ │ │ │  
    • rename_file()
      • 
│ │ │ │  
    • remap_files()
      • 
│ │ │ │  
    • trackers() add_tracker() clear_trackers()
      • 
│ │ │ │ -
    • collections() similar_torrents()
      • 
│ │ │ │ -
    • add_http_seed() add_url_seed() web_seeds() set_web_seeds()
      • 
│ │ │ │ +
    • similar_torrents() collections()
      • 
│ │ │ │ +
    • web_seeds() add_url_seed() set_web_seeds() add_http_seed()
      • 
│ │ │ │  
    • total_size()
      • 
│ │ │ │ -
    • num_pieces() piece_length()
      • 
│ │ │ │ +
    • piece_length() num_pieces()
      • 
│ │ │ │  
    • blocks_per_piece()
      • 
│ │ │ │ -
    • last_piece() piece_range() end_piece()
      • 
│ │ │ │ +
    • last_piece() end_piece() piece_range()
      • 
│ │ │ │  
    • info_hashes() info_hash()
      • 
│ │ │ │ -
    • v2() v1()
      • 
│ │ │ │ +
    • v1() v2()
      • 
│ │ │ │  
    • num_files()
      • 
│ │ │ │  
    • map_block()
      • 
│ │ │ │  
    • map_file()
      • 
│ │ │ │  
    • ssl_cert()
      • 
│ │ │ │  
    • is_valid()
      • 
│ │ │ │  
    • priv()
      • 
│ │ │ │  
    • is_i2p()
      • 
│ │ │ │ @@ -197,58 +197,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 (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ -   torrent_info (torrent_info const& t);
│ │ │ │ +   torrent_info (std::string const& filename, error_code& ec);
│ │ │ │     torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -   explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │     explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -   torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -   torrent_info (char const* buffer, int size);
│ │ │ │ -   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +   torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │     explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │     explicit torrent_info (std::string const& filename);
│ │ │ │ -   torrent_info (std::string const& filename, error_code& ec);
│ │ │ │     torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -   torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ +   torrent_info (torrent_info const& t);
│ │ │ │ +   torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +   torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +   explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +   torrent_info (char const* buffer, int size);
│ │ │ │     ~torrent_info ();
│ │ │ │ -   file_storage const& files () const;
│ │ │ │     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);
│ │ │ │ -   std::vector<announce_entry> const& trackers () const;
│ │ │ │ +   void add_tracker (std::string const& url, int tier = 0);
│ │ │ │     void clear_trackers ();
│ │ │ │ +   std::vector<announce_entry> const& trackers () const;
│ │ │ │     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;
│ │ │ │ +   std::vector<std::string> collections () 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 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);
│ │ │ │     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 last_piece () const;
│ │ │ │     index_range<piece_index_t> piece_range () const;
│ │ │ │     piece_index_t end_piece () const;
│ │ │ │ -   info_hash_t const& info_hashes () const;
│ │ │ │ +   piece_index_t last_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;
│ │ │ │ @@ -269,27 +269,27 @@
│ │ │ │     span<char const> piece_layer (file_index_t) const;
│ │ │ │     void free_piece_layers ();
│ │ │ │  };
│ │ │ │  
      
│ │ │ │  [report issue]
      
│ │ │ │  
      torrent_info()
      
│ │ │ │  
      │ │ │ │ -torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ -torrent_info (torrent_info const& t);
│ │ │ │ +torrent_info (std::string const& filename, error_code& ec);
│ │ │ │  torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │  explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -torrent_info (char const* buffer, int size);
│ │ │ │ -torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │  explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │  explicit torrent_info (std::string const& filename);
│ │ │ │ -torrent_info (std::string const& filename, error_code& ec);
│ │ │ │  torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ +torrent_info (torrent_info const& t);
│ │ │ │ +torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +torrent_info (char const* buffer, int size);
│ │ │ │  
      
│ │ │ │  
      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
│ │ │ │ @@ -323,16 +323,16 @@
│ │ │ │  
│ │ │ │  
      frees all storage associated with this torrent_info object
      
│ │ │ │  
│ │ │ │  [report issue]
      
│ │ │ │  
      
│ │ │ │  
      files() orig_files()
      
│ │ │ │  
      │ │ │ │ -file_storage const& files () const;
│ │ │ │  file_storage const& orig_files () const;
│ │ │ │ +file_storage const& 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
│ │ │ │  having a torrent file. When renaming files in a storage, the storage
│ │ │ │  needs to make its own copy of the file_storage in order to make its
│ │ │ │  mapping differ from the one in the torrent file.
      
│ │ │ │ @@ -382,57 +382,57 @@
│ │ │ │  the current one.
      
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
      
│ │ │ │  
      
│ │ │ │  
      trackers() add_tracker() clear_trackers()
      
│ │ │ │  
      │ │ │ │ -std::vector<announce_entry> const& trackers () const;
│ │ │ │ +void add_tracker (std::string const& url, int tier = 0);
│ │ │ │  void clear_trackers ();
│ │ │ │ +std::vector<announce_entry> const& trackers () const;
│ │ │ │  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
│ │ │ │  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]
      
│ │ │ │ -
      
│ │ │ │ -
      collections() similar_torrents()
      
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      similar_torrents() collections()
      
│ │ │ │  
      │ │ │ │ -std::vector<std::string> collections () const;
│ │ │ │  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]
      
│ │ │ │ -
      
│ │ │ │ -
      add_http_seed() add_url_seed() web_seeds() set_web_seeds()
      
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      web_seeds() add_url_seed() set_web_seeds() add_http_seed()
      
│ │ │ │  
      │ │ │ │  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 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);
│ │ │ │  
      
│ │ │ │  
      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.
      
│ │ │ │ @@ -453,21 +453,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]
      
│ │ │ │ -
      
│ │ │ │ -
      num_pieces() piece_length()
      
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      piece_length() num_pieces()
      
│ │ │ │  
      │ │ │ │ -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
│ │ │ │ @@ -477,47 +477,47 @@
│ │ │ │  
      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() piece_range() end_piece()
      
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      last_piece() end_piece() piece_range()
      
│ │ │ │  
      │ │ │ │ -piece_index_t last_piece () const;
│ │ │ │  index_range<piece_index_t> piece_range () const;
│ │ │ │  piece_index_t end_piece () const;
│ │ │ │ +piece_index_t last_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()
      
│ │ │ │  
      │ │ │ │ -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]
      
│ │ │ │ -
      
│ │ │ │ -
      v2() v1()
      
│ │ │ │ +
│ │ │ │ +[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()
      
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -11,22 +11,22 @@
│ │ │ │ │      * _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 _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_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _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_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)_ _s_e_t___w_e_b___s_e_e_d_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 _w_e_b___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │            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 _p_i_e_c_e___l_e_n_g_t_h_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │            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_(_)_ _p_i_e_c_e___r_a_n_g_e_(_)_ _e_n_d___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 _v_2_(_)_ _v_1_(_)
│ │ │ │ │ +          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,62 +120,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 (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ -   explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │     explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │     explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │     explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │  from_span_t);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +   explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │     ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │ -   file_storage const& ffiilleess () const;
│ │ │ │ │     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);
│ │ │ │ │ -   std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ +   void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │     void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +   std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │     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;
│ │ │ │ │ +   std::vector ccoolllleeccttiioonnss () 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 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);
│ │ │ │ │     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 llaasstt__ppiieeccee () const;
│ │ │ │ │     index_range ppiieeccee__rraannggee () const;
│ │ │ │ │     piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ -   info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ +   piece_index_t llaasstt__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;
│ │ │ │ │ @@ -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 (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │  explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │  explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │  explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │  from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │  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
│ │ │ │ │ @@ -242,16 +242,16 @@
│ │ │ │ │  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(()) **********
│ │ │ │ │ -file_storage const& ffiilleess () const;
│ │ │ │ │  file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │ +file_storage const& 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
│ │ │ │ │  file.
│ │ │ │ │  orig_files() returns the original (unmodified) file storage for this torrent.
│ │ │ │ │ @@ -285,47 +285,47 @@
│ │ │ │ │  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(()) aadddd__ttrraacckkeerr(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ │ -std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ +void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │  void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │  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.
│ │ │ │ │  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]
│ │ │ │ │ -********** ccoolllleeccttiioonnss(()) ssiimmiillaarr__ttoorrrreennttss(()) **********
│ │ │ │ │ -std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ +********** ssiimmiillaarr__ttoorrrreennttss(()) ccoolllleeccttiioonnss(()) **********
│ │ │ │ │  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]
│ │ │ │ │ -********** aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) wweebb__sseeeeddss(()) sseett__wweebb__sseeeeddss(()) **********
│ │ │ │ │ +********** wweebb__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) sseett__wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │  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 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);
│ │ │ │ │  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
│ │ │ │ │ @@ -339,47 +339,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]
│ │ │ │ │ -********** nnuumm__ppiieecceess(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ -int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +********** ppiieeccee__lleennggtthh(()) nnuumm__ppiieecceess(()) **********
│ │ │ │ │  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(()) ppiieeccee__rraannggee(()) eenndd__ppiieeccee(()) **********
│ │ │ │ │ -piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ +********** llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) ppiieeccee__rraannggee(()) **********
│ │ │ │ │  index_range ppiieeccee__rraannggee () const;
│ │ │ │ │  piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ +piece_index_t llaasstt__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;
│ │ │ │ │  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]
│ │ │ │ │ -********** vv22(()) vv11(()) **********
│ │ │ │ │ -bool vv11 () const;
│ │ │ │ │ +********** 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(()) **********
│ │ │ │ │  int nnuumm__ffiilleess () const;
│ │ │ │ │  If you need index-access to files you can use the num_files() along with the
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Trackers.html
│ │ │ │ @@ -31,15 +31,15 @@
│ │ │ │  
      home
      
│ │ │ │  
      
│ │ │ │  
      Table of contents
      
│ │ │ │  
│ │ │ │  
      
│ │ │ │  [report issue]
      
│ │ │ │  
      announce_infohash
      
│ │ │ │ @@ -131,19 +131,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& operator= (announce_entry const&) &;
│ │ │ │     announce_entry (announce_entry const&);
│ │ │ │ -   announce_entry ();
│ │ │ │ -   explicit announce_entry (string_view u);
│ │ │ │     ~announce_entry ();
│ │ │ │ -   announce_entry& operator= (announce_entry const&) &;
│ │ │ │ +   explicit announce_entry (string_view u);
│ │ │ │ +   announce_entry ();
│ │ │ │  
│ │ │ │     enum tracker_source
│ │ │ │     {
│ │ │ │        source_torrent,
│ │ │ │        source_client,
│ │ │ │        source_magnet_link,
│ │ │ │        source_tex,
│ │ │ │ @@ -154,24 +154,24 @@
│ │ │ │     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]
      
│ │ │ │ +
      operator=() announce_entry() ~announce_entry()
      
│ │ │ │  
      │ │ │ │ +announce_entry& operator= (announce_entry const&) &;
│ │ │ │  announce_entry (announce_entry const&);
│ │ │ │ -announce_entry ();
│ │ │ │ -explicit announce_entry (string_view u);
│ │ │ │  ~announce_entry ();
│ │ │ │ -announce_entry& operator= (announce_entry const&) &;
│ │ │ │ +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"
      
│ │ │ │  
    • 
│ │ │ │ ├── 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 _o_p_e_r_a_t_o_r_=_(_)_ _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 _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,19 +78,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
│ │ │ │ │  {
│ │ │ │ │ +   announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │     aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ -   aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ -   explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │     ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ -   announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ +   explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ +   aannnnoouunnccee__eennttrryy ();
│ │ │ │ │  
│ │ │ │ │     enum tracker_source
│ │ │ │ │     {
│ │ │ │ │        source_torrent,
│ │ │ │ │        source_client,
│ │ │ │ │        source_magnet_link,
│ │ │ │ │        source_tex,
│ │ │ │ │ @@ -101,20 +101,20 @@
│ │ │ │ │     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==(()) **********
│ │ │ │ │ +********** ooppeerraattoorr==(()) aannnnoouunnccee__eennttrryy(()) ~~aannnnoouunnccee__eennttrryy(()) **********
│ │ │ │ │ +announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │  aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ -aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ -explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │  ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ -announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ +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_ _ _ _ _ _ _ _ _ _ |
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Utility.html
│ │ │ │ @@ -31,15 +31,15 @@
│ │ │ │  
    home
    
│ │ │ │  
    
│ │ │ │  
    Table of contents
    
│ │ │ │  
│ │ │ │  
    
│ │ │ │ @@ -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&& rhs) noexcept = default;
│ │ │ │     explicit bitfield (int bits);
│ │ │ │ -   bitfield () noexcept = default;
│ │ │ │     bitfield (bitfield const& rhs);
│ │ │ │ -   bitfield (char const* b, int bits);
│ │ │ │ +   bitfield () noexcept = default;
│ │ │ │     bitfield (int bits, bool val);
│ │ │ │ +   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 set_bit (int index) noexcept;
│ │ │ │     void clear_bit (int index) noexcept;
│ │ │ │ +   void set_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 (bitfield&& rhs) noexcept = default;
│ │ │ │  explicit bitfield (int bits);
│ │ │ │ -bitfield () noexcept = default;
│ │ │ │  bitfield (bitfield const& rhs);
│ │ │ │ -bitfield (char const* b, int bits);
│ │ │ │ +bitfield () noexcept = default;
│ │ │ │  bitfield (int bits, bool val);
│ │ │ │ +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
│ │ │ │ @@ -121,30 +121,30 @@
│ │ │ │  
    
│ │ │ │  
    assign()
    
│ │ │ │  
    │ │ │ │  void assign (char const* b, int const bits);
│ │ │ │  
    
│ │ │ │  
    copy bitfield from buffer b of bits number of bits, rounded up to
│ │ │ │  the nearest byte boundary.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    get_bit() operator[]()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    operator[]() get_bit()
    
│ │ │ │  
    │ │ │ │  bool operator[] (int index) const noexcept;
│ │ │ │  bool get_bit (int index) const noexcept;
│ │ │ │  
    
│ │ │ │  
    query bit at index. Returns true if bit is 1, otherwise false.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    clear_bit() set_bit()
    
│ │ │ │  
    │ │ │ │ -void set_bit (int index) noexcept;
│ │ │ │  void clear_bit (int index) noexcept;
│ │ │ │ +void set_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* 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()
    
│ │ │ │  
    │ │ │ │ @@ -242,32 +242,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 ();
│ │ │ │ -   hasher (char const* data, int len);
│ │ │ │     hasher& operator= (hasher const&) &;
│ │ │ │ -   explicit hasher (span<char const> data);
│ │ │ │     hasher (hasher const&);
│ │ │ │ +   hasher (char const* data, int len);
│ │ │ │ +   explicit hasher (span<char const> data);
│ │ │ │     hasher& update (span<char const> data);
│ │ │ │     hasher& update (char const* data, int len);
│ │ │ │     sha1_hash final ();
│ │ │ │     void reset ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    operator=() hasher()
    
│ │ │ │  
    │ │ │ │ -hasher (char const* data, int len);
│ │ │ │  hasher& operator= (hasher const&) &;
│ │ │ │ -explicit hasher (span<char const> data);
│ │ │ │  hasher (hasher const&);
│ │ │ │ +hasher (char const* data, int len);
│ │ │ │ +explicit hasher (span<char const> data);
│ │ │ │  
    
│ │ │ │  
    this is the same as default constructing followed by a call to
│ │ │ │  update(data, len).
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    update()
    
│ │ │ │  
    │ │ │ │ @@ -296,42 +296,42 @@
│ │ │ │  
    
│ │ │ │  
    hasher256
    
│ │ │ │  
    Declared in "libtorrent/hasher.hpp"
    
│ │ │ │  
    │ │ │ │  class hasher256
│ │ │ │  {
│ │ │ │     hasher256 ();
│ │ │ │ -   hasher256 (hasher256 const&);
│ │ │ │ -   explicit hasher256 (span<char const> data);
│ │ │ │     hasher256& operator= (hasher256 const&) &;
│ │ │ │ +   explicit hasher256 (span<char const> data);
│ │ │ │     hasher256 (char const* data, int len);
│ │ │ │ -   hasher256& update (span<char const> data);
│ │ │ │ +   hasher256 (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 (hasher256 const&);
│ │ │ │ -explicit hasher256 (span<char const> data);
│ │ │ │  hasher256& operator= (hasher256 const&) &;
│ │ │ │ +explicit hasher256 (span<char const> data);
│ │ │ │  hasher256 (char const* data, int len);
│ │ │ │ +hasher256 (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 ();
│ │ │ │ ├── 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
│ │ │ │ │      * _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 _g_e_t___b_i_t_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ +          o _o_p_e_r_a_t_o_r_[_]_(_)_ _g_e_t___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_(_)
│ │ │ │ │ @@ -21,78 +21,78 @@
│ │ │ │ │            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_(_)
│ │ │ │ │  [_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&& rhs) noexcept = default;
│ │ │ │ │     explicit bbiittffiieelldd (int bits);
│ │ │ │ │ -   bbiittffiieelldd () noexcept = default;
│ │ │ │ │     bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -   bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ +   bbiittffiieelldd () noexcept = default;
│ │ │ │ │     bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ +   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 sseett__bbiitt (int index) noexcept;
│ │ │ │ │     void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ +   void sseett__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 (bitfield&& rhs) noexcept = default;
│ │ │ │ │  explicit bbiittffiieelldd (int bits);
│ │ │ │ │ -bbiittffiieelldd () noexcept = default;
│ │ │ │ │  bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ +bbiittffiieelldd () noexcept = default;
│ │ │ │ │  bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ +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]
│ │ │ │ │  ********** 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]
│ │ │ │ │ -********** ggeett__bbiitt(()) ooppeerraattoorr[[]](()) **********
│ │ │ │ │ +********** 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 sseett__bbiitt (int index) noexcept;
│ │ │ │ │  void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ +void sseett__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* 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]
│ │ │ │ │ @@ -151,29 +151,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 ();
│ │ │ │ │ -   hhaasshheerr (char const* data, int len);
│ │ │ │ │     hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ -   explicit hhaasshheerr (span data);
│ │ │ │ │     hhaasshheerr (hasher const&);
│ │ │ │ │ +   hhaasshheerr (char const* data, int len);
│ │ │ │ │ +   explicit hhaasshheerr (span data);
│ │ │ │ │     hasher& uuppddaattee (span data);
│ │ │ │ │     hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │     sha1_hash ffiinnaall ();
│ │ │ │ │     void rreesseett ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ooppeerraattoorr==(()) hhaasshheerr(()) **********
│ │ │ │ │ -hhaasshheerr (char const* data, int len);
│ │ │ │ │  hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ -explicit hhaasshheerr (span data);
│ │ │ │ │  hhaasshheerr (hasher const&);
│ │ │ │ │ +hhaasshheerr (char const* data, int len);
│ │ │ │ │ +explicit hhaasshheerr (span data);
│ │ │ │ │  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);
│ │ │ │ │  append the following bytes to what is being hashed
│ │ │ │ │ @@ -189,36 +189,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 ();
│ │ │ │ │ -   hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ -   explicit hhaasshheerr225566 (span data);
│ │ │ │ │     hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ +   explicit hhaasshheerr225566 (span data);
│ │ │ │ │     hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ -   hasher256& uuppddaattee (span data);
│ │ │ │ │ +   hhaasshheerr225566 (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==(()) **********
│ │ │ │ │ -hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ -explicit hhaasshheerr225566 (span data);
│ │ │ │ │ +********** ooppeerraattoorr==(()) hhaasshheerr225566(()) **********
│ │ │ │ │  hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ +explicit hhaasshheerr225566 (span data);
│ │ │ │ │  hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ +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);
│ │ │ │ │ +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]
│ │ │ ├── ./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,33 +25,33 @@
│ │ │ │  
    
│ │ │ │  
    Session
    
│ │ │ │  
    
│ │ │ │  
    session_params
    
│ │ │ │  
    session_proxy
    
│ │ │ │  
    session
    
│ │ │ │  
    session_handle
    
│ │ │ │ -
    read_session_params()
    
│ │ │ │  
    write_session_params()
    
│ │ │ │ +
    read_session_params()
    
│ │ │ │  
    write_session_params_buf()
    
│ │ │ │  
    
│ │ │ │  
    Torrent Info
    
│ │ │ │  
    
│ │ │ │  
    web_seed_entry
    
│ │ │ │  
    load_torrent_limits
    
│ │ │ │  
    torrent_info
    
│ │ │ │  
    
│ │ │ │  
    Core
    
│ │ │ │  
    
│ │ │ │  
    peer_info
    
│ │ │ │  
    info_hash_t
    
│ │ │ │  
    piece_block
    
│ │ │ │  
    peer_request
    
│ │ │ │ -
    load_torrent_buffer()
    
│ │ │ │ -
    load_torrent_parsed()
    
│ │ │ │  
    load_torrent_file()
    
│ │ │ │ +
    load_torrent_parsed()
    
│ │ │ │ +
    load_torrent_buffer()
    
│ │ │ │  
    make_magnet_uri()
    
│ │ │ │  
    parse_magnet_uri()
    
│ │ │ │  
    torrent_peer_equal()
    
│ │ │ │  
    truncate_files()
    
│ │ │ │  
    version()
    
│ │ │ │  
    socket_type_t
    
│ │ │ │  
    protocol_version
    
│ │ │ │ @@ -97,16 +97,16 @@
│ │ │ │  
    announce_entry
    
│ │ │ │  
    
│ │ │ │  
    Settings
    
│ │ │ │  
    
│ │ │ │  
    overview
    
│ │ │ │  
    settings_pack
    
│ │ │ │  
    generate_fingerprint()
    
│ │ │ │ -
    high_performance_seed()
    
│ │ │ │  
    min_memory_usage()
    
│ │ │ │ +
    high_performance_seed()
    
│ │ │ │  
    name_for_setting()
    
│ │ │ │  
    setting_by_name()
    
│ │ │ │  
    default_settings()
    
│ │ │ │  
    
│ │ │ │  
    DHT
    
│ │ │ │  
    
│ │ │ │  
    dht_state
    
│ │ │ │ @@ -115,16 +115,16 @@
│ │ │ │  
    sign_mutable_item()
    
│ │ │ │  
    dht_default_storage_constructor()
    
│ │ │ │  
    announce_flags_t
    
│ │ │ │  
    
│ │ │ │  
    Resume Data
    
│ │ │ │  
    
│ │ │ │  
    read_resume_data()
    
│ │ │ │ -
    write_resume_data_buf()
    
│ │ │ │  
    write_resume_data()
    
│ │ │ │ +
    write_resume_data_buf()
    
│ │ │ │  
    write_torrent_file_buf()
    
│ │ │ │  
    write_torrent_file()
    
│ │ │ │  
    write_torrent_flags_t
    
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    Error Codes
    
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,29 +3,29 @@
│ │ │ │ │  ************ 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
│ │ │ │ │ -_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
│ │ │ │ │  _p_i_e_c_e___b_l_o_c_k
│ │ │ │ │  _p_e_e_r___r_e_q_u_e_s_t
│ │ │ │ │ -_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___p_a_r_s_e_d_(_)
│ │ │ │ │  _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_(_)
│ │ │ │ │  _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │  _p_a_r_s_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │  _t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_)
│ │ │ │ │  _t_r_u_n_c_a_t_e___f_i_l_e_s_(_)
│ │ │ │ │  _v_e_r_s_i_o_n_(_)
│ │ │ │ │  _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │  _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ │ @@ -59,30 +59,30 @@
│ │ │ │ │  _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
│ │ │ │ │  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_(_)
│ │ │ │ │ -_h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)
│ │ │ │ │  _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_(_)
│ │ │ │ │  _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_(_)
│ │ │ │ │  _a_n_n_o_u_n_c_e___f_l_a_g_s___t
│ │ │ │ │  Resume Data
│ │ │ │ │  _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___b_u_f_(_)
│ │ │ │ │  _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___t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ │  Error Codes
│ │ │ │ │  _s_t_o_r_a_g_e___e_r_r_o_r
│ │ │ │ │  _l_i_b_t_o_r_r_e_n_t___c_a_t_e_g_o_r_y_(_)
│ │ │ │ │  _h_t_t_p___c_a_t_e_g_o_r_y_(_)
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/single-page-ref.html
│ │ │ │ @@ -55,59 +55,59 @@
│ │ │ │  
  • enum error_code_enum
    • 
│ │ │ │  
  • session_params
│ │ │ │  
    • 
│ │ │ │  
  • session_proxy
│ │ │ │  
    • 
│ │ │ │  
  • session
│ │ │ │  
    • 
│ │ │ │  
  • session_handle
│ │ │ │  
    • 
│ │ │ │  
  • read_session_params() write_session_params_buf() write_session_params()
    • 
│ │ │ │  
  • web_seed_entry
│ │ │ │  
    • 
│ │ │ │  
  • load_torrent_limits
    • 
│ │ │ │  
  • torrent_info
│ │ │ │  
    • 
│ │ │ │  
  • torrent_plugin
│ │ │ │  
    • 
│ │ │ │  
  • peer_plugin
│ │ │ │  
    • 
│ │ │ │  
  • storage_params
    • 
│ │ │ │ @@ -286,75 +286,75 @@
│ │ │ │  
  • posix_disk_io_constructor()
    • 
│ │ │ │  
  • default_disk_io_constructor()
    • 
│ │ │ │  
  • enum storage_mode_t
    • 
│ │ │ │  
  • enum status_t
    • 
│ │ │ │  
  • enum move_flags_t
    • 
│ │ │ │  
  • client_data_t
│ │ │ │  
    • 
│ │ │ │  
  • add_torrent_params
    • 
│ │ │ │  
  • peer_class_info
    • 
│ │ │ │  
  • peer_class_type_filter
│ │ │ │  
    • 
│ │ │ │  
  • block_info
│ │ │ │  
    • 
│ │ │ │  
  • partial_piece_info
    • 
│ │ │ │  
  • torrent_handle
│ │ │ │  
    • 
│ │ │ │  
  • hash_value()
    • 
│ │ │ │ @@ -461,15 +461,15 @@
│ │ │ │  
  • piece_finished_alert
    • 
│ │ │ │  
  • request_dropped_alert
    • 
│ │ │ │  
  • block_timeout_alert
    • 
│ │ │ │  
  • block_finished_alert
    • 
│ │ │ │  
  • block_downloading_alert
    • 
│ │ │ │  
  • unwanted_block_alert
    • 
│ │ │ │  
  • storage_moved_alert
│ │ │ │  
    • 
│ │ │ │  
  • storage_moved_failed_alert
│ │ │ │  
    • 
│ │ │ │  
  • torrent_deleted_alert
    • 
│ │ │ │ @@ -593,15 +593,15 @@
│ │ │ │  
  • tracker_list_alert
    • 
│ │ │ │  
  • alert_cast()
    • 
│ │ │ │  
  • operation_name()
    • 
│ │ │ │  
  • enum operation_t
    • 
│ │ │ │  
  • alert_category_t
    • 
│ │ │ │  
  • int
    • 
│ │ │ │  
  • counters
│ │ │ │  
    • 
│ │ │ │  
  • stats_metric
    • 
│ │ │ │  
  • session_stats_metrics()
    • 
│ │ │ │  
  • find_metric_idx()
    • 
│ │ │ │  
  • enum metric_type_t
    • 
│ │ │ │  
  • ip_filter
│ │ │ │  
    • 
│ │ │ │  
  • add_files()
    • 
│ │ │ │  
  • set_piece_hashes()
    • 
│ │ │ │  
  • bitfield
│ │ │ │  
    • 
│ │ │ │  
  • hasher256
│ │ │ │  
    • 
│ │ │ │  
  • torrent_status
│ │ │ │  
    • 
│ │ │ │  
  • announce_infohash
    • 
│ │ │ │  
  • announce_endpoint
    • 
│ │ │ │  
  • announce_entry
│ │ │ │  
    • 
│ │ │ │  
  • settings_pack
│ │ │ │  
    • 
│ │ │ │  
  • sign_mutable_item()
    • 
│ │ │ │  
  • dht_default_storage_constructor()
    • 
│ │ │ │  
  • announce_flags_t
    • 
│ │ │ │  
  • read_resume_data()
    • 
│ │ │ │ -
  • write_resume_data_buf() write_resume_data()
    • 
│ │ │ │ +
  • write_resume_data() write_resume_data_buf()
    • 
│ │ │ │  
  • write_torrent_file() write_torrent_file_buf()
    • 
│ │ │ │  
  • write_torrent_flags_t
    • 
│ │ │ │  
  • ed25519_create_seed()
    • 
│ │ │ │  
  • ed25519_create_keypair()
    • 
│ │ │ │  
  • ed25519_sign()
    • 
│ │ │ │  
  • ed25519_verify()
    • 
│ │ │ │  
  • ed25519_add_scalar()
    • 
│ │ │ │ @@ -2134,17 +2134,17 @@
│ │ │ │  
    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 (settings_pack&& sp);
│ │ │ │     session_params ();
│ │ │ │ +   session_params (settings_pack&& sp);
│ │ │ │ +   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;
│ │ │ │ @@ -2154,17 +2154,17 @@
│ │ │ │     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 (settings_pack&& sp);
│ │ │ │  session_params ();
│ │ │ │ +session_params (settings_pack&& sp);
│ │ │ │ +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()
    
│ │ │ │ @@ -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 ();
│ │ │ │     session_proxy (session_proxy&&) noexcept;
│ │ │ │ -   session_proxy (session_proxy const&);
│ │ │ │ -   session_proxy ();
│ │ │ │     session_proxy& operator= (session_proxy const&) &;
│ │ │ │ +   ~session_proxy ();
│ │ │ │     session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ +   session_proxy ();
│ │ │ │ +   session_proxy (session_proxy const&);
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    ~session_proxy() session_proxy() operator=()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    operator=() ~session_proxy() session_proxy()
    
│ │ │ │  
    │ │ │ │ -~session_proxy ();
│ │ │ │  session_proxy (session_proxy&&) noexcept;
│ │ │ │ -session_proxy (session_proxy const&);
│ │ │ │ -session_proxy ();
│ │ │ │  session_proxy& operator= (session_proxy const&) &;
│ │ │ │ +~session_proxy ();
│ │ │ │  session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ +session_proxy ();
│ │ │ │ +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 ();
│ │ │ │ +   session (session_params const& 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 (session_params&& params, session_flags_t flags);
│ │ │ │ -   session (session_params const& 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 (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │     ~session ();
│ │ │ │     session_proxy abort ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    session()
    
│ │ │ │  
    │ │ │ │ -session ();
│ │ │ │ +session (session_params const& 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 (session_params&& 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 const& 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 (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.
    
│ │ │ │  
    
│ │ │ │ @@ -2358,77 +2358,77 @@
│ │ │ │  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 const& st);
│ │ │ │     void set_dht_state (dht::dht_state&& st);
│ │ │ │ -   std::vector<torrent_handle> get_torrents () const;
│ │ │ │     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);
│ │ │ │ +   void async_add_torrent (add_torrent_params&& params);
│ │ │ │     torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ +   torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │     torrent_handle add_torrent (add_torrent_params&& 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, 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);
│ │ │ │     void dht_put_item (std::array<char, 32> key
│ │ │ │        , std::function<void(entry&, std::array<char, 64>&
│ │ │ │        , std::int64_t&, std::string const&)> cb
│ │ │ │        , std::string salt = std::string());
│ │ │ │ -   void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │     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);
│ │ │ │     ip_filter get_ip_filter () const;
│ │ │ │     void set_ip_filter (ip_filter f);
│ │ │ │     void set_port_filter (port_filter const& f);
│ │ │ │ +   bool is_listening () const;
│ │ │ │     unsigned short listen_port () const;
│ │ │ │     unsigned short ssl_listen_port () const;
│ │ │ │ -   bool is_listening () const;
│ │ │ │ -   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);
│ │ │ │     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);
│ │ │ │ -   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 set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │     void remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ │ -   void apply_settings (settings_pack&&);
│ │ │ │     settings_pack get_settings () const;
│ │ │ │ +   void apply_settings (settings_pack&&);
│ │ │ │     void apply_settings (settings_pack const&);
│ │ │ │ +   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 pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ -   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;
│ │ │ │ @@ -2460,24 +2460,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]
    
│ │ │ │ -
    
│ │ │ │ -
    get_torrent_status() refresh_torrent_status()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    refresh_torrent_status() get_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.
    
│ │ │ │  
    
│ │ │ │ @@ -2552,16 +2552,16 @@
│ │ │ │  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()
    
│ │ │ │  
    │ │ │ │ -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.
    
│ │ │ │ @@ -2569,19 +2569,19 @@
│ │ │ │  torrents currently in the session.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    async_add_torrent() add_torrent()
    
│ │ │ │  
    │ │ │ │  torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ +void async_add_torrent (add_torrent_params&& params);
│ │ │ │  torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │  torrent_handle add_torrent (add_torrent_params&& 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, 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,19 +2606,19 @@
│ │ │ │  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 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
│ │ │ │ @@ -2730,21 +2730,21 @@
│ │ │ │  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_get_peers (sha1_hash const& info_hash);
│ │ │ │  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.
    
│ │ │ │  
    dht_announce() will issue a DHT announce request to the DHT to the
│ │ │ │  specified info-hash, advertising the specified port. If the port is
│ │ │ │  left at its default, 0, the port will be implied by the DHT message's
│ │ │ │ @@ -2827,18 +2827,18 @@
│ │ │ │  that sends bad data with very high accuracy. Should
│ │ │ │  eliminate most problems on poisoned torrents.
│ │ │ │  
│ │ │ │  
    │ │ │ │  #include <libtorrent/extensions/smart_ban.hpp>
│ │ │ │  ses.add_extension(&lt::create_smart_ban_plugin);
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    set_ip_filter() get_ip_filter()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    get_ip_filter() set_ip_filter()
    
│ │ │ │  
    │ │ │ │  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
│ │ │ │ @@ -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]
    
│ │ │ │ -
    
│ │ │ │ -
    ssl_listen_port() listen_port() is_listening()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    is_listening() ssl_listen_port() listen_port()
    
│ │ │ │  
    │ │ │ │ +bool is_listening () const;
│ │ │ │  unsigned short listen_port () const;
│ │ │ │  unsigned short ssl_listen_port () const;
│ │ │ │ -bool is_listening () 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]
    
│ │ │ │  
    
│ │ │ │  
    get_peer_class_filter() set_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.
    
│ │ │ │ @@ -2960,16 +2960,16 @@
│ │ │ │  destructs.
    
│ │ │ │  
    For more information on peer classes, see peer classes.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    get_peer_class() set_peer_class()
    
│ │ │ │  
    │ │ │ │ -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 set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │  
    
│ │ │ │  
    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
│ │ │ │ @@ -3009,35 +3009,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&&);
│ │ │ │  settings_pack get_settings () const;
│ │ │ │ +void apply_settings (settings_pack&&);
│ │ │ │  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() wait_for_alert() pop_alerts()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    wait_for_alert() pop_alerts() set_alert_notify()
    
│ │ │ │  
    │ │ │ │ +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 pop_alerts (std::vector<alert*>* alerts);
│ │ │ │  
    
│ │ │ │  
    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
│ │ │ │ @@ -3083,21 +3083,21 @@
│ │ │ │  message to an HWND or some other main message pump. The actual
│ │ │ │  retrieval of alerts should not be done in the callback. In fact, the
│ │ │ │  callback should not block. It should not perform any expensive work.
│ │ │ │  It really should just notify the main application thread.
    
│ │ │ │  
    The type of an alert 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.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    delete_port_mapping() add_port_mapping()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_port_mapping() delete_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]
    
│ │ │ │ @@ -3171,19 +3171,19 @@
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    read_session_params() write_session_params_buf() write_session_params()
    
│ │ │ │  
    Declared in "libtorrent/session_params.hpp"
    
│ │ │ │  
    │ │ │ │ -session_params read_session_params (span<char const> buf
│ │ │ │ +entry write_session_params (session_params const& sp
│ │ │ │     , 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
│ │ │ │ +session_params read_session_params (span<char const> buf
│ │ │ │     , 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());
│ │ │ │  
    
│ │ │ │  
    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
│ │ │ │ @@ -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 (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -   torrent_info (char const* buffer, int size);
│ │ │ │ -   explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ -   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -   torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ -   torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ -   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);
│ │ │ │     torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -   explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │     explicit torrent_info (std::string const& filename);
│ │ │ │     torrent_info (torrent_info const& t);
│ │ │ │ +   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +   torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +   explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +   torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ +   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 (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │     ~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);
│ │ │ │ +   std::vector<announce_entry> const& trackers () const;
│ │ │ │     void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ -   void clear_trackers ();
│ │ │ │     void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ -   std::vector<announce_entry> const& trackers () const;
│ │ │ │ -   std::vector<std::string> collections () const;
│ │ │ │ +   void clear_trackers ();
│ │ │ │     std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ -   void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +   std::vector<std::string> collections () const;
│ │ │ │     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 set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │     std::int64_t total_size () const;
│ │ │ │     int num_pieces () const;
│ │ │ │     int piece_length () const;
│ │ │ │     int blocks_per_piece () const;
│ │ │ │ +   index_range<piece_index_t> piece_range () const;
│ │ │ │     piece_index_t last_piece () const;
│ │ │ │     piece_index_t end_piece () const;
│ │ │ │ -   index_range<piece_index_t> piece_range () const;
│ │ │ │     sha1_hash info_hash () const noexcept;
│ │ │ │     info_hash_t const& info_hashes () const;
│ │ │ │ -   bool v2 () const;
│ │ │ │     bool v1 () const;
│ │ │ │ +   bool v2 () 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 (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -torrent_info (char const* buffer, int size);
│ │ │ │ -explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ -torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ -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);
│ │ │ │  torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │  explicit torrent_info (std::string const& filename);
│ │ │ │  torrent_info (torrent_info const& t);
│ │ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ +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 (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │  
    
│ │ │ │  
    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& orig_files () const;
│ │ │ │  file_storage const& 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]
    
│ │ │ │ -
    
│ │ │ │ -
    clear_trackers() trackers() add_tracker()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    trackers() add_tracker() clear_trackers()
    
│ │ │ │  
    │ │ │ │ +std::vector<announce_entry> const& trackers () const;
│ │ │ │  void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ -void clear_trackers ();
│ │ │ │  void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ -std::vector<announce_entry> const& trackers () const;
│ │ │ │ +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
│ │ │ │ @@ -3520,37 +3520,37 @@
│ │ │ │  
    trackers() returns all entries from announce-list.
    
│ │ │ │  
    clear_trackers() removes all trackers from announce-list.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    collections() similar_torrents()
    
│ │ │ │  
    │ │ │ │ -std::vector<std::string> collections () const;
│ │ │ │  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_url_seed() add_http_seed() web_seeds()
    
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_http_seed() set_web_seeds() web_seeds() add_url_seed()
    
│ │ │ │  
    │ │ │ │ -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 set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │  
    
│ │ │ │  
    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
│ │ │ │ @@ -3594,22 +3594,22 @@
│ │ │ │  
    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]
    
│ │ │ │ -
    
│ │ │ │ -
    end_piece() last_piece() piece_range()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    end_piece() piece_range() last_piece()
    
│ │ │ │  
    │ │ │ │ +index_range<piece_index_t> piece_range () const;
│ │ │ │  piece_index_t last_piece () const;
│ │ │ │  piece_index_t end_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.
    
│ │ │ │ @@ -3625,16 +3625,16 @@
│ │ │ │  info_hashes() to get an object that may hold both a v1 and v2
│ │ │ │  info-hash
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    v1() v2()
    
│ │ │ │  
    │ │ │ │ -bool v2 () const;
│ │ │ │  bool v1 () const;
│ │ │ │ +bool v2 () 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()
    
│ │ │ │ @@ -3707,18 +3707,18 @@
│ │ │ │  
    
│ │ │ │  
    piece_size()
    
│ │ │ │  
    │ │ │ │  int piece_size (piece_index_t index) const;
│ │ │ │  
    
│ │ │ │  
    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() hash_for_piece_ptr()
    
│ │ │ │ +
│ │ │ │ +[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;
│ │ │ │  
    
│ │ │ │  
    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.
│ │ │ │ @@ -4330,17 +4330,17 @@
│ │ │ │  
    If has_v2() is false then the v1 hash might actually be a truncated
│ │ │ │  v2 hash
    
│ │ │ │  
    
│ │ │ │  
    │ │ │ │  struct info_hash_t
│ │ │ │  {
│ │ │ │     explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ -   explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ -   info_hash_t () noexcept = default;
│ │ │ │     info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ +   info_hash_t () noexcept = default;
│ │ │ │ +   explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │     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;
│ │ │ │ @@ -4352,28 +4352,28 @@
│ │ │ │     sha256_hash v2;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    info_hash_t()
    
│ │ │ │  
    │ │ │ │  explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ -explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ -info_hash_t () noexcept = default;
│ │ │ │  info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ +info_hash_t () noexcept = default;
│ │ │ │ +explicit info_hash_t (sha1_hash h1) 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_v2() has_v1() has()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    has_v2() has() has_v1()
    
│ │ │ │  
    │ │ │ │  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.
    
│ │ │ │ @@ -4453,33 +4453,33 @@
│ │ │ │  
    start
    
│ │ │ │  
    The byte offset within that piece where the range starts.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    length
    
│ │ │ │  
    The size of the range, in bytes.
    
│ │ │ │  
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ +[report issue]
    
│ │ │ │  
    
│ │ │ │ -
    
│ │ │ │ -
    load_torrent_file() load_torrent_parsed() load_torrent_buffer()
    
│ │ │ │ +
    
│ │ │ │ +
    load_torrent_buffer() load_torrent_file() load_torrent_parsed()
    
│ │ │ │  
    Declared in "libtorrent/load_torrent.hpp"
    
│ │ │ │  
    │ │ │ │ -add_torrent_params load_torrent_file (
│ │ │ │ -   std::string const& filename);
│ │ │ │  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);
│ │ │ │  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);
│ │ │ │ -add_torrent_params load_torrent_parsed (
│ │ │ │     bdecode_node const& torrent_file, 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).
│ │ │ │ @@ -4492,17 +4492,17 @@
│ │ │ │  
│ │ │ │  
│ │ │ │  [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_handle const& handle);
│ │ │ │  std::string make_magnet_uri (torrent_info const& info);
│ │ │ │ +std::string make_magnet_uri (torrent_handle const& handle);
│ │ │ │ +std::string make_magnet_uri (add_torrent_params const& atp);
│ │ │ │  
    
│ │ │ │  
    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,16 +4522,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.
    
│ │ │ │ @@ -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_pause() on_resume()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_resume() on_pause()
    
│ │ │ │  
    │ │ │ │  virtual bool on_pause ();
│ │ │ │  virtual bool on_resume ();
│ │ │ │  
    
│ │ │ │  
    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_request (peer_request const&);
│ │ │ │ -   virtual bool on_have_all ();
│ │ │ │ -   virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ -   virtual bool on_have (piece_index_t);
│ │ │ │ -   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │     virtual bool on_unchoke ();
│ │ │ │ +   virtual bool on_interested ();
│ │ │ │ +   virtual bool on_dont_have (piece_index_t);
│ │ │ │     virtual bool on_have_none ();
│ │ │ │ +   virtual bool on_have_all ();
│ │ │ │ +   virtual bool on_request (peer_request const&);
│ │ │ │ +   virtual bool on_have (piece_index_t);
│ │ │ │     virtual bool on_not_interested ();
│ │ │ │ +   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ +   virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │     virtual bool on_choke ();
│ │ │ │ -   virtual bool on_dont_have (piece_index_t);
│ │ │ │ -   virtual bool on_interested ();
│ │ │ │     virtual bool on_piece (peer_request const& /*piece*/
│ │ │ │        , span<char const> /*buf*/);
│ │ │ │ -   virtual bool on_suggest (piece_index_t);
│ │ │ │     virtual bool on_cancel (peer_request const&);
│ │ │ │     virtual bool on_reject (peer_request const&);
│ │ │ │ -   virtual void sent_cancel (peer_request const&);
│ │ │ │ -   virtual void sent_allow_fast (piece_index_t);
│ │ │ │ -   virtual void sent_request (peer_request const&);
│ │ │ │ +   virtual bool on_suggest (piece_index_t);
│ │ │ │ +   virtual void sent_reject_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_cancel (peer_request const&);
│ │ │ │ +   virtual void sent_request (peer_request const&);
│ │ │ │     virtual void sent_choke ();
│ │ │ │ -   virtual void sent_reject_request (peer_request const&);
│ │ │ │     virtual void sent_have_all ();
│ │ │ │ +   virtual void sent_have (piece_index_t);
│ │ │ │ +   virtual void sent_piece (peer_request const&);
│ │ │ │     virtual void sent_unchoke ();
│ │ │ │     virtual void sent_interested ();
│ │ │ │     virtual void sent_not_interested ();
│ │ │ │ -   virtual void sent_have (piece_index_t);
│ │ │ │ -   virtual void sent_piece (peer_request const&);
│ │ │ │     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);
│ │ │ │ @@ -5571,38 +5571,38 @@
│ │ │ │  
    
│ │ │ │  
    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_all() on_not_interested() on_interested() on_choke() on_dont_have() on_allowed_fast() on_unchoke() on_have_none() on_bitfield() on_request() on_have()
    
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_have_all() on_choke() on_not_interested() on_have_none() on_dont_have() on_bitfield() on_request() on_have() on_allowed_fast() on_unchoke() on_interested()
    
│ │ │ │  
    │ │ │ │ -virtual bool on_request (peer_request const&);
│ │ │ │ -virtual bool on_have_all ();
│ │ │ │ -virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ -virtual bool on_have (piece_index_t);
│ │ │ │ -virtual bool on_allowed_fast (piece_index_t);
│ │ │ │  virtual bool on_unchoke ();
│ │ │ │ +virtual bool on_interested ();
│ │ │ │ +virtual bool on_dont_have (piece_index_t);
│ │ │ │  virtual bool on_have_none ();
│ │ │ │ +virtual bool on_have_all ();
│ │ │ │ +virtual bool on_request (peer_request const&);
│ │ │ │ +virtual bool on_have (piece_index_t);
│ │ │ │  virtual bool on_not_interested ();
│ │ │ │ +virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ +virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │  virtual bool on_choke ();
│ │ │ │ -virtual bool on_dont_have (piece_index_t);
│ │ │ │ -virtual bool on_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]
    
│ │ │ │ @@ -5615,26 +5615,26 @@
│ │ │ │  
    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_have() sent_piece() sent_interested() sent_not_interested() sent_unchoke()
    
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    sent_have() sent_not_interested() sent_piece() sent_unchoke() sent_interested()
    
│ │ │ │  
    │ │ │ │ +virtual void sent_have (piece_index_t);
│ │ │ │ +virtual void sent_piece (peer_request const&);
│ │ │ │  virtual void sent_unchoke ();
│ │ │ │  virtual void sent_interested ();
│ │ │ │  virtual void sent_not_interested ();
│ │ │ │ -virtual void sent_have (piece_index_t);
│ │ │ │ -virtual void sent_piece (peer_request const&);
│ │ │ │  
    
│ │ │ │  
    called after a choke message has been sent to the peer
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    sent_payload()
    
│ │ │ │  
    │ │ │ │  virtual void sent_payload (int /* bytes */);
│ │ │ │ @@ -5737,47 +5737,47 @@
│ │ │ │  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;
│ │ │ │     peer_id const& pid () const;
│ │ │ │     bool has_piece (piece_index_t i) const;
│ │ │ │     bool is_choked () const;
│ │ │ │     bool is_interesting () const;
│ │ │ │ -   bool is_peer_interested () const;
│ │ │ │     bool has_peer_choked () const;
│ │ │ │ +   bool is_peer_interested () const;
│ │ │ │     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_disconnecting () const;
│ │ │ │ +   bool is_outgoing () 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 is_connecting () 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 should_log (peer_log_alert::direction_t direction) const;
│ │ │ │     bool can_disconnect (error_code const& ec) const;
│ │ │ │     bool has_metadata () const;
│ │ │ │     bool in_handshake () const;
│ │ │ │     void send_buffer (char const* begin, int size);
│ │ │ │ -   std::time_t last_seen_complete () const;
│ │ │ │     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;
│ │ │ │     std::shared_ptr<peer_connection> native_handle () const;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -5790,16 +5790,16 @@
│ │ │ │  
    │ │ │ │  struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │  {
│ │ │ │     explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ │     bool packet_finished () const;
│ │ │ │     bool support_extensions () 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"
    
│ │ │ │ @@ -5879,76 +5879,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
│ │ │ │ -      , 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_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 (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 (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;
│ │ │ │ -   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);
│ │ │ │ +   std::string const& name () const;
│ │ │ │     void swap (file_storage& ti) noexcept;
│ │ │ │     void canonicalize ();
│ │ │ │ -   std::time_t mtime (file_index_t index) const;
│ │ │ │ -   std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ +   std::int64_t file_offset (file_index_t index) const;
│ │ │ │ +   std::int64_t file_size (file_index_t index) const;
│ │ │ │     std::string symlink (file_index_t index) const;
│ │ │ │     sha1_hash hash (file_index_t index) const;
│ │ │ │ -   sha256_hash root (file_index_t index) const;
│ │ │ │ -   std::int64_t file_offset (file_index_t index) const;
│ │ │ │ -   char const* root_ptr (file_index_t const index) const;
│ │ │ │     string_view file_name (file_index_t index) const;
│ │ │ │     bool pad_file_at (file_index_t index) const;
│ │ │ │ -   std::int64_t file_size (file_index_t index) const;
│ │ │ │ -   int file_num_pieces (file_index_t index) const;
│ │ │ │ +   std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ +   sha256_hash root (file_index_t index) const;
│ │ │ │ +   char const* root_ptr (file_index_t const index) const;
│ │ │ │ +   std::time_t mtime (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;
│ │ │ │     int file_first_piece_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;
│ │ │ │ @@ -5975,28 +5975,28 @@
│ │ │ │  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()
    
│ │ │ │  
    │ │ │ │ -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 (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_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 (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 (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
│ │ │ │ @@ -6098,21 +6098,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]
    
│ │ │ │ -
    
│ │ │ │ -
    set_num_pieces() num_pieces()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    num_pieces() set_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;
│ │ │ │ @@ -6137,16 +6137,16 @@
│ │ │ │  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()
    
│ │ │ │  
    │ │ │ │ -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()
    
│ │ │ │  
    │ │ │ │ @@ -6175,21 +6175,21 @@
│ │ │ │  
    
│ │ │ │  
    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]
    
│ │ │ │ -
    
│ │ │ │ -
    name() set_name()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    set_name() name()
    
│ │ │ │  
    │ │ │ │ -std::string const& name () const;
│ │ │ │  void set_name (std::string const& n);
│ │ │ │ +std::string const& name () const;
│ │ │ │  
    
│ │ │ │  
    set and get the name of this torrent. For multi-file torrents, this is also
│ │ │ │  the name of the root directory all the files are stored in.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    swap()
    
│ │ │ │  
    │ │ │ │ @@ -6200,37 +6200,37 @@
│ │ │ │  
    
│ │ │ │  
    canonicalize()
    
│ │ │ │  
    │ │ │ │  void canonicalize ();
│ │ │ │  
    
│ │ │ │  
    arrange files and padding to match the canonical form required
│ │ │ │  by BEP 52
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
    
│ │ │ │  
    file_piece_range() file_num_blocks() file_num_pieces()
    
│ │ │ │  
    │ │ │ │ -int file_num_pieces (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;
│ │ │ │  
    
│ │ │ │  
    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_block_node() file_first_piece_node()
    
│ │ │ │ +
│ │ │ │ +[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;
│ │ │ │  
    
│ │ │ │  
    index of first piece node in the merkle tree
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ @@ -6309,21 +6309,21 @@
│ │ │ │  
    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_offset() file_index_at_piece()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    file_index_at_piece() file_index_at_offset()
    
│ │ │ │  
    │ │ │ │ -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;
│ │ │ │ @@ -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);
│ │ │ │ -   T* get () const;
│ │ │ │     explicit operator T () const;
│ │ │ │ -   client_data_t& operator= (void const*) = delete;
│ │ │ │ +   T* get () const;
│ │ │ │     operator void* () const = delete;
│ │ │ │ -   client_data_t& operator= (void*) = delete;
│ │ │ │     operator void const* () const = delete;
│ │ │ │ +   client_data_t& operator= (void const*) = delete;
│ │ │ │ +   client_data_t& operator= (void*) = 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]
    
│ │ │ │ -
    
│ │ │ │ -
    void*() operator=() const*()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    const*() operator=() void*()
    
│ │ │ │  
    │ │ │ │ -client_data_t& operator= (void const*) = delete;
│ │ │ │  operator void* () const = delete;
│ │ │ │ -client_data_t& operator= (void*) = delete;
│ │ │ │  operator void const* () const = delete;
│ │ │ │ +client_data_t& operator= (void const*) = delete;
│ │ │ │ +client_data_t& operator= (void*) = delete;
│ │ │ │  
    
│ │ │ │  
    we don't allow type-unsafe operations
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    add_torrent_params
    
│ │ │ │  
    Declared in "libtorrent/add_torrent_params.hpp"
    
│ │ │ │ @@ -6988,16 +6988,16 @@
│ │ │ │  peer-classes from peers. It is applied after the peer class filter is applied (which
│ │ │ │  is based on the peer's IP address).
    
│ │ │ │  
    │ │ │ │  struct peer_class_type_filter
│ │ │ │  {
│ │ │ │     void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │     void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ -   void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │     void allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ +   void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │     std::uint32_t apply (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │     friend bool operator== (peer_class_type_filter const& lhs
│ │ │ │        , peer_class_type_filter const& rhs);
│ │ │ │  
│ │ │ │     enum socket_type_t
│ │ │ │     {
│ │ │ │        tcp_socket,
│ │ │ │ @@ -7014,21 +7014,21 @@
│ │ │ │  
    add() remove()
    
│ │ │ │  
    │ │ │ │  void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │  void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │  
    
│ │ │ │  
    add() and remove() adds and removes a peer class to be added
│ │ │ │  to new peers based on socket type.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    disallow() allow()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    allow() disallow()
    
│ │ │ │  
    │ │ │ │ -void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │  void allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ +void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │  
    
│ │ │ │  
    disallow() and allow() adds and removes a peer class to be
│ │ │ │  removed from new peers based on socket type.
    
│ │ │ │  
    The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ │  peer classes in the peer_class_type_filter are 32 bits.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ @@ -7106,17 +7106,17 @@
│ │ │ │  
│ │ │ │     unsigned bytes_progress:15;
│ │ │ │     unsigned block_size:15;
│ │ │ │     unsigned state:2;
│ │ │ │     unsigned num_peers:14;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    peer() set_peer()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    set_peer() peer()
    
│ │ │ │  
    │ │ │ │  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]
    
│ │ │ │  
    
│ │ │ │ @@ -7258,109 +7258,109 @@
│ │ │ │  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, 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 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_peer_info () const;
│ │ │ │     void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ -   std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ -   void post_download_queue () const;
│ │ │ │ +   torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │     void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ -   void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ +   void post_download_queue () const;
│ │ │ │ +   std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │     void reset_piece_deadline (piece_index_t index) const;
│ │ │ │     void clear_piece_deadlines () const;
│ │ │ │ +   void set_piece_deadline (piece_index_t index, int deadline, deadline_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;
│ │ │ │     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<open_file_state> file_status () const;
│ │ │ │     void clear_error () const;
│ │ │ │ +   std::vector<announce_entry> trackers () const;
│ │ │ │     void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │     void post_trackers () const;
│ │ │ │     void add_tracker (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 remove_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;
│ │ │ │ +   std::set<std::string> http_seeds () 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 pause (pause_flags_t flags = {}) const;
│ │ │ │     void resume () const;
│ │ │ │ +   void pause (pause_flags_t flags = {}) const;
│ │ │ │     torrent_flags_t flags () const;
│ │ │ │ -   void unset_flags (torrent_flags_t flags) const;
│ │ │ │     void set_flags (torrent_flags_t flags) const;
│ │ │ │ +   void unset_flags (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;
│ │ │ │ +   bool need_save_resume_data () const;
│ │ │ │ +   void queue_position_top () const;
│ │ │ │ +   queue_position_t queue_position () const;
│ │ │ │     void queue_position_bottom () const;
│ │ │ │     void queue_position_down () const;
│ │ │ │ -   queue_position_t queue_position () const;
│ │ │ │ -   void queue_position_top () 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 = "");
│ │ │ │     std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │     std::shared_ptr<torrent_info> torrent_file_with_hashes () 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;
│ │ │ │     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 piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │     void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ -   download_priority_t file_priority (file_index_t index) const;
│ │ │ │ -   std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ +   download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ +   std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │     void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ +   std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ +   download_priority_t file_priority (file_index_t index) const;
│ │ │ │     void file_priority (file_index_t index, download_priority_t priority) 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;
│ │ │ │ -   void set_download_limit (int limit) const;
│ │ │ │ -   int download_limit () const;
│ │ │ │     void set_upload_limit (int limit) const;
│ │ │ │     int upload_limit () const;
│ │ │ │ +   int download_limit () const;
│ │ │ │ +   void set_download_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 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;
│ │ │ │ +   info_hash_t info_hashes () 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;
│ │ │ │ @@ -7393,16 +7393,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, 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 add_piece (piece_index_t piece, char const* 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
│ │ │ │ @@ -7439,39 +7439,39 @@
│ │ │ │  
    
│ │ │ │  
    have_piece()
    
│ │ │ │  
    │ │ │ │  bool have_piece (piece_index_t piece) const;
│ │ │ │  
    
│ │ │ │  
    Returns true if this piece has been completely downloaded and written
│ │ │ │  to disk, and false otherwise.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    post_peer_info() get_peer_info()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    get_peer_info() post_peer_info()
    
│ │ │ │  
    │ │ │ │ -void post_peer_info () const;
│ │ │ │  void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ +void post_peer_info () const;
│ │ │ │  
    
│ │ │ │  
    Query information about connected peers for this torrent. If the
│ │ │ │  torrent_handle is invalid, it will throw a system_error exception.
    
│ │ │ │  
    post_peer_info() is asynchronous and will trigger the posting of
│ │ │ │  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
│ │ │ │ @@ -7481,38 +7481,38 @@
│ │ │ │  instead call post_status(). It will trigger posting of a
│ │ │ │  state_update_alert with a single torrent_status object for this
│ │ │ │  torrent.
    
│ │ │ │  
    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 include are defined in this class.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    get_download_queue() post_download_queue()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    post_download_queue() get_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;
│ │ │ │ +std::vector<partial_piece_info> get_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]
    
│ │ │ │ -
    
│ │ │ │ -
    set_piece_deadline() clear_piece_deadlines() reset_piece_deadline()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    reset_piece_deadline() clear_piece_deadlines() set_piece_deadline()
    
│ │ │ │  
    │ │ │ │ -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;
│ │ │ │ +void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) 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
│ │ │ │ @@ -7523,22 +7523,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]
    
│ │ │ │ -
    
│ │ │ │ -
    file_progress() post_file_progress()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    post_file_progress() file_progress()
    
│ │ │ │  
    │ │ │ │  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;
│ │ │ │  std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ +void post_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
│ │ │ │ @@ -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]
    
│ │ │ │ -
    
│ │ │ │ -
    replace_trackers() post_trackers() trackers() add_tracker()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    trackers() replace_trackers() post_trackers() add_tracker()
    
│ │ │ │  
    │ │ │ │ +std::vector<announce_entry> trackers () const;
│ │ │ │  void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │  void post_trackers () const;
│ │ │ │  void add_tracker (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
│ │ │ │  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
│ │ │ │ @@ -7597,42 +7597,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]
    
│ │ │ │ -
    
│ │ │ │ -
    remove_url_seed() add_url_seed() url_seeds()
    
│ │ │ │ +[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 remove_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]
    
│ │ │ │ -
    
│ │ │ │ -
    remove_http_seed() http_seeds() add_http_seed()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_http_seed() remove_http_seed() http_seeds()
    
│ │ │ │  
    │ │ │ │ -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;
│ │ │ │ +std::set<std::string> http_seeds () 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()
    
│ │ │ │ @@ -7679,16 +7679,16 @@
│ │ │ │  network thread. Also unlike other functions, it never throws
│ │ │ │  the system_error exception.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    resume() pause()
    
│ │ │ │  
    │ │ │ │ -void pause (pause_flags_t flags = {}) const;
│ │ │ │  void resume () const;
│ │ │ │ +void pause (pause_flags_t flags = {}) 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.
    
│ │ │ │ @@ -7706,16 +7706,16 @@
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    flags() set_flags() unset_flags()
    
│ │ │ │  
    │ │ │ │  torrent_flags_t flags () const;
│ │ │ │ -void unset_flags (torrent_flags_t flags) const;
│ │ │ │  void set_flags (torrent_flags_t flags) const;
│ │ │ │ +void unset_flags (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.
│ │ │ │ @@ -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,26 +7872,26 @@
│ │ │ │  
    
│ │ │ │  
    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_down() queue_position_top() queue_position_up() queue_position_bottom() queue_position()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    queue_position_top() queue_position_up() queue_position_bottom() queue_position() queue_position_down()
    
│ │ │ │  
    │ │ │ │ +void queue_position_top () const;
│ │ │ │ +queue_position_t queue_position () const;
│ │ │ │  void queue_position_bottom () const;
│ │ │ │  void queue_position_down () const;
│ │ │ │ -queue_position_t queue_position () const;
│ │ │ │ -void queue_position_top () 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
│ │ │ │ @@ -7992,42 +7992,42 @@
│ │ │ │  
    │ │ │ │  std::vector<std::vector<sha256_hash>> piece_layers () 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.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    post_piece_availability() piece_availability()
    
│ │ │ │ +
│ │ │ │ +[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>
│ │ │ │  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]
    
│ │ │ │ -
    
│ │ │ │ -
    piece_priority() get_piece_priorities() prioritize_pieces()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    get_piece_priorities() prioritize_pieces() piece_priority()
    
│ │ │ │  
    │ │ │ │  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 piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │  void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ +download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ +std::vector<download_priority_t> get_piece_priorities () 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
│ │ │ │ @@ -8049,23 +8049,23 @@
│ │ │ │  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]
    
│ │ │ │ -
    
│ │ │ │ -
    prioritize_files() get_file_priorities() file_priority()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    file_priority() prioritize_files() get_file_priorities()
    
│ │ │ │  
    │ │ │ │ -download_priority_t file_priority (file_index_t index) const;
│ │ │ │ -std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │  void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ +std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ +download_priority_t file_priority (file_index_t index) const;
│ │ │ │  void file_priority (file_index_t index, download_priority_t priority) 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
│ │ │ │ @@ -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_upload_limit() download_limit() set_download_limit()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    download_limit() upload_limit() set_upload_limit() set_download_limit()
    
│ │ │ │  
    │ │ │ │ -void set_download_limit (int limit) const;
│ │ │ │ -int download_limit () const;
│ │ │ │  void set_upload_limit (int limit) const;
│ │ │ │  int upload_limit () const;
│ │ │ │ +int download_limit () const;
│ │ │ │ +void set_download_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
│ │ │ │ @@ -8179,18 +8179,18 @@
│ │ │ │  
    clear_peers()
    
│ │ │ │  
    │ │ │ │  void clear_peers ();
│ │ │ │  
    
│ │ │ │  
    This will disconnect all peers and clear the peer list for this
│ │ │ │  torrent. New peers will have to be acquired before resuming, from
│ │ │ │  trackers, DHT or local service discovery, for example.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    set_max_uploads() max_uploads()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    max_uploads() set_max_uploads()
    
│ │ │ │  
    │ │ │ │  void set_max_uploads (int max_uploads) const;
│ │ │ │  int max_uploads () 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
│ │ │ │ @@ -8198,16 +8198,16 @@
│ │ │ │  settings_pack.
    
│ │ │ │  
    max_uploads() returns the current settings.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    max_connections() set_max_connections()
    
│ │ │ │  
    │ │ │ │ -void set_max_connections (int max_connections) const;
│ │ │ │  int max_connections () const;
│ │ │ │ +void set_max_connections (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
│ │ │ │  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
│ │ │ │ @@ -8275,31 +8275,31 @@
│ │ │ │  operation is complete when either a file_renamed_alert or
│ │ │ │  file_rename_failed_alert is posted.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    info_hashes() info_hash()
    
│ │ │ │  
    │ │ │ │ -info_hash_t info_hashes () const;
│ │ │ │  sha1_hash info_hash () const;
│ │ │ │ +info_hash_t info_hashes () 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,16 +8888,16 @@
│ │ │ │  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_index_t idx, disk_interface& disk_io);
│ │ │ │     ~storage_holder ();
│ │ │ │ +   storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ │     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 (storage_holder&& rhs) noexcept;
│ │ │ │ @@ -8945,16 +8945,16 @@
│ │ │ │  
    If this buffer holder is moved-from, default constructed or reset,
│ │ │ │  data() will return nullptr.
    
│ │ │ │  
    │ │ │ │  struct disk_buffer_holder
│ │ │ │  {
│ │ │ │     disk_buffer_holder (disk_buffer_holder&&) noexcept;
│ │ │ │     disk_buffer_holder& operator= (disk_buffer_holder&&) & noexcept;
│ │ │ │ -   disk_buffer_holder& operator= (disk_buffer_holder const&) = delete;
│ │ │ │     disk_buffer_holder (disk_buffer_holder const&) = delete;
│ │ │ │ +   disk_buffer_holder& operator= (disk_buffer_holder const&) = delete;
│ │ │ │     disk_buffer_holder (buffer_allocator_interface& alloc
│ │ │ │        , char* buf, int sz) noexcept;
│ │ │ │     disk_buffer_holder () noexcept = default;
│ │ │ │     ~disk_buffer_holder ();
│ │ │ │     char* data () const noexcept;
│ │ │ │     void reset ();
│ │ │ │     void swap (disk_buffer_holder& h) noexcept;
│ │ │ │ @@ -9033,16 +9033,16 @@
│ │ │ │  
    │ │ │ │  struct settings_interface
│ │ │ │  {
│ │ │ │     virtual bool has_val (int name) const = 0;
│ │ │ │     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 std::string const& get_str (int name) const = 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;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    file_open_mode_t
    
│ │ │ │  
    Declared in "libtorrent/disk_interface.hpp"
    
│ │ │ │ @@ -10139,26 +10139,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* old_path () const;
│ │ │ │     char const* storage_path () const;
│ │ │ │ +   char const* old_path () const;
│ │ │ │  
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::storage;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    old_path() storage_path()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    storage_path() old_path()
    
│ │ │ │  
    │ │ │ │ -char const* old_path () const;
│ │ │ │  char const* storage_path () const;
│ │ │ │ +char const* old_path () const;
│ │ │ │  
    
│ │ │ │  
    the path the torrent was moved to and from, respectively.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    
│ │ │ │  
    storage_moved_failed_alert
    
│ │ │ │  
    Declared in "libtorrent/alert_types.hpp"
    
│ │ │ │ @@ -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;
│ │ │ │ -   std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () 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;
│ │ │ │     sha1_hash node_id;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    num_nodes() nodes()
    
│ │ │ │  
    │ │ │ │ -std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const;
│ │ │ │  int num_nodes () const;
│ │ │ │ +std::vector<std::pair<sha1_hash, udp::endpoint>> 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]
    
│ │ │ │ @@ -11845,32 +11845,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]
    
│ │ │ │  
    num_samples() 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()
    
│ │ │ │ @@ -11931,16 +11931,16 @@
│ │ │ │  
    this alert is posted to indicate to the client that some alerts were
│ │ │ │  dropped. Dropped meaning that the alert failed to be delivered to the
│ │ │ │  client. The most common cause of such failure is that the internal alert
│ │ │ │  queue grew too big (controlled by alert_queue_size).
    
│ │ │ │  
    │ │ │ │  struct alerts_dropped_alert final : alert
│ │ │ │  {
│ │ │ │ -   static_assert (num_alert_types <= abi_alert_count, "need to increase bitset. This is an ABI break");
│ │ │ │     std::string message () const override;
│ │ │ │ +   static_assert (num_alert_types <= abi_alert_count, "need to increase bitset. This is an ABI break");
│ │ │ │  
│ │ │ │     static constexpr alert_category_t static_category  = alert_category::error;
│ │ │ │     std::bitset<abi_alert_count> dropped_alerts;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    dropped_alerts
    
│ │ │ │ @@ -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,25 +12537,25 @@
│ │ │ │  
    
│ │ │ │  
    counters
    
│ │ │ │  
    Declared in "libtorrent/performance_counters.hpp"
    
│ │ │ │  
    │ │ │ │  struct counters
│ │ │ │  {
│ │ │ │     counters () ;
│ │ │ │ -   counters& operator= (counters const&) & ;
│ │ │ │     counters (counters const&) ;
│ │ │ │ +   counters& operator= (counters const&) & ;
│ │ │ │     std::int64_t operator[] (int i) const ;
│ │ │ │     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) ;
│ │ │ │ +   void blend_stats_counter (int c, std::int64_t value, int ratio) ;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    operator[]() inc_stats_counter()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    inc_stats_counter() operator[]()
    
│ │ │ │  
    │ │ │ │  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]
    
│ │ │ │  
    
│ │ │ │ @@ -12641,20 +12641,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 ();
│ │ │ │ +   ip_filter& operator= (ip_filter&&);
│ │ │ │     ~ip_filter ();
│ │ │ │     ip_filter& operator= (ip_filter const&);
│ │ │ │     ip_filter (ip_filter&&);
│ │ │ │ -   ip_filter& operator= (ip_filter&&);
│ │ │ │ -   ip_filter ();
│ │ │ │ -   ip_filter (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
│ │ │ │     {
│ │ │ │ @@ -12738,20 +12738,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&&);
│ │ │ │     port_filter ();
│ │ │ │ -   ~port_filter ();
│ │ │ │     port_filter& operator= (port_filter const&);
│ │ │ │ -   port_filter (port_filter&&);
│ │ │ │ +   port_filter& operator= (port_filter&&);
│ │ │ │ +   ~port_filter ();
│ │ │ │     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,
│ │ │ │     };
│ │ │ │ @@ -12820,45 +12820,45 @@
│ │ │ │  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 (integer_type);
│ │ │ │ -   entry (span<char const>);
│ │ │ │     entry (list_type);
│ │ │ │     entry (preformatted_type);
│ │ │ │ +   entry (integer_type);
│ │ │ │ +   entry (span<char const>);
│ │ │ │     entry (U v);
│ │ │ │     entry (data_type t);
│ │ │ │     entry (bdecode_node const& n);
│ │ │ │ -   entry& operator= (entry&&) & noexcept;
│ │ │ │ -   entry& operator= (entry const&) &;
│ │ │ │ -   entry& operator= (list_type) &;
│ │ │ │ +   entry& operator= (dictionary_type) &;
│ │ │ │ +   entry& operator= (bdecode_node const&) &;
│ │ │ │     entry& operator= (span<char const>) &;
│ │ │ │ +   entry& operator= (list_type) &;
│ │ │ │     entry& operator= (integer_type) &;
│ │ │ │ -   entry& operator= (bdecode_node const&) &;
│ │ │ │ -   entry& operator= (dictionary_type) &;
│ │ │ │     entry& operator= (preformatted_type) &;
│ │ │ │ +   entry& operator= (entry&&) & noexcept;
│ │ │ │ +   entry& operator= (entry const&) &;
│ │ │ │     entry& operator= (U v) &;
│ │ │ │ -   dictionary_type const& dict () const;
│ │ │ │ -   preformatted_type const& preformatted () const;
│ │ │ │ -   dictionary_type& dict ();
│ │ │ │ +   list_type const& list () const;
│ │ │ │     list_type& list ();
│ │ │ │     string_type& string ();
│ │ │ │ -   string_type const& string () const;
│ │ │ │ -   integer_type& integer ();
│ │ │ │     integer_type const& integer () const;
│ │ │ │ +   integer_type& integer ();
│ │ │ │ +   dictionary_type& dict ();
│ │ │ │ +   string_type const& string () const;
│ │ │ │ +   preformatted_type const& preformatted () const;
│ │ │ │     preformatted_type& preformatted ();
│ │ │ │ -   list_type const& list () const;
│ │ │ │ +   dictionary_type const& dict () const;
│ │ │ │     void swap (entry& e);
│ │ │ │ -   entry const& operator[] (string_view key) const;
│ │ │ │     entry& operator[] (string_view key);
│ │ │ │ -   entry* find_key (string_view key);
│ │ │ │ +   entry const& operator[] (string_view key) const;
│ │ │ │     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,
│ │ │ │ @@ -12875,18 +12875,18 @@
│ │ │ │  
    
│ │ │ │  
    returns the concrete type of the entry
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    entry()
    
│ │ │ │  
    │ │ │ │  entry (dictionary_type);
│ │ │ │ -entry (integer_type);
│ │ │ │ -entry (span<char const>);
│ │ │ │  entry (list_type);
│ │ │ │  entry (preformatted_type);
│ │ │ │ +entry (integer_type);
│ │ │ │ +entry (span<char const>);
│ │ │ │  
    
│ │ │ │  
    constructors directly from a specific type.
│ │ │ │  The content of the argument is copied into the
│ │ │ │  newly constructed entry
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    entry()
    
│ │ │ │ @@ -12902,43 +12902,43 @@
│ │ │ │  entry (bdecode_node const& n);
│ │ │ │  
    
│ │ │ │  
    construct from bdecode_node parsed form (see bdecode())
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    operator=()
    
│ │ │ │  
    │ │ │ │ -entry& operator= (entry&&) & noexcept;
│ │ │ │ -entry& operator= (entry const&) &;
│ │ │ │ -entry& operator= (list_type) &;
│ │ │ │ +entry& operator= (dictionary_type) &;
│ │ │ │ +entry& operator= (bdecode_node const&) &;
│ │ │ │  entry& operator= (span<char const>) &;
│ │ │ │ +entry& operator= (list_type) &;
│ │ │ │  entry& operator= (integer_type) &;
│ │ │ │ -entry& operator= (bdecode_node const&) &;
│ │ │ │ -entry& operator= (dictionary_type) &;
│ │ │ │  entry& operator= (preformatted_type) &;
│ │ │ │ +entry& operator= (entry&&) & noexcept;
│ │ │ │ +entry& operator= (entry const&) &;
│ │ │ │  
    
│ │ │ │  
    copies the structure of the right hand side into this
│ │ │ │  entry.
    
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    list() string() preformatted() integer() dict()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    dict() list() integer() preformatted() string()
    
│ │ │ │  
    │ │ │ │ -dictionary_type const& dict () const;
│ │ │ │ -preformatted_type const& preformatted () const;
│ │ │ │ -dictionary_type& dict ();
│ │ │ │ +list_type const& list () const;
│ │ │ │  list_type& list ();
│ │ │ │  string_type& string ();
│ │ │ │ -string_type const& string () const;
│ │ │ │ -integer_type& integer ();
│ │ │ │  integer_type const& integer () const;
│ │ │ │ +integer_type& integer ();
│ │ │ │ +dictionary_type& dict ();
│ │ │ │ +string_type const& string () const;
│ │ │ │ +preformatted_type const& preformatted () const;
│ │ │ │  preformatted_type& preformatted ();
│ │ │ │ -list_type const& list () const;
│ │ │ │ +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
│ │ │ │ @@ -12982,32 +12982,32 @@
│ │ │ │  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.
    
│ │ │ │  
    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]
    
│ │ │ │ @@ -13140,16 +13140,16 @@
│ │ │ │  .torrent file using bencode().
    
│ │ │ │  
    │ │ │ │  struct create_torrent
│ │ │ │  {
│ │ │ │     explicit create_torrent (torrent_info const& ti);
│ │ │ │     explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ │        , create_flags_t flags = {});
│ │ │ │ -   std::vector<char> generate_buf () const;
│ │ │ │     entry generate () const;
│ │ │ │ +   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_http_seed (string_view url);
│ │ │ │ @@ -13212,16 +13212,16 @@
│ │ │ │  entire duration of the create_torrent object.
    
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
│ │ │ │  
    
│ │ │ │  
    generate_buf() generate()
    
│ │ │ │  
    │ │ │ │ -std::vector<char> generate_buf () const;
│ │ │ │  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.
    
│ │ │ │  
    The function returning an entry may be useful to add custom entries
│ │ │ │  to the torrent file before bencoding it and saving it to disk.
    
│ │ │ │  
    Whether the resulting torrent object is v1, v2 or hybrid depends on
│ │ │ │ @@ -13304,18 +13304,18 @@
│ │ │ │  16 kiB blocks. Note that piece sizes must 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 generate().
│ │ │ │  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()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_http_seed() add_url_seed()
    
│ │ │ │  
    │ │ │ │  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
│ │ │ │ @@ -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()
    
│ │ │ │  
    │ │ │ │  bool priv () const;
│ │ │ │  void set_priv (bool p);
│ │ │ │  
    
│ │ │ │  
    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,
│ │ │ │ @@ -13412,18 +13412,18 @@
│ │ │ │  
    │ │ │ │  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]
    
│ │ │ │ -
    
│ │ │ │ -
    add_collection() add_similar_torrent()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    add_similar_torrent() add_collection()
    
│ │ │ │  
    │ │ │ │  void add_collection (string_view c);
│ │ │ │  void add_similar_torrent (sha1_hash ih);
│ │ │ │  
    
│ │ │ │  
    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
│ │ │ │ @@ -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"
    
│ │ │ │  
    │ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , std::function<void(piece_index_t)> const& f);
│ │ │ │  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);
│ │ │ │  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);
│ │ │ │  void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , settings_interface const& settings
│ │ │ │ +   , 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);
│ │ │ │  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,25 +13550,25 @@
│ │ │ │  
    bitfield
    
│ │ │ │  
    Declared in "libtorrent/bitfield.hpp"
    
│ │ │ │  
    The bitfield type stores any number of bits as a bitfield
│ │ │ │  in a heap allocated array.
    
│ │ │ │  
    │ │ │ │  struct bitfield
│ │ │ │  {
│ │ │ │ +   explicit bitfield (int bits);
│ │ │ │     bitfield (bitfield const& rhs);
│ │ │ │     bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ +   bitfield (char const* b, int bits);
│ │ │ │     bitfield (int bits, bool val);
│ │ │ │     bitfield () noexcept = default;
│ │ │ │ -   explicit bitfield (int bits);
│ │ │ │ -   bitfield (char const* b, int bits);
│ │ │ │     void assign (char const* b, int const bits);
│ │ │ │ -   bool get_bit (int index) const noexcept;
│ │ │ │     bool operator[] (int index) const noexcept;
│ │ │ │ -   void set_bit (int index) noexcept;
│ │ │ │ +   bool get_bit (int index) const noexcept;
│ │ │ │     void clear_bit (int index) noexcept;
│ │ │ │ +   void set_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;
│ │ │ │ @@ -13579,20 +13579,20 @@
│ │ │ │     int find_last_clear () const noexcept;
│ │ │ │     bool operator== (lt::bitfield const& rhs) const;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    bitfield()
    
│ │ │ │  
    │ │ │ │ +explicit bitfield (int bits);
│ │ │ │  bitfield (bitfield const& rhs);
│ │ │ │  bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ +bitfield (char const* b, int bits);
│ │ │ │  bitfield (int bits, bool val);
│ │ │ │  bitfield () noexcept = default;
│ │ │ │ -explicit bitfield (int bits);
│ │ │ │ -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
│ │ │ │ @@ -13601,30 +13601,30 @@
│ │ │ │  
    
│ │ │ │  
    assign()
    
│ │ │ │  
    │ │ │ │  void assign (char const* b, int const bits);
│ │ │ │  
    
│ │ │ │  
    copy bitfield from buffer b of bits number of bits, rounded up to
│ │ │ │  the nearest byte boundary.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    get_bit() operator[]()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    operator[]() get_bit()
    
│ │ │ │  
    │ │ │ │ -bool get_bit (int index) const noexcept;
│ │ │ │  bool operator[] (int index) const noexcept;
│ │ │ │ +bool get_bit (int index) const noexcept;
│ │ │ │  
    
│ │ │ │  
    query bit at index. Returns true if bit is 1, otherwise false.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    clear_bit() set_bit()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    set_bit() clear_bit()
    
│ │ │ │  
    │ │ │ │ -void set_bit (int index) noexcept;
│ │ │ │  void clear_bit (int index) noexcept;
│ │ │ │ +void set_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;
│ │ │ │ @@ -13722,41 +13722,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 (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 (hasher const&);
│ │ │ │ +   explicit hasher (span<char const> data);
│ │ │ │ +   hasher (char const* data, int len);
│ │ │ │     hasher& update (char const* data, int len);
│ │ │ │ +   hasher& update (span<char const> data);
│ │ │ │     sha1_hash final ();
│ │ │ │     void reset ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    hasher() operator=()
    
│ │ │ │  
    │ │ │ │ -hasher (char const* data, int len);
│ │ │ │ -explicit hasher (span<char const> data);
│ │ │ │ -hasher (hasher const&);
│ │ │ │  hasher& operator= (hasher const&) &;
│ │ │ │ +hasher (hasher const&);
│ │ │ │ +explicit hasher (span<char const> data);
│ │ │ │ +hasher (char const* data, int len);
│ │ │ │  
    
│ │ │ │  
    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 ();
│ │ │ │ @@ -13776,42 +13776,42 @@
│ │ │ │  
    
│ │ │ │  
    hasher256
    
│ │ │ │  
    Declared in "libtorrent/hasher.hpp"
    
│ │ │ │  
    │ │ │ │  class hasher256
│ │ │ │  {
│ │ │ │     hasher256 ();
│ │ │ │ -   hasher256& operator= (hasher256 const&) &;
│ │ │ │ +   hasher256 (char const* data, int len);
│ │ │ │     explicit hasher256 (span<char const> data);
│ │ │ │     hasher256 (hasher256 const&);
│ │ │ │ -   hasher256 (char const* data, int len);
│ │ │ │ -   hasher256& update (span<char const> data);
│ │ │ │ +   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&) &;
│ │ │ │ +hasher256 (char const* data, int len);
│ │ │ │  explicit hasher256 (span<char const> data);
│ │ │ │  hasher256 (hasher256 const&);
│ │ │ │ -hasher256 (char const* data, int len);
│ │ │ │ +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 ();
│ │ │ │ @@ -14498,18 +14498,18 @@
│ │ │ │  
    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 ();
│ │ │ │ -   announce_entry (announce_entry const&);
│ │ │ │     announce_entry& operator= (announce_entry const&) &;
│ │ │ │ -   explicit announce_entry (string_view u);
│ │ │ │     announce_entry ();
│ │ │ │ +   announce_entry (announce_entry const&);
│ │ │ │ +   explicit announce_entry (string_view u);
│ │ │ │  
│ │ │ │     enum tracker_source
│ │ │ │     {
│ │ │ │        source_torrent,
│ │ │ │        source_client,
│ │ │ │        source_magnet_link,
│ │ │ │        source_tex,
│ │ │ │ @@ -14521,23 +14521,23 @@
│ │ │ │     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 ();
│ │ │ │ -announce_entry (announce_entry const&);
│ │ │ │  announce_entry& operator= (announce_entry const&) &;
│ │ │ │ -explicit announce_entry (string_view u);
│ │ │ │  announce_entry ();
│ │ │ │ +announce_entry (announce_entry const&);
│ │ │ │ +explicit announce_entry (string_view u);
│ │ │ │  
    
│ │ │ │  
    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_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_int (int name, int val) override;
│ │ │ │ +   void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ +   void set_str (int name, std::string val) override;
│ │ │ │     bool has_val (int name) const override;
│ │ │ │     void clear ();
│ │ │ │     void clear (int name);
│ │ │ │ -   bool get_bool (int name) const override;
│ │ │ │ -   int get_int (int name) const override;
│ │ │ │     std::string const& get_str (int name) const override;
│ │ │ │ +   int get_int (int name) const override;
│ │ │ │ +   bool get_bool (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_int() set_bool()
    
│ │ │ │  
    │ │ │ │ -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_int (int name, int val) override;
│ │ │ │ +void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ +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()
    
│ │ │ │ @@ -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_bool() get_int()
    
│ │ │ │  
    │ │ │ │ -bool get_bool (int name) const override;
│ │ │ │ -int get_int (int name) const override;
│ │ │ │  std::string const& get_str (int name) const override;
│ │ │ │ +int get_int (int name) const override;
│ │ │ │ +bool get_bool (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]
    
│ │ │ │ @@ -19764,46 +19764,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 (bdecode_node&&) noexcept;
│ │ │ │     bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ +   bdecode_node (bdecode_node&&) noexcept;
│ │ │ │     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::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;
│ │ │ │ +   bdecode_node list_at (int i) const;
│ │ │ │     int list_size () const;
│ │ │ │ +   std::int64_t list_int_value_at (int i
│ │ │ │ +      , std::int64_t default_val = 0) const;
│ │ │ │ +   bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +   bdecode_node dict_find_int (string_view key) const;
│ │ │ │ +   bdecode_node dict_find (string_view key) 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_dict (string_view key) const;
│ │ │ │ +   int dict_size () const;
│ │ │ │     std::int64_t dict_find_int_value (string_view key
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ -   std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ -   bdecode_node dict_find_string (string_view key) const;
│ │ │ │ -   bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -   bdecode_node dict_find_list (string_view key) const;
│ │ │ │     std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ -   bdecode_node dict_find_int (string_view key) const;
│ │ │ │ -   int dict_size () const;
│ │ │ │ -   bdecode_node dict_find (string_view key) const;
│ │ │ │ +   std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │     std::int64_t int_value () const;
│ │ │ │ -   int string_length () const;
│ │ │ │     char const* string_ptr () const;
│ │ │ │ -   string_view string_value () const;
│ │ │ │     std::ptrdiff_t string_offset () const;
│ │ │ │ +   int string_length () 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;
│ │ │ │  
│ │ │ │     enum type_t
│ │ │ │ @@ -19818,21 +19818,21 @@
│ │ │ │  
    
│ │ │ │  [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 (bdecode_node&&) noexcept;
│ │ │ │  bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ +bdecode_node (bdecode_node&&) noexcept;
│ │ │ │  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]
    
│ │ │ │  
    
│ │ │ │ @@ -19866,57 +19866,57 @@
│ │ │ │  
│ │ │ │  
    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_string_value_at() list_size() list_at() list_int_value_at()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    list_at() list_string_value_at() list_size() list_int_value_at()
    
│ │ │ │  
    │ │ │ │ -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;
│ │ │ │ +bdecode_node list_at (int i) const;
│ │ │ │  int list_size () const;
│ │ │ │ +std::int64_t list_int_value_at (int i
│ │ │ │ +      , std::int64_t default_val = 0) 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_find_int_value() dict_find_string() dict_at() dict_find_string_value() dict_find_list() dict_find_dict() dict_find() dict_at_node() dict_find_int() dict_size()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    dict_find_int_value() dict_find() dict_find_dict() dict_find_string() dict_size() dict_find_list() dict_at() dict_find_int() dict_find_string_value() dict_at_node()
    
│ │ │ │  
    │ │ │ │ +bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +bdecode_node dict_find_int (string_view key) const;
│ │ │ │ +bdecode_node dict_find (string_view key) 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_dict (string_view key) const;
│ │ │ │ +int dict_size () const;
│ │ │ │  std::int64_t dict_find_int_value (string_view key
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ -std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ -bdecode_node dict_find_string (string_view key) const;
│ │ │ │ -bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -bdecode_node dict_find_list (string_view key) const;
│ │ │ │  std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ -bdecode_node dict_find_int (string_view key) const;
│ │ │ │ -int dict_size () const;
│ │ │ │ -bdecode_node dict_find (string_view key) const;
│ │ │ │ +std::pair<bdecode_node, bdecode_node> dict_at_node (int i) 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.
    
│ │ │ │ @@ -19931,25 +19931,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_ptr() string_length() string_value() string_offset()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    string_offset() string_value() string_length() string_ptr()
    
│ │ │ │  
    │ │ │ │ -int string_length () const;
│ │ │ │  char const* string_ptr () const;
│ │ │ │ -string_view string_value () const;
│ │ │ │  std::ptrdiff_t string_offset () const;
│ │ │ │ +int string_length () 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.
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -20388,21 +20388,21 @@
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    read_resume_data()
    
│ │ │ │  
    Declared in "libtorrent/read_resume_data.hpp"
    
│ │ │ │  
    │ │ │ │  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 (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 = {});
│ │ │ │ +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 = {});
│ │ │ │  
    
│ │ │ │  
    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_buf() write_resume_data()
    
│ │ │ │ +
│ │ │ │ +[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"
    
│ │ │ │  
    │ │ │ │ -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
      • 
│ │ │ │ @@ -20510,18 +20510,18 @@
│ │ │ │  
│ │ │ │  
      Verifies the signature on the given message using pk
      
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    ed25519_add_scalar()
    
│ │ │ │  
    Declared in "libtorrent/kademlia/ed25519.hpp"
    
│ │ │ │  
    │ │ │ │ -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);
│ │ │ │ +secret_key ed25519_add_scalar (secret_key const& sk
│ │ │ │ +   , 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 {}
│ │ │ │ │ @@ -22,87 +22,87 @@
│ │ │ │ │      * _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 _~_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 _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_(_)
│ │ │ │ │      * _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 _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 _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 _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 _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 _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 _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 _g_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s___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 _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 _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_(_)_ _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 _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 _w_a_i_t___f_o_r___a_l_e_r_t_(_)_ _p_o_p___a_l_e_r_t_s_(_)_ _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)
│ │ │ │ │ +          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___b_u_f_(_)_ _w_r_i_t_e___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 _c_l_e_a_r___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 _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _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 _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___h_t_t_p___s_e_e_d_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _w_e_b___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)
│ │ │ │ │            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 _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 _e_n_d___p_i_e_c_e_(_)_ _p_i_e_c_e___r_a_n_g_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)
│ │ │ │ │            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_(_)
│ │ │ │ │            o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ -          o _h_a_s_h___f_o_r___p_i_e_c_e_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)
│ │ │ │ │ +          o _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e_(_)
│ │ │ │ │            o _n_a_m_e_(_)
│ │ │ │ │            o _c_r_e_a_t_i_o_n___d_a_t_e_(_)
│ │ │ │ │            o _c_r_e_a_t_o_r_(_)
│ │ │ │ │            o _c_o_m_m_e_n_t_(_)
│ │ │ │ │            o _n_o_d_e_s_(_)
│ │ │ │ │            o _a_d_d___n_o_d_e_(_)
│ │ │ │ │            o _p_a_r_s_e___i_n_f_o___s_e_c_t_i_o_n_(_)
│ │ │ │ │ @@ -110,22 +110,22 @@
│ │ │ │ │            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___v_2_(_)_ _h_a_s___v_1_(_)_ _h_a_s_(_)
│ │ │ │ │ +          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_(_)
│ │ │ │ │ +    * _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_(_)_ _l_o_a_d___t_o_r_r_e_n_t___p_a_r_s_e_d_(_)
│ │ │ │ │      * _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │      * _p_a_r_s_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │      * _t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_)
│ │ │ │ │      * _t_r_u_n_c_a_t_e___f_i_l_e_s_(_)
│ │ │ │ │      * _v_e_r_s_i_o_n_(_)
│ │ │ │ │      * _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │      * _e_n_u_m_ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ │ @@ -153,31 +153,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___p_a_u_s_e_(_)_ _o_n___r_e_s_u_m_e_(_)
│ │ │ │ │ +          o _o_n___r_e_s_u_m_e_(_)_ _o_n___p_a_u_s_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___a_l_l_(_)_ _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___c_h_o_k_e_(_)
│ │ │ │ │ -            _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___u_n_c_h_o_k_e_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)
│ │ │ │ │ -            _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___h_a_v_e_(_)
│ │ │ │ │ +          o _o_n___h_a_v_e___a_l_l_(_)_ _o_n___c_h_o_k_e_(_)_ _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___d_o_n_t___h_a_v_e_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___h_a_v_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___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │            o _o_n___p_i_e_c_e_(_)
│ │ │ │ │ -          o _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)_ _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ -            _s_e_n_t___u_n_c_h_o_k_e_(_)
│ │ │ │ │ +          o _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_(_)_ _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_(_)
│ │ │ │ │            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_(_)
│ │ │ │ │ @@ -196,106 +196,106 @@
│ │ │ │ │            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 _s_e_t___n_u_m___p_i_e_c_e_s_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ +          o _n_u_m___p_i_e_c_e_s_(_)_ _s_e_t___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 _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 _n_a_m_e_(_)_ _s_e_t___n_a_m_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 _m_t_i_m_e_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _h_a_s_h_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _r_o_o_t___p_t_r_(_)_ _f_i_l_e___s_i_z_e_(_)
│ │ │ │ │ -            _s_y_m_l_i_n_k_(_)_ _r_o_o_t_(_)_ _f_i_l_e___p_a_t_h_(_)_ _f_i_l_e___n_a_m_e_(_)
│ │ │ │ │ +          o _f_i_l_e___s_i_z_e_(_)_ _m_t_i_m_e_(_)_ _r_o_o_t_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _s_y_m_l_i_n_k_(_)_ _f_i_l_e___n_a_m_e_(_)
│ │ │ │ │ +            _r_o_o_t___p_t_r_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _f_i_l_e___p_a_t_h_(_)_ _h_a_s_h_(_)
│ │ │ │ │            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___b_l_o_c_k___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_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___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___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 _v_o_i_d_*_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _c_o_n_s_t_*_(_)
│ │ │ │ │ +          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
│ │ │ │ │      * _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 _a_d_d_(_)_ _r_e_m_o_v_e_(_)
│ │ │ │ │ -          o _d_i_s_a_l_l_o_w_(_)_ _a_l_l_o_w_(_)
│ │ │ │ │ +          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
│ │ │ │ │      * _b_l_o_c_k___i_n_f_o
│ │ │ │ │ -          o _p_e_e_r_(_)_ _s_e_t___p_e_e_r_(_)
│ │ │ │ │ +          o _s_e_t___p_e_e_r_(_)_ _p_e_e_r_(_)
│ │ │ │ │            o _e_n_u_m_ _b_l_o_c_k___s_t_a_t_e___t
│ │ │ │ │      * _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 _p_o_s_t___p_e_e_r___i_n_f_o_(_)_ _g_e_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 _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 _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_s_(_)_ _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 _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___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 _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _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_(_)
│ │ │ │ │ +          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 _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_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ -          o _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _u_r_l___s_e_e_d_s_(_)
│ │ │ │ │ -          o _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _h_t_t_p___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ +          o _t_r_a_c_k_e_r_s_(_)_ _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_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ +          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 _r_e_s_u_m_e_(_)_ _p_a_u_s_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 _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___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___u_p_(_)
│ │ │ │ │ -            _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_(_)
│ │ │ │ │ +          o _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_(_)_ _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_(_)_ _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___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_o_s_t___p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)_ _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)
│ │ │ │ │ -          o _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_(_)_ _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)
│ │ │ │ │ -          o _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_(_)_ _f_i_l_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ │ +          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_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___l_s_d___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___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_(_)
│ │ │ │ │ +          o _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_(_)
│ │ │ │ │              _s_e_t___d_o_w_n_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___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_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 _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 _o_l_d___p_a_t_h_(_)_ _s_t_o_r_a_g_e___p_a_t_h_(_)
│ │ │ │ │ +          o _s_t_o_r_a_g_e___p_a_t_h_(_)_ _o_l_d___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
│ │ │ │ │ @@ -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,15 +493,15 @@
│ │ │ │ │            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 _l_i_s_t_(_)_ _s_t_r_i_n_g_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _i_n_t_e_g_e_r_(_)_ _d_i_c_t_(_)
│ │ │ │ │ +          o _d_i_c_t_(_)_ _l_i_s_t_(_)_ _i_n_t_e_g_e_r_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _s_t_r_i_n_g_(_)
│ │ │ │ │            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_(_)
│ │ │ │ │ @@ -510,33 +510,33 @@
│ │ │ │ │            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___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___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 _a_d_d___c_o_l_l_e_c_t_i_o_n_(_)_ _a_d_d___s_i_m_i_l_a_r___t_o_r_r_e_n_t_(_)
│ │ │ │ │ +          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 _g_e_t___b_i_t_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ -          o _c_l_e_a_r___b_i_t_(_)_ _s_e_t___b_i_t_(_)
│ │ │ │ │ +          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 _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 _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_(_)
│ │ │ │ │      * _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_(_)_ _~_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
│ │ │ │ │      * _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___i_n_t_(_)_ _s_e_t___b_o_o_l_(_)
│ │ │ │ │            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___b_o_o_l_(_)_ _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
│ │ │ │ │            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
│ │ │ │ │ @@ -580,25 +580,25 @@
│ │ │ │ │            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_(_)
│ │ │ │ │      * _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 _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___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_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)
│ │ │ │ │ -          o _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)_ _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___l_i_s_t_(_)_ _d_i_c_t___f_i_n_d___d_i_c_t_(_)
│ │ │ │ │ -            _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___i_n_t_(_)_ _d_i_c_t___s_i_z_e_(_)
│ │ │ │ │ +          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___s_i_z_e_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)
│ │ │ │ │ +          o _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___f_i_n_d___d_i_c_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g
│ │ │ │ │ +            _(_)_ _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___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___a_t___n_o_d_e_(_)
│ │ │ │ │            o _i_n_t___v_a_l_u_e_(_)
│ │ │ │ │ -          o _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_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)
│ │ │ │ │ +          o _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___p_t_r_(_)
│ │ │ │ │            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,15 +618,15 @@
│ │ │ │ │            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___b_u_f_(_)_ _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_(_)_ _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_(_)_ _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_(_)
│ │ │ │ │ @@ -1238,17 +1238,17 @@
│ │ │ │ │  [_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 (settings_pack&& sp);
│ │ │ │ │     sseessssiioonn__ppaarraammss ();
│ │ │ │ │ +   sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ +   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;
│ │ │ │ │ @@ -1256,17 +1256,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 (settings_pack const& sp);
│ │ │ │ │ -sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │  sseessssiioonn__ppaarraammss ();
│ │ │ │ │ +sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ +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 const& sp
│ │ │ │ │        , std::vector> exts);
│ │ │ │ │ @@ -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
│ │ │ │ │  {
│ │ │ │ │ -   ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │     sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ │ -   sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ -   sseessssiioonn__pprrooxxyy ();
│ │ │ │ │     session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ +   ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │     session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ +   sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ +   sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │  };
│ │ │ │ │  [_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&&) noexcept;
│ │ │ │ │ -sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ -sseessssiioonn__pprrooxxyy ();
│ │ │ │ │  session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ +~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │  session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ +sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ +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 ();
│ │ │ │ │ +   sseessssiioonn (session_params const& 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 (session_params&& params, session_flags_t flags);
│ │ │ │ │ -   sseessssiioonn (session_params const& 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);
│ │ │ │ │ +   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 ();
│ │ │ │ │ +sseessssiioonn (session_params const& 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 (session_params&& 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 const& 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);
│ │ │ │ │ +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
│ │ │ │ │ @@ -1416,82 +1416,82 @@
│ │ │ │ │  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 const& st);
│ │ │ │ │     void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │ -   std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │     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 const& params);
│ │ │ │ │ -   torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& 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 const& params, error_code&
│ │ │ │ │  ec);
│ │ │ │ │ +   torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ +   void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │     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);
│ │ │ │ │     void ddhhtt__ppuutt__iitteemm (std::array key
│ │ │ │ │        , std::function&
│ │ │ │ │        , std::int64_t&, std::string const&)> cb
│ │ │ │ │        , std::string salt = std::string());
│ │ │ │ │ -   void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │     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);
│ │ │ │ │     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);
│ │ │ │ │     ip_filter ggeett__iipp__ffiilltteerr () const;
│ │ │ │ │     void sseett__iipp__ffiilltteerr (ip_filter f);
│ │ │ │ │     void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ │ +   bool iiss__lliisstteenniinngg () const;
│ │ │ │ │     unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │     unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ -   bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ -   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);
│ │ │ │ │     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);
│ │ │ │ │ -   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 sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │     void rreemmoovvee__ttoorrrreenntt (const torrent_handle&, remove_flags_t = {});
│ │ │ │ │ -   void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │     settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ +   void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │     void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ +   void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │     alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │     void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │ -   void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │ -   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;
│ │ │ │ │ @@ -1517,20 +1517,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]
│ │ │ │ │ -********** ggeett__ttoorrrreenntt__ssttaattuuss(()) rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) **********
│ │ │ │ │ -void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret
│ │ │ │ │ -      , status_flags_t flags = {}) const;
│ │ │ │ │ +********** rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) ggeett__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
│ │ │ │ │ @@ -1582,30 +1582,30 @@
│ │ │ │ │  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;
│ │ │ │ │  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);
│ │ │ │ │ +void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │  torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec);
│ │ │ │ │  torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& 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, 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,15 +1626,15 @@
│ │ │ │ │  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(()) **********
│ │ │ │ │ +********** 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
│ │ │ │ │ @@ -1713,18 +1713,18 @@
│ │ │ │ │  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(()) **********
│ │ │ │ │ -void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ +********** 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
│ │ │ │ │  info-hash, advertising the specified port. If the port is left at its default,
│ │ │ │ │  0, the port will be implied by the DHT message's source port (which may improve
│ │ │ │ │  connectivity through a NAT). dht_announce() is not affected by the
│ │ │ │ │ @@ -1781,15 +1781,15 @@
│ │ │ │ │    smart ban _p_l_u_g_i_n
│ │ │ │ │        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]
│ │ │ │ │ -********** sseett__iipp__ffiilltteerr(()) ggeett__iipp__ffiilltteerr(()) **********
│ │ │ │ │ +********** ggeett__iipp__ffiilltteerr(()) sseett__iipp__ffiilltteerr(()) **********
│ │ │ │ │  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
│ │ │ │ │ @@ -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]
│ │ │ │ │ -********** ssssll__lliisstteenn__ppoorrtt(()) lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) **********
│ │ │ │ │ +********** iiss__lliisstteenniinngg(()) ssssll__lliisstteenn__ppoorrtt(()) lliisstteenn__ppoorrtt(()) **********
│ │ │ │ │ +bool iiss__lliisstteenniinngg () const;
│ │ │ │ │  unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │  unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ -bool iiss__lliisstteenniinngg () 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]
│ │ │ │ │  ********** ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) sseett__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.
│ │ │ │ │ @@ -1875,16 +1875,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]
│ │ │ │ │  ********** 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;
│ │ │ │ │ +void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │  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
│ │ │ │ │ @@ -1914,26 +1914,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(()) **********
│ │ │ │ │ -void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │ +********** aappppllyy__sseettttiinnggss(()) ggeett__sseettttiinnggss(()) **********
│ │ │ │ │  settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ +void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │  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(()) wwaaiitt__ffoorr__aalleerrtt(()) ppoopp__aalleerrttss(()) **********
│ │ │ │ │ +********** wwaaiitt__ffoorr__aalleerrtt(()) ppoopp__aalleerrttss(()) sseett__aalleerrtt__nnoottiiffyy(()) **********
│ │ │ │ │ +void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │  alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │  void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │ -void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │  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.
│ │ │ │ │ @@ -1972,18 +1972,18 @@
│ │ │ │ │  alerts should not be done in the callback. In fact, the callback should not
│ │ │ │ │  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);
│ │ │ │ │ +********** aadddd__ppoorrtt__mmaappppiinngg(()) ddeelleettee__ppoorrtt__mmaappppiinngg(()) **********
│ │ │ │ │  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 =
│ │ │ │ │ @@ -2032,19 +2032,19 @@
│ │ │ │ │        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__bbuuff(()) wwrriittee__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"
│ │ │ │ │ -session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf
│ │ │ │ │ +entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp
│ │ │ │ │     , 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
│ │ │ │ │ +session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf
│ │ │ │ │     , 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());
│ │ │ │ │  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
│ │ │ │ │ @@ -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 (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ -from_span_t);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -   explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ -   explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ -   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);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │  cfg);
│ │ │ │ │ -   explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -   ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │     explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │     ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +   explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +   explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ +   explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ +from_span_t);
│ │ │ │ │ +   ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │     ~~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);
│ │ │ │ │ +   std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │     void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ -   void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │     void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ │ -   std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ -   std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ +   void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │     std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ -   void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ +   std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │     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 sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │     std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │     int nnuumm__ppiieecceess () const;
│ │ │ │ │     int ppiieeccee__lleennggtthh () const;
│ │ │ │ │     int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ +   index_range ppiieeccee__rraannggee () const;
│ │ │ │ │     piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │     piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ -   index_range ppiieeccee__rraannggee () const;
│ │ │ │ │     sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │     info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ -   bool vv22 () const;
│ │ │ │ │     bool vv11 () const;
│ │ │ │ │ +   bool vv22 () 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 (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ -from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ -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);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │  cfg);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │  explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │  ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ +from_span_t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │  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& oorriigg__ffiilleess () const;
│ │ │ │ │  file_storage const& 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,49 +2293,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]
│ │ │ │ │ -********** cclleeaarr__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ +********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ │ +std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │  void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ -void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │  void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ │ -std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ +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]
│ │ │ │ │  ********** ccoolllleeccttiioonnss(()) ssiimmiillaarr__ttoorrrreennttss(()) **********
│ │ │ │ │ -std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │  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__uurrll__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) wweebb__sseeeeddss(()) **********
│ │ │ │ │ -void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ +********** aadddd__hhttttpp__sseeeedd(()) sseett__wweebb__sseeeeddss(()) wweebb__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │  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 sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │  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
│ │ │ │ │ @@ -2362,33 +2362,33 @@
│ │ │ │ │  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(()) **********
│ │ │ │ │ +********** eenndd__ppiieeccee(()) ppiieeccee__rraannggee(()) llaasstt__ppiieeccee(()) **********
│ │ │ │ │ +index_range ppiieeccee__rraannggee () const;
│ │ │ │ │  piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │  piece_index_t eenndd__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__hhaasshheess(()) iinnffoo__hhaasshh(()) **********
│ │ │ │ │  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 vv22 () const;
│ │ │ │ │  bool vv11 () const;
│ │ │ │ │ +bool vv22 () 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
│ │ │ │ │ @@ -2436,15 +2436,15 @@
│ │ │ │ │  than the i2p network.
│ │ │ │ │  [_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(()) hhaasshh__ffoorr__ppiieeccee__ppttrr(()) **********
│ │ │ │ │ +********** 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;
│ │ │ │ │  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]
│ │ │ │ │ @@ -2897,17 +2897,17 @@
│ │ │ │ │  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 (sha256_hash h2) noexcept;
│ │ │ │ │ -   explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ -   iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │     iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │ +   iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │ +   explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │     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)
│ │ │ │ │ @@ -2918,23 +2918,23 @@
│ │ │ │ │  
│ │ │ │ │     sha1_hash v1;
│ │ │ │ │     sha256_hash v2;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** iinnffoo__hhaasshh__tt(()) **********
│ │ │ │ │  explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ │ -explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ -iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │  iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │ +iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │ +explicit iinnffoo__hhaasshh__tt (sha1_hash h1) 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__vv22(()) hhaass__vv11(()) hhaass(()) **********
│ │ │ │ │ +********** hhaass__vv22(()) hhaass(()) hhaass__vv11(()) **********
│ │ │ │ │  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;
│ │ │ │ │ @@ -2989,41 +2989,41 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    start
│ │ │ │ │        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(()) ************
│ │ │ │ │ +************ llooaadd__ttoorrrreenntt__bbuuffffeerr(()) llooaadd__ttoorrrreenntt__ffiillee(()) llooaadd__ttoorrrreenntt__ppaarrsseedd(()) ************
│ │ │ │ │  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__ffiillee (
│ │ │ │ │ -   std::string const& filename);
│ │ │ │ │  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);
│ │ │ │ │  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);
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │     bdecode_node const& torrent_file, 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 (add_torrent_params const& atp);
│ │ │ │ │ -std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle);
│ │ │ │ │  std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info);
│ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle);
│ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp);
│ │ │ │ │  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,16 +3038,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]
│ │ │ │ │ @@ -3591,15 +3591,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__ppaauussee(()) oonn__rreessuummee(()) **********
│ │ │ │ │ +********** oonn__rreessuummee(()) oonn__ppaauussee(()) **********
│ │ │ │ │  virtual bool oonn__ppaauussee ();
│ │ │ │ │  virtual bool oonn__rreessuummee ();
│ │ │ │ │  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__rreeqquueesstt (peer_request const&);
│ │ │ │ │ -   virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ -   virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ -   virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ -   virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │     virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ +   virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ +   virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │     virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ +   virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ +   virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +   virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │     virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +   virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ +   virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │     virtual bool oonn__cchhookkee ();
│ │ │ │ │ -   virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ -   virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │     virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**//
│ │ │ │ │        , span //**bbuuff**//);
│ │ │ │ │ -   virtual bool oonn__ssuuggggeesstt (piece_index_t);
│ │ │ │ │     virtual bool oonn__ccaanncceell (peer_request const&);
│ │ │ │ │     virtual bool oonn__rreejjeecctt (peer_request const&);
│ │ │ │ │ -   virtual void sseenntt__ccaanncceell (peer_request const&);
│ │ │ │ │ -   virtual void sseenntt__aallllooww__ffaasstt (piece_index_t);
│ │ │ │ │ -   virtual void sseenntt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +   virtual bool oonn__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ +   virtual void sseenntt__rreejjeecctt__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__ccaanncceell (peer_request const&);
│ │ │ │ │ +   virtual void sseenntt__rreeqquueesstt (peer_request const&);
│ │ │ │ │     virtual void sseenntt__cchhookkee ();
│ │ │ │ │ -   virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │     virtual void sseenntt__hhaavvee__aallll ();
│ │ │ │ │ +   virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ +   virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │     virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │     virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │     virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ -   virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ -   virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │     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__hhaavvee__aallll(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__iinntteerreesstteedd(()) oonn__cchhookkee(()) oonn__ddoonntt__hhaavvee
│ │ │ │ │ -(()) oonn__aalllloowweedd__ffaasstt(()) oonn__uunncchhookkee(()) oonn__hhaavvee__nnoonnee(()) oonn__bbiittffiieelldd(()) oonn__rreeqquueesstt(())
│ │ │ │ │ -oonn__hhaavvee(()) **********
│ │ │ │ │ -virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ -virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ -virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ -virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ +********** oonn__hhaavvee__aallll(()) oonn__cchhookkee(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee__nnoonnee(()) oonn__ddoonntt__hhaavvee
│ │ │ │ │ +(()) oonn__bbiittffiieelldd(()) oonn__rreeqquueesstt(()) oonn__hhaavvee(()) oonn__aalllloowweedd__ffaasstt(()) oonn__uunncchhookkee(())
│ │ │ │ │ +oonn__iinntteerreesstteedd(()) **********
│ │ │ │ │  virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ +virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ +virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │  virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ +virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ +virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │  virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ +virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │  virtual bool oonn__cchhookkee ();
│ │ │ │ │ -virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual bool oonn__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__hhaavvee(()) sseenntt__ppiieeccee(()) sseenntt__iinntteerreesstteedd(()) sseenntt__nnoott__iinntteerreesstteedd(())
│ │ │ │ │ -sseenntt__uunncchhookkee(()) **********
│ │ │ │ │ +********** sseenntt__hhaavvee(()) sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__ppiieeccee(()) sseenntt__uunncchhookkee(())
│ │ │ │ │ +sseenntt__iinntteerreesstteedd(()) **********
│ │ │ │ │ +virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ +virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │  virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │  virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │  virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ -virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │  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]
│ │ │ │ │ @@ -3831,48 +3831,48 @@
│ │ │ │ │  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;
│ │ │ │ │     peer_id const& ppiidd () const;
│ │ │ │ │     bool hhaass__ppiieeccee (piece_index_t i) const;
│ │ │ │ │     bool iiss__cchhookkeedd () const;
│ │ │ │ │     bool iiss__iinntteerreessttiinngg () const;
│ │ │ │ │ -   bool iiss__ppeeeerr__iinntteerreesstteedd () const;
│ │ │ │ │     bool hhaass__ppeeeerr__cchhookkeedd () const;
│ │ │ │ │ +   bool iiss__ppeeeerr__iinntteerreesstteedd () const;
│ │ │ │ │     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__ddiissccoonnnneeccttiinngg () const;
│ │ │ │ │ +   bool iiss__oouuttggooiinngg () 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 iiss__ccoonnnneeccttiinngg () 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 sshhoouulldd__lloogg (peer_log_alert::direction_t direction) const;
│ │ │ │ │     bool ccaann__ddiissccoonnnneecctt (error_code const& ec) const;
│ │ │ │ │     bool hhaass__mmeettaaddaattaa () const;
│ │ │ │ │     bool iinn__hhaannddsshhaakkee () const;
│ │ │ │ │     void sseenndd__bbuuffffeerr (char const* begin, int size);
│ │ │ │ │ -   std::time_t llaasstt__sseeeenn__ccoommpplleettee () const;
│ │ │ │ │     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;
│ │ │ │ │     std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ************ bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee ************
│ │ │ │ │ @@ -3882,16 +3882,16 @@
│ │ │ │ │  libtorrent versions.
│ │ │ │ │  struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │ │  {
│ │ │ │ │     explicit bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (peer_connection_handle pc);
│ │ │ │ │     bool ppaacckkeett__ffiinniisshheedd () const;
│ │ │ │ │     bool ssuuppppoorrtt__eexxtteennssiioonnss () 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);
│ │ │ │ │ @@ -3952,80 +3952,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
│ │ │ │ │ -      , 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__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 (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 (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;
│ │ │ │ │ -   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);
│ │ │ │ │ +   std::string const& nnaammee () const;
│ │ │ │ │     void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │     void ccaannoonniiccaalliizzee ();
│ │ │ │ │ -   std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ -   std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ -"") const;
│ │ │ │ │ +   std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ +   std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │     std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │     sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ -   sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ -   std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ -   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │     string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │     bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ -   std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ -   int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ +   std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ +"") const;
│ │ │ │ │ +   sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +   std::time_t mmttiimmee (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;
│ │ │ │ │     int ffiillee__ffiirrsstt__ppiieeccee__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;
│ │ │ │ │ @@ -4042,28 +4042,28 @@
│ │ │ │ │  ********** 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
│ │ │ │ │ -      , 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__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 (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 (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
│ │ │ │ │ @@ -4136,17 +4136,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]
│ │ │ │ │ -********** sseett__nnuumm__ppiieecceess(()) nnuumm__ppiieecceess(()) **********
│ │ │ │ │ -int nnuumm__ppiieecceess () const;
│ │ │ │ │ +********** nnuumm__ppiieecceess(()) sseett__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(()) **********
│ │ │ │ │ @@ -4158,16 +4158,16 @@
│ │ │ │ │  ********** 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;
│ │ │ │ │  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.
│ │ │ │ │ @@ -4184,41 +4184,41 @@
│ │ │ │ │  returns the number of blocks in the specified piece, for v2 torrents.
│ │ │ │ │  [_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]
│ │ │ │ │ -********** nnaammee(()) sseett__nnaammee(()) **********
│ │ │ │ │ -std::string const& nnaammee () const;
│ │ │ │ │ +********** sseett__nnaammee(()) nnaammee(()) **********
│ │ │ │ │  void sseett__nnaammee (std::string const& n);
│ │ │ │ │ +std::string const& nnaammee () const;
│ │ │ │ │  set and get the name of this torrent. For multi-file torrents, this is also the
│ │ │ │ │  name of the root directory all the files are stored in.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** sswwaapp(()) **********
│ │ │ │ │  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]
│ │ │ │ │ -********** mmttiimmee(()) ffiillee__ooffffsseett(()) hhaasshh(()) ppaadd__ffiillee__aatt(()) rroooott__ppttrr(()) ffiillee__ssiizzee(()) ssyymmlliinnkk
│ │ │ │ │ -(()) rroooott(()) ffiillee__ppaatthh(()) ffiillee__nnaammee(()) **********
│ │ │ │ │ -std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ -std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ -const;
│ │ │ │ │ +********** ffiillee__ssiizzee(()) mmttiimmee(()) rroooott(()) ffiillee__ooffffsseett(()) ssyymmlliinnkk(()) ffiillee__nnaammee(()) rroooott__ppttrr(())
│ │ │ │ │ +ppaadd__ffiillee__aatt(()) ffiillee__ppaatthh(()) hhaasshh(()) **********
│ │ │ │ │ +std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ +std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │  std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │  sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ -sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ -std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │  string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │  bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ -std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ +std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ +const;
│ │ │ │ │ +sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +std::time_t mmttiimmee (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
│ │ │ │ │ @@ -4232,23 +4232,23 @@
│ │ │ │ │  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(()) **********
│ │ │ │ │ -int ffiillee__nnuumm__ppiieecceess (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;
│ │ │ │ │  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__bblloocckk__nnooddee(()) ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) **********
│ │ │ │ │ +********** 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;
│ │ │ │ │  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;
│ │ │ │ │ @@ -4267,17 +4267,17 @@
│ │ │ │ │  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__ooffffsseett(()) ffiillee__iinnddeexx__aatt__ppiieeccee(()) **********
│ │ │ │ │ -file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │ +********** ffiillee__iinnddeexx__aatt__ppiieeccee(()) ffiillee__iinnddeexx__aatt__ooffffsseett(()) **********
│ │ │ │ │  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]
│ │ │ │ │ @@ -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);
│ │ │ │ │ -   T* ggeett () const;
│ │ │ │ │     explicit operator TT () const;
│ │ │ │ │ -   client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │ +   T* ggeett () const;
│ │ │ │ │     operator vvooiidd** () const = delete;
│ │ │ │ │ -   client_data_t& ooppeerraattoorr== (void*) = delete;
│ │ │ │ │     operator void ccoonnsstt** () const = delete;
│ │ │ │ │ +   client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │ +   client_data_t& ooppeerraattoorr== (void*) = 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]
│ │ │ │ │ -********** vvooiidd**(()) ooppeerraattoorr==(()) ccoonnsstt**(()) **********
│ │ │ │ │ -client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │ +********** ccoonnsstt**(()) ooppeerraattoorr==(()) vvooiidd**(()) **********
│ │ │ │ │  operator vvooiidd** () const = delete;
│ │ │ │ │ -client_data_t& ooppeerraattoorr== (void*) = delete;
│ │ │ │ │  operator void ccoonnsstt** () const = delete;
│ │ │ │ │ +client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │ +client_data_t& ooppeerraattoorr== (void*) = 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:
│ │ │ │ │ @@ -4748,16 +4748,16 @@
│ │ │ │ │  peer_class_type_filter is a simple container for rules for adding and
│ │ │ │ │  subtracting peer-classes from peers. It is applied aafftteerr the peer class filter
│ │ │ │ │  is applied (which is based on the peer's IP address).
│ │ │ │ │  struct peer_class_type_filter
│ │ │ │ │  {
│ │ │ │ │     void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │     void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ -   void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │     void aallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +   void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │     std::uint32_t aappppllyy (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │ │     friend bool ooppeerraattoorr==== (peer_class_type_filter const& lhs
│ │ │ │ │        , peer_class_type_filter const& rhs);
│ │ │ │ │  
│ │ │ │ │     enum socket_type_t
│ │ │ │ │     {
│ │ │ │ │        tcp_socket,
│ │ │ │ │ @@ -4771,17 +4771,17 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd(()) rreemmoovvee(()) **********
│ │ │ │ │  void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │  void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │  add() and remove() adds and removes a peer class to be added to new peers based
│ │ │ │ │  on socket type.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddiissaallllooww(()) aallllooww(()) **********
│ │ │ │ │ -void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +********** aallllooww(()) ddiissaallllooww(()) **********
│ │ │ │ │  void aallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │  disallow() and allow() adds and removes a peer class to be removed from new
│ │ │ │ │  peers based on socket type.
│ │ │ │ │  The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ │ │  peer classes in the peer_class_type_filter are 32 bits.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aappppllyy(()) **********
│ │ │ │ │  std::uint32_t aappppllyy (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │ │ @@ -4819,15 +4819,15 @@
│ │ │ │ │  
│ │ │ │ │     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(()) **********
│ │ │ │ │ +********** sseett__ppeeeerr(()) ppeeeerr(()) **********
│ │ │ │ │  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"
│ │ │ │ │   _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
│ │ │ │ │ @@ -4917,119 +4917,119 @@
│ │ │ │ │  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, 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 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__ppeeeerr__iinnffoo () const;
│ │ │ │ │     void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ -   std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ -   void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ +   torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │     void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │ -   void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │ -flags = {}) const;
│ │ │ │ │ +   void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ +   std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │     void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │     void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ +   void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_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;
│ │ │ │ │ +   void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │     std::vector ffiillee__ssttaattuuss () const;
│ │ │ │ │     void cclleeaarr__eerrrroorr () const;
│ │ │ │ │ +   std::vector ttrraacckkeerrss () const;
│ │ │ │ │     void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │     void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │     void aadddd__ttrraacckkeerr (announce_entry 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 rreemmoovvee__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;
│ │ │ │ │ +   std::set hhttttpp__sseeeeddss () 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 ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │     void rreessuummee () const;
│ │ │ │ │ +   void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │     torrent_flags_t ffllaaggss () const;
│ │ │ │ │ -   void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │     void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ +   void uunnsseett__ffllaaggss (torrent_flags_t flags) 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;
│ │ │ │ │ +   bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │ +   void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ +   queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ -   queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ -   void qquueeuuee__ppoossiittiioonn__ttoopp () 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 = "");
│ │ │ │ │     std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │     std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │     std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │ -   void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │     void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ +   void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () 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 ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ │  const;
│ │ │ │ │     void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ -   download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ -   std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ +   download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ +   std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │     void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ +   std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ +   download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │     void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) 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;
│ │ │ │ │ -   void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ -   int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │     void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │     int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ +   int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ +   void sseett__ddoowwnnllooaadd__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 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;
│ │ │ │ │ +   info_hash_t iinnffoo__hhaasshheess () 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;
│ │ │ │ │ @@ -5057,18 +5057,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, 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 aadddd__ppiieeccee (piece_index_t piece, char const* 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
│ │ │ │ │ @@ -5096,30 +5096,30 @@
│ │ │ │ │  to finish in the same order as you initiated them.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** hhaavvee__ppiieeccee(()) **********
│ │ │ │ │  bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │  Returns true if this piece has been completely downloaded and written to disk,
│ │ │ │ │  and false otherwise.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppoosstt__ppeeeerr__iinnffoo(()) ggeett__ppeeeerr__iinnffoo(()) **********
│ │ │ │ │ -void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │ +********** ggeett__ppeeeerr__iinnffoo(()) ppoosstt__ppeeeerr__iinnffoo(()) **********
│ │ │ │ │  void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ +void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │  Query information about connected peers for this torrent. If the _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │  is invalid, it will throw a system_error exception.
│ │ │ │ │  post_peer_info() is asynchronous and will trigger the posting of a
│ │ │ │ │  _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
│ │ │ │ │ @@ -5127,29 +5127,29 @@
│ │ │ │ │  It will trigger posting of a _s_t_a_t_e___u_p_d_a_t_e___a_l_e_r_t with a single _t_o_r_r_e_n_t___s_t_a_t_u_s
│ │ │ │ │  object for this torrent.
│ │ │ │ │  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;
│ │ │ │ │ +********** ppoosstt__ddoowwnnllooaadd__qquueeuuee(()) ggeett__ddoowwnnllooaadd__qquueeuuee(()) **********
│ │ │ │ │  void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │ +void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ +std::vector ggeett__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]
│ │ │ │ │ -********** sseett__ppiieeccee__ddeeaaddlliinnee(()) cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) **********
│ │ │ │ │ -void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │ -flags = {}) const;
│ │ │ │ │ +********** rreesseett__ppiieeccee__ddeeaaddlliinnee(()) cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) sseett__ppiieeccee__ddeeaaddlliinnee(()) **********
│ │ │ │ │  void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │  void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ +void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │ +flags = {}) 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,
│ │ │ │ │ @@ -5157,20 +5157,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]
│ │ │ │ │ -********** ffiillee__pprrooggrreessss(()) ppoosstt__ffiillee__pprrooggrreessss(()) **********
│ │ │ │ │ +********** ppoosstt__ffiillee__pprrooggrreessss(()) ffiillee__pprrooggrreessss(()) **********
│ │ │ │ │  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;
│ │ │ │ │ +void ppoosstt__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
│ │ │ │ │ @@ -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]
│ │ │ │ │ -********** rreeppllaaccee__ttrraacckkeerrss(()) ppoosstt__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ +********** ttrraacckkeerrss(()) rreeppllaaccee__ttrraacckkeerrss(()) ppoosstt__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ +std::vector ttrraacckkeerrss () const;
│ │ │ │ │  void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │  void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │  void aadddd__ttrraacckkeerr (announce_entry 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
│ │ │ │ │  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.
│ │ │ │ │ @@ -5212,30 +5212,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]
│ │ │ │ │ -********** rreemmoovvee__uurrll__sseeeedd(()) aadddd__uurrll__sseeeedd(()) uurrll__sseeeeddss(()) **********
│ │ │ │ │ +********** 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 rreemmoovvee__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]
│ │ │ │ │ -********** rreemmoovvee__hhttttpp__sseeeedd(()) hhttttpp__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ -std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ +********** aadddd__hhttttpp__sseeeedd(()) rreemmoovvee__hhttttpp__sseeeedd(()) hhttttpp__sseeeeddss(()) **********
│ │ │ │ │  void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │  void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +std::set hhttttpp__sseeeeddss () 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&,
│ │ │ │ │ @@ -5267,16 +5267,16 @@
│ │ │ │ │  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 ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │  void rreessuummee () const;
│ │ │ │ │ +void ppaauussee (pause_flags_t flags = {}) 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
│ │ │ │ │ @@ -5285,16 +5285,16 @@
│ │ │ │ │  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(()) **********
│ │ │ │ │  torrent_flags_t ffllaaggss () const;
│ │ │ │ │ -void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │  void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ +void uunnsseett__ffllaaggss (torrent_flags_t flags) 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.
│ │ │ │ │ @@ -5405,34 +5405,34 @@
│ │ │ │ │  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__ddoowwnn(()) qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__uupp(())
│ │ │ │ │ -qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn(()) **********
│ │ │ │ │ +********** qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__uupp(()) qquueeuuee__ppoossiittiioonn__bboottttoomm(())
│ │ │ │ │ +qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) **********
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ +queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ -queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__ttoopp () 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.
│ │ │ │ │ @@ -5512,33 +5512,33 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** 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]
│ │ │ │ │ -********** ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy(()) ppiieeccee__aavvaaiillaabbiilliittyy(()) **********
│ │ │ │ │ -void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ +********** ppiieeccee__aavvaaiillaabbiilliittyy(()) ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy(()) **********
│ │ │ │ │  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]
│ │ │ │ │ -********** ppiieeccee__pprriioorriittyy(()) ggeett__ppiieeccee__pprriioorriittiieess(()) pprriioorriittiizzee__ppiieecceess(()) **********
│ │ │ │ │ +********** ggeett__ppiieeccee__pprriioorriittiieess(()) pprriioorriittiizzee__ppiieecceess(()) ppiieeccee__pprriioorriittyy(()) **********
│ │ │ │ │  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 ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ │  void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ +download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ +std::vector ggeett__ppiieeccee__pprriioorriittiieess () 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,18 +5558,18 @@
│ │ │ │ │  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]
│ │ │ │ │ -********** pprriioorriittiizzee__ffiilleess(()) ggeett__ffiillee__pprriioorriittiieess(()) ffiillee__pprriioorriittyy(()) **********
│ │ │ │ │ -download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ -std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ +********** ffiillee__pprriioorriittyy(()) pprriioorriittiizzee__ffiilleess(()) ggeett__ffiillee__pprriioorriittiieess(()) **********
│ │ │ │ │  void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ +std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ +download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │  void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) 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.
│ │ │ │ │ @@ -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__uuppllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(())
│ │ │ │ │ +********** ddoowwnnllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(())
│ │ │ │ │  **********
│ │ │ │ │ -void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ -int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │  void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │  int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ +int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ +void sseett__ddoowwnnllooaadd__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.
│ │ │ │ │ @@ -5655,26 +5655,26 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** cclleeaarr__ppeeeerrss(()) **********
│ │ │ │ │  void cclleeaarr__ppeeeerrss ();
│ │ │ │ │  This will disconnect all peers and clear the peer list for this torrent. New
│ │ │ │ │  peers will have to be acquired before resuming, from trackers, DHT or local
│ │ │ │ │  service discovery, for example.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__mmaaxx__uuppllooaaddss(()) mmaaxx__uuppllooaaddss(()) **********
│ │ │ │ │ +********** mmaaxx__uuppllooaaddss(()) sseett__mmaaxx__uuppllooaaddss(()) **********
│ │ │ │ │  void sseett__mmaaxx__uuppllooaaddss (int max_uploads) const;
│ │ │ │ │  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(()) **********
│ │ │ │ │ -void sseett__mmaaxx__ccoonnnneeccttiioonnss (int max_connections) const;
│ │ │ │ │  int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │ +void sseett__mmaaxx__ccoonnnneeccttiioonnss (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 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
│ │ │ │ │  connections_limit in _s_e_t_t_i_n_g_s___p_a_c_k.
│ │ │ │ │  max_connections() returns the current settings.
│ │ │ │ │ @@ -5725,25 +5725,25 @@
│ │ │ │ │  ********** 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(()) **********
│ │ │ │ │ -info_hash_t iinnffoo__hhaasshheess () const;
│ │ │ │ │  sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │ +info_hash_t iinnffoo__hhaasshheess () 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<<(()) **********
│ │ │ │ │ -bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │ +********** ooppeerraattoorr<<(()) ooppeerraattoorr====(()) ooppeerraattoorr!!==(()) **********
│ │ │ │ │  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.
│ │ │ │ │ @@ -6204,16 +6204,16 @@
│ │ │ │ │  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 (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ │     ~~ssttoorraaggee__hhoollddeerr ();
│ │ │ │ │ +   ssttoorraaggee__hhoollddeerr (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ │     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;
│ │ │ │ │     ssttoorraaggee__hhoollddeerr (storage_holder&& rhs) noexcept;
│ │ │ │ │ @@ -6248,16 +6248,16 @@
│ │ │ │ │  it's destructed
│ │ │ │ │  If this buffer holder is moved-from, default constructed or reset, data() will
│ │ │ │ │  return nullptr.
│ │ │ │ │  struct disk_buffer_holder
│ │ │ │ │  {
│ │ │ │ │     ddiisskk__bbuuffffeerr__hhoollddeerr (disk_buffer_holder&&) noexcept;
│ │ │ │ │     disk_buffer_holder& ooppeerraattoorr== (disk_buffer_holder&&) & noexcept;
│ │ │ │ │ -   disk_buffer_holder& ooppeerraattoorr== (disk_buffer_holder const&) = delete;
│ │ │ │ │     ddiisskk__bbuuffffeerr__hhoollddeerr (disk_buffer_holder const&) = delete;
│ │ │ │ │ +   disk_buffer_holder& ooppeerraattoorr== (disk_buffer_holder const&) = delete;
│ │ │ │ │     ddiisskk__bbuuffffeerr__hhoollddeerr (buffer_allocator_interface& alloc
│ │ │ │ │        , char* buf, int sz) noexcept;
│ │ │ │ │     ddiisskk__bbuuffffeerr__hhoollddeerr () noexcept = default;
│ │ │ │ │     ~~ddiisskk__bbuuffffeerr__hhoollddeerr ();
│ │ │ │ │     char* ddaattaa () const noexcept;
│ │ │ │ │     void rreesseett ();
│ │ │ │ │     void sswwaapp (disk_buffer_holder& h) noexcept;
│ │ │ │ │ @@ -6307,16 +6307,16 @@
│ │ │ │ │  settings.
│ │ │ │ │  struct settings_interface
│ │ │ │ │  {
│ │ │ │ │     virtual bool hhaass__vvaall (int name) const = 0;
│ │ │ │ │     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 std::string const& ggeett__ssttrr (int name) const = 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;
│ │ │ │ │  };
│ │ │ │ │  [_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
│ │ │ │ │ @@ -7226,24 +7226,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* oolldd__ppaatthh () const;
│ │ │ │ │     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]
│ │ │ │ │ -********** oolldd__ppaatthh(()) ssttoorraaggee__ppaatthh(()) **********
│ │ │ │ │ -char const* oolldd__ppaatthh () const;
│ │ │ │ │ +********** ssttoorraaggee__ppaatthh(()) oolldd__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
│ │ │ │ │  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
│ │ │ │ │ @@ -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;
│ │ │ │ │ -   std::vector> nnooddeess () const;
│ │ │ │ │     int nnuumm__nnooddeess () const;
│ │ │ │ │ +   std::vector> 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(()) **********
│ │ │ │ │ -std::vector> nnooddeess () const;
│ │ │ │ │  int nnuumm__nnooddeess () const;
│ │ │ │ │ +std::vector> 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"
│ │ │ │ │ @@ -8517,30 +8517,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]
│ │ │ │ │  ********** nnuumm__ssaammpplleess(()) 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]
│ │ │ │ │ @@ -8585,17 +8585,17 @@
│ │ │ │ │  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 _a_l_e_r_t is posted to indicate to the client that some alerts were dropped.
│ │ │ │ │  Dropped meaning that the _a_l_e_r_t failed to be delivered to the client. The most
│ │ │ │ │  common cause of such failure is that the internal _a_l_e_r_t queue grew too big
│ │ │ │ │  (controlled by alert_queue_size).
│ │ │ │ │  struct alerts_dropped_alert final : alert
│ │ │ │ │  {
│ │ │ │ │ +   std::string mmeessssaaggee () const override;
│ │ │ │ │     ssttaattiicc__aasssseerrtt (num_alert_types <= abi_alert_count, "need to increase bitset.
│ │ │ │ │  This is an ABI break");
│ │ │ │ │ -   std::string mmeessssaaggee () const override;
│ │ │ │ │  
│ │ │ │ │     static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy  = alert_category::error;
│ │ │ │ │     std::bitset dropped_alerts;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │    dropped_alerts
│ │ │ │ │        a bitmask indicating which alerts were dropped. Each bit represents the
│ │ │ │ │ @@ -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,23 +8930,23 @@
│ │ │ │ │        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&) ;
│ │ │ │ │ +   counters& ooppeerraattoorr== (counters const&) & ;
│ │ │ │ │     std::int64_t ooppeerraattoorr[[]] (int i) const ;
│ │ │ │ │     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) ;
│ │ │ │ │ +   void bblleenndd__ssttaattss__ccoouunntteerr (int c, std::int64_t value, int ratio) ;
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr[[]](()) iinncc__ssttaattss__ccoouunntteerr(()) **********
│ │ │ │ │ +********** 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
│ │ │ │ │ @@ -8994,20 +8994,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&);
│ │ │ │ │ +   iipp__ffiilltteerr ();
│ │ │ │ │ +   ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │     ~~iipp__ffiilltteerr ();
│ │ │ │ │     ip_filter& ooppeerraattoorr== (ip_filter const&);
│ │ │ │ │     iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │ -   ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │ -   iipp__ffiilltteerr ();
│ │ │ │ │ -   iipp__ffiilltteerr (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;
│ │ │ │ │  
│ │ │ │ │     enum access_flags
│ │ │ │ │ @@ -9056,20 +9056,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&&);
│ │ │ │ │     ppoorrtt__ffiilltteerr ();
│ │ │ │ │ -   ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │     port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │ -   ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │ +   port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ +   ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │     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,
│ │ │ │ │ @@ -9112,45 +9112,45 @@
│ │ │ │ │  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 (integer_type);
│ │ │ │ │ -   eennttrryy (span);
│ │ │ │ │     eennttrryy (list_type);
│ │ │ │ │     eennttrryy (preformatted_type);
│ │ │ │ │ +   eennttrryy (integer_type);
│ │ │ │ │ +   eennttrryy (span);
│ │ │ │ │     eennttrryy (U v);
│ │ │ │ │     eennttrryy (data_type t);
│ │ │ │ │     eennttrryy (bdecode_node const& n);
│ │ │ │ │ -   entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │ -   entry& ooppeerraattoorr== (entry const&) &;
│ │ │ │ │ -   entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │ +   entry& ooppeerraattoorr== (dictionary_type) &;
│ │ │ │ │ +   entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │     entry& ooppeerraattoorr== (span) &;
│ │ │ │ │ +   entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │     entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ -   entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │ -   entry& ooppeerraattoorr== (dictionary_type) &;
│ │ │ │ │     entry& ooppeerraattoorr== (preformatted_type) &;
│ │ │ │ │ +   entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │ +   entry& ooppeerraattoorr== (entry const&) &;
│ │ │ │ │     entry& ooppeerraattoorr== (U v) &;
│ │ │ │ │ -   dictionary_type const& ddiicctt () const;
│ │ │ │ │ -   preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │ -   dictionary_type& ddiicctt ();
│ │ │ │ │ +   list_type const& lliisstt () const;
│ │ │ │ │     list_type& lliisstt ();
│ │ │ │ │     string_type& ssttrriinngg ();
│ │ │ │ │ -   string_type const& ssttrriinngg () const;
│ │ │ │ │ -   integer_type& iinntteeggeerr ();
│ │ │ │ │     integer_type const& iinntteeggeerr () const;
│ │ │ │ │ +   integer_type& iinntteeggeerr ();
│ │ │ │ │ +   dictionary_type& ddiicctt ();
│ │ │ │ │ +   string_type const& ssttrriinngg () const;
│ │ │ │ │ +   preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │     preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │ -   list_type const& lliisstt () const;
│ │ │ │ │ +   dictionary_type const& ddiicctt () const;
│ │ │ │ │     void sswwaapp (entry& e);
│ │ │ │ │ -   entry const& ooppeerraattoorr[[]] (string_view key) const;
│ │ │ │ │     entry& ooppeerraattoorr[[]] (string_view key);
│ │ │ │ │ -   entry* ffiinndd__kkeeyy (string_view key);
│ │ │ │ │ +   entry const& ooppeerraattoorr[[]] (string_view key) const;
│ │ │ │ │     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,
│ │ │ │ │ @@ -9162,51 +9162,51 @@
│ │ │ │ │  [_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 (integer_type);
│ │ │ │ │ -eennttrryy (span);
│ │ │ │ │  eennttrryy (list_type);
│ │ │ │ │  eennttrryy (preformatted_type);
│ │ │ │ │ +eennttrryy (integer_type);
│ │ │ │ │ +eennttrryy (span);
│ │ │ │ │  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== (entry&&) & noexcept;
│ │ │ │ │ -entry& ooppeerraattoorr== (entry const&) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (dictionary_type) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │  entry& ooppeerraattoorr== (span) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │  entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (dictionary_type) &;
│ │ │ │ │  entry& ooppeerraattoorr== (preformatted_type) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │ +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]
│ │ │ │ │ -********** lliisstt(()) ssttrriinngg(()) pprreeffoorrmmaatttteedd(()) iinntteeggeerr(()) ddiicctt(()) **********
│ │ │ │ │ -dictionary_type const& ddiicctt () const;
│ │ │ │ │ -preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │ -dictionary_type& ddiicctt ();
│ │ │ │ │ +********** ddiicctt(()) lliisstt(()) iinntteeggeerr(()) pprreeffoorrmmaatttteedd(()) ssttrriinngg(()) **********
│ │ │ │ │ +list_type const& lliisstt () const;
│ │ │ │ │  list_type& lliisstt ();
│ │ │ │ │  string_type& ssttrriinngg ();
│ │ │ │ │ -string_type const& ssttrriinngg () const;
│ │ │ │ │ -integer_type& iinntteeggeerr ();
│ │ │ │ │  integer_type const& iinntteeggeerr () const;
│ │ │ │ │ +integer_type& iinntteeggeerr ();
│ │ │ │ │ +dictionary_type& ddiicctt ();
│ │ │ │ │ +string_type const& ssttrriinngg () const;
│ │ │ │ │ +preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │  preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │ -list_type const& lliisstt () const;
│ │ │ │ │ +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.
│ │ │ │ │ @@ -9237,27 +9237,27 @@
│ │ │ │ │  _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.
│ │ │ │ │  [_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(()) **********
│ │ │ │ │ @@ -9336,16 +9336,16 @@
│ │ │ │ │  _e_n_t_r_y that's returned can then be bencoded into a .torrent file using _b_e_n_c_o_d_e
│ │ │ │ │  _(_).
│ │ │ │ │  struct create_torrent
│ │ │ │ │  {
│ │ │ │ │     explicit ccrreeaattee__ttoorrrreenntt (torrent_info const& ti);
│ │ │ │ │     explicit ccrreeaattee__ttoorrrreenntt (file_storage& fs, int piece_size = 0
│ │ │ │ │        , create_flags_t flags = {});
│ │ │ │ │ -   std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │     entry ggeenneerraattee () const;
│ │ │ │ │ +   std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │     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);
│ │ │ │ │ @@ -9399,16 +9399,16 @@
│ │ │ │ │  (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__bbuuff(()) ggeenneerraattee(()) **********
│ │ │ │ │ -std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │  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.
│ │ │ │ │  Whether the resulting torrent object is v1, v2 or hybrid depends on whether any
│ │ │ │ │  of the v1_only or v2_only flags were set on the constructor. If neither were
│ │ │ │ │ @@ -9465,15 +9465,15 @@
│ │ │ │ │  the merkle tree formed by the piece's 16 kiB blocks. Note that piece sizes must
│ │ │ │ │  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(()) **********
│ │ │ │ │ +********** aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │  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.
│ │ │ │ │ @@ -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(()) **********
│ │ │ │ │  bool pprriivv () const;
│ │ │ │ │  void sseett__pprriivv (bool p);
│ │ │ │ │  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(()) **********
│ │ │ │ │ @@ -9537,15 +9537,15 @@
│ │ │ │ │  ********** ppiieeccee__lleennggtthh(()) ppiieeccee__ssiizzee(()) **********
│ │ │ │ │  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__ccoolllleeccttiioonn(()) aadddd__ssiimmiillaarr__ttoorrrreenntt(()) **********
│ │ │ │ │ +********** aadddd__ssiimmiillaarr__ttoorrrreenntt(()) aadddd__ccoolllleeccttiioonn(()) **********
│ │ │ │ │  void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │  void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih);
│ │ │ │ │  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.
│ │ │ │ │ @@ -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"
│ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ -   , std::function const& f);
│ │ │ │ │  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);
│ │ │ │ │  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);
│ │ │ │ │  void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ -   , settings_interface const& settings
│ │ │ │ │ +   , 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);
│ │ │ │ │  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,25 +9648,25 @@
│ │ │ │ │  [_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
│ │ │ │ │  {
│ │ │ │ │ +   explicit bbiittffiieelldd (int bits);
│ │ │ │ │     bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │     bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ +   bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │     bbiittffiieelldd (int bits, bool val);
│ │ │ │ │     bbiittffiieelldd () noexcept = default;
│ │ │ │ │ -   explicit bbiittffiieelldd (int bits);
│ │ │ │ │ -   bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │     void aassssiiggnn (char const* b, int const bits);
│ │ │ │ │ -   bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │     bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │ -   void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ +   bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │     void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ +   void sseett__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;
│ │ │ │ │ @@ -9675,40 +9675,40 @@
│ │ │ │ │     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(()) **********
│ │ │ │ │ +explicit bbiittffiieelldd (int bits);
│ │ │ │ │  bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │  bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ +bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │  bbiittffiieelldd (int bits, bool val);
│ │ │ │ │  bbiittffiieelldd () noexcept = default;
│ │ │ │ │ -explicit bbiittffiieelldd (int bits);
│ │ │ │ │ -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]
│ │ │ │ │  ********** 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]
│ │ │ │ │ -********** ggeett__bbiitt(()) ooppeerraattoorr[[]](()) **********
│ │ │ │ │ -bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │ +********** 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 sseett__bbiitt (int index) noexcept;
│ │ │ │ │ +********** sseett__bbiitt(()) cclleeaarr__bbiitt(()) **********
│ │ │ │ │  void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ +void sseett__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(()) **********
│ │ │ │ │ @@ -9767,35 +9767,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 (char const* data, int len);
│ │ │ │ │ -   explicit hhaasshheerr (span data);
│ │ │ │ │ -   hhaasshheerr (hasher const&);
│ │ │ │ │     hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ -   hasher& uuppddaattee (span data);
│ │ │ │ │ +   hhaasshheerr (hasher const&);
│ │ │ │ │ +   explicit hhaasshheerr (span data);
│ │ │ │ │ +   hhaasshheerr (char const* data, int len);
│ │ │ │ │     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 (char const* data, int len);
│ │ │ │ │ -explicit hhaasshheerr (span data);
│ │ │ │ │ -hhaasshheerr (hasher const&);
│ │ │ │ │  hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ +hhaasshheerr (hasher const&);
│ │ │ │ │ +explicit hhaasshheerr (span data);
│ │ │ │ │ +hhaasshheerr (char const* data, int len);
│ │ │ │ │  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]
│ │ │ │ │ @@ -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&) &;
│ │ │ │ │ +   hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │     explicit hhaasshheerr225566 (span data);
│ │ │ │ │     hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ -   hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ -   hasher256& uuppddaattee (span data);
│ │ │ │ │ +   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(()) **********
│ │ │ │ │ +hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │  explicit hhaasshheerr225566 (span data);
│ │ │ │ │  hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ -hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ +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]
│ │ │ │ │ @@ -10392,18 +10392,18 @@
│ │ │ │ │  ************ 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 ();
│ │ │ │ │ -   aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │     announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ -   explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │     aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ +   aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ +   explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │  
│ │ │ │ │     enum tracker_source
│ │ │ │ │     {
│ │ │ │ │        source_torrent,
│ │ │ │ │        source_client,
│ │ │ │ │        source_magnet_link,
│ │ │ │ │        source_tex,
│ │ │ │ │ @@ -10414,20 +10414,20 @@
│ │ │ │ │     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==(()) **********
│ │ │ │ │ +********** aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) ~~aannnnoouunnccee__eennttrryy(()) **********
│ │ │ │ │  ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ -aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │  announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ -explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │  aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ +aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ +explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │  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__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__iinntt (int name, int val) override;
│ │ │ │ │ +   void sseett__iinntt (int name, flags::bitfield_flag const val);
│ │ │ │ │ +   void sseett__ssttrr (int name, std::string val) override;
│ │ │ │ │     bool hhaass__vvaall (int name) const override;
│ │ │ │ │     void cclleeaarr ();
│ │ │ │ │     void cclleeaarr (int name);
│ │ │ │ │ -   bool ggeett__bbooooll (int name) const override;
│ │ │ │ │ -   int ggeett__iinntt (int name) const override;
│ │ │ │ │     std::string const& ggeett__ssttrr (int name) const override;
│ │ │ │ │ +   int ggeett__iinntt (int name) const override;
│ │ │ │ │ +   bool ggeett__bbooooll (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__ssttrr (int name, std::string val) override;
│ │ │ │ │ +********** sseett__ssttrr(()) sseett__iinntt(()) sseett__bbooooll(()) **********
│ │ │ │ │  void sseett__bbooooll (int name, bool val) override;
│ │ │ │ │ -void sseett__iinntt (int name, flags::bitfield_flag const val);
│ │ │ │ │  void sseett__iinntt (int name, int val) override;
│ │ │ │ │ +void sseett__iinntt (int name, flags::bitfield_flag const val);
│ │ │ │ │ +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
│ │ │ │ │ @@ -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(()) **********
│ │ │ │ │ -bool ggeett__bbooooll (int name) const override;
│ │ │ │ │ -int ggeett__iinntt (int name) const override;
│ │ │ │ │ +********** ggeett__ssttrr(()) ggeett__bbooooll(()) ggeett__iinntt(()) **********
│ │ │ │ │  std::string const& ggeett__ssttrr (int name) const override;
│ │ │ │ │ +int ggeett__iinntt (int name) const override;
│ │ │ │ │ +bool ggeett__bbooooll (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"
│ │ │ │ │ @@ -12190,46 +12190,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;
│ │ │ │ │ -   bbddeeccooddee__nnooddee (bdecode_node&&) noexcept;
│ │ │ │ │     bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default;
│ │ │ │ │ +   bbddeeccooddee__nnooddee (bdecode_node&&) noexcept;
│ │ │ │ │     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::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;
│ │ │ │ │ +   bdecode_node lliisstt__aatt (int i) const;
│ │ │ │ │     int lliisstt__ssiizzee () const;
│ │ │ │ │ +   std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i
│ │ │ │ │ +      , std::int64_t default_val = 0) const;
│ │ │ │ │ +   bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │ +   bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const;
│ │ │ │ │ +   bdecode_node ddiicctt__ffiinndd (string_view key) 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__ddiicctt (string_view key) const;
│ │ │ │ │ +   int ddiicctt__ssiizzee () const;
│ │ │ │ │     std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key
│ │ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ │ -   std::pair ddiicctt__aatt__nnooddee (int i) const;
│ │ │ │ │ -   bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │ -   bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const;
│ │ │ │ │ -   bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const;
│ │ │ │ │     std::pair ddiicctt__aatt (int i) const;
│ │ │ │ │ -   bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const;
│ │ │ │ │ -   int ddiicctt__ssiizzee () const;
│ │ │ │ │ -   bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │ +   std::pair ddiicctt__aatt__nnooddee (int i) const;
│ │ │ │ │     std::int64_t iinntt__vvaalluuee () const;
│ │ │ │ │ -   int ssttrriinngg__lleennggtthh () const;
│ │ │ │ │     char const* ssttrriinngg__ppttrr () const;
│ │ │ │ │ -   string_view ssttrriinngg__vvaalluuee () const;
│ │ │ │ │     std::ptrdiff_t ssttrriinngg__ooffffsseett () const;
│ │ │ │ │ +   int ssttrriinngg__lleennggtthh () 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;
│ │ │ │ │  
│ │ │ │ │     enum type_t
│ │ │ │ │ @@ -12242,17 +12242,17 @@
│ │ │ │ │     };
│ │ │ │ │  };
│ │ │ │ │  [_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&&) noexcept;
│ │ │ │ │ +********** ooppeerraattoorr==(()) bbddeeccooddee__nnooddee(()) **********
│ │ │ │ │  bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default;
│ │ │ │ │ +bbddeeccooddee__nnooddee (bdecode_node&&) noexcept;
│ │ │ │ │  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;
│ │ │ │ │ @@ -12272,41 +12272,41 @@
│ │ │ │ │  span ddaattaa__sseeccttiioonn () 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__ssttrriinngg__vvaalluuee__aatt(()) lliisstt__ssiizzee(()) lliisstt__aatt(()) lliisstt__iinntt__vvaalluuee__aatt(()) **********
│ │ │ │ │ -std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i
│ │ │ │ │ -      , std::int64_t default_val = 0) const;
│ │ │ │ │ -bdecode_node lliisstt__aatt (int i) const;
│ │ │ │ │ +********** lliisstt__aatt(()) lliisstt__ssttrriinngg__vvaalluuee__aatt(()) lliisstt__ssiizzee(()) lliisstt__iinntt__vvaalluuee__aatt(()) **********
│ │ │ │ │  string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i
│ │ │ │ │        , string_view default_val = string_view()) const;
│ │ │ │ │ +bdecode_node lliisstt__aatt (int i) const;
│ │ │ │ │  int lliisstt__ssiizzee () const;
│ │ │ │ │ +std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i
│ │ │ │ │ +      , std::int64_t default_val = 0) 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__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ffiinndd__ssttrriinngg(()) ddiicctt__aatt(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee
│ │ │ │ │ -(()) ddiicctt__ffiinndd__lliisstt(()) ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__ffiinndd(()) ddiicctt__aatt__nnooddee(()) ddiicctt__ffiinndd__iinntt(())
│ │ │ │ │ -ddiicctt__ssiizzee(()) **********
│ │ │ │ │ +********** ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ffiinndd(()) ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__ffiinndd__ssttrriinngg(())
│ │ │ │ │ +ddiicctt__ssiizzee(()) ddiicctt__ffiinndd__lliisstt(()) ddiicctt__aatt(()) ddiicctt__ffiinndd__iinntt(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(())
│ │ │ │ │ +ddiicctt__aatt__nnooddee(()) **********
│ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const;
│ │ │ │ │ +bdecode_node ddiicctt__ffiinndd (string_view key) 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__ddiicctt (string_view key) const;
│ │ │ │ │ +int ddiicctt__ssiizzee () const;
│ │ │ │ │  std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key
│ │ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ │ -std::pair ddiicctt__aatt__nnooddee (int i) const;
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const;
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const;
│ │ │ │ │  std::pair ddiicctt__aatt (int i) const;
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const;
│ │ │ │ │ -int ddiicctt__ssiizzee () const;
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │ +std::pair ddiicctt__aatt__nnooddee (int i) 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
│ │ │ │ │ @@ -12318,19 +12318,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__ppttrr(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__vvaalluuee(()) ssttrriinngg__ooffffsseett(()) **********
│ │ │ │ │ -int ssttrriinngg__lleennggtthh () const;
│ │ │ │ │ +********** ssttrriinngg__ooffffsseett(()) ssttrriinngg__vvaalluuee(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__ppttrr(()) **********
│ │ │ │ │  char const* ssttrriinngg__ppttrr () const;
│ │ │ │ │ -string_view ssttrriinngg__vvaalluuee () const;
│ │ │ │ │  std::ptrdiff_t ssttrriinngg__ooffffsseett () const;
│ │ │ │ │ +int ssttrriinngg__lleennggtthh () 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(()) **********
│ │ │ │ │  void 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 (bdecode_node const& rd
│ │ │ │ │ -   , int piece_limit = 0x200000);
│ │ │ │ │ -add_torrent_params rreeaadd__rreessuummee__ddaattaa (span buffer
│ │ │ │ │ -   , load_torrent_limits const& cfg = {});
│ │ │ │ │ -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 = {});
│ │ │ │ │ +add_torrent_params rreeaadd__rreessuummee__ddaattaa (bdecode_node const& rd
│ │ │ │ │ +   , int piece_limit = 0x200000);
│ │ │ │ │ +add_torrent_params rreeaadd__rreessuummee__ddaattaa (span buffer
│ │ │ │ │ +   , 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__bbuuff(()) wwrriittee__rreessuummee__ddaattaa(()) ************
│ │ │ │ │ +************ wwrriittee__rreessuummee__ddaattaa(()) wwrriittee__rreessuummee__ddaattaa__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__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(()) 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
│ │ │ │ │ @@ -12723,18 +12723,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"
│ │ │ │ │ -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);
│ │ │ │ │ +secret_key eedd2255551199__aadddd__ssccaallaarr (secret_key const& sk
│ │ │ │ │ +   , 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