--- /srv/reproducible-results/rbuild-debian/r-b-build.fBHPqLCd/b1/libtorrent-rasterbar_2.0.10-1.1_arm64.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.fBHPqLCd/b2/libtorrent-rasterbar_2.0.10-1.1_arm64.changes ├── Files │ @@ -1,7 +1,7 @@ │ │ b4747750d2471437984ca3b80a8e7fb0 365480 libdevel optional libtorrent-rasterbar-dev_2.0.10-1.1_arm64.deb │ - 1a73bb1f6982e258c178ce3a5c4ff829 1669176 doc optional libtorrent-rasterbar-doc_2.0.10-1.1_all.deb │ + 02c89996abd0cb83fee4b98cadabfa54 1668816 doc optional libtorrent-rasterbar-doc_2.0.10-1.1_all.deb │ 2162a02b730ebfe0ad5130042364ad0e 49852564 debug optional libtorrent-rasterbar2.0t64-dbgsym_2.0.10-1.1_arm64.deb │ 10d0ebd069ea74113fe729acbba723d2 1474236 libs optional libtorrent-rasterbar2.0t64_2.0.10-1.1_arm64.deb │ 8278b9b2a626987010d79e4e099eaaf8 13040692 debug optional python3-libtorrent-dbgsym_2.0.10-1.1_arm64.deb │ 72e9e523da08b3d34b4fe3de2d7740b1 670456 python optional python3-libtorrent_2.0.10-1.1_arm64.deb ├── libtorrent-rasterbar-doc_2.0.10-1.1_all.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2024-02-28 20:35:15.000000 debian-binary │ │ --rw-r--r-- 0 0 0 3640 2024-02-28 20:35:15.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 1665344 2024-02-28 20:35:15.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 3636 2024-02-28 20:35:15.000000 control.tar.xz │ │ +-rw-r--r-- 0 0 0 1664988 2024-02-28 20:35:15.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Add_Torrent.html │ │ │ │ @@ -30,15 +30,15 @@ │ │ │ │ │ │ │ │

home

│ │ │ │
│ │ │ │

Table of contents

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

client_data_t

│ │ │ │ @@ -51,37 +51,37 @@ │ │ │ │ { │ │ │ │ client_data_t () = default; │ │ │ │ explicit client_data_t (T* v); │ │ │ │ client_data_t& operator= (T* v); │ │ │ │ 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()

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

construct a nullptr client data

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

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

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

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

│ │ │ │ 
│ │ │ │  operator void const* () const = delete;
│ │ │ │ -operator void* () const = delete;
│ │ │ │ -client_data_t& operator= (void*) = 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 {} │ │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ > │ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_] │ │ │ │ │ VVeerrssiioonn:: 2.0.10 │ │ │ │ │ _h_o_m_e │ │ │ │ │ Table of contents │ │ │ │ │ * _c_l_i_e_n_t___d_a_t_a___t │ │ │ │ │ o _c_l_i_e_n_t___d_a_t_a___t_(_) │ │ │ │ │ - o _o_p_e_r_a_t_o_r_=_(_)_ _c_o_n_s_t_*_(_)_ _v_o_i_d_*_(_) │ │ │ │ │ + o _v_o_i_d_*_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _c_o_n_s_t_*_(_) │ │ │ │ │ * _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ cclliieenntt__ddaattaa__tt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_c_l_i_e_n_t___d_a_t_a_._h_p_p" │ │ │ │ │ A thin wrapper around a void pointer used as "user data". i.e. an opaque cookie │ │ │ │ │ passed in to libtorrent and returned on demand. It adds type-safety by │ │ │ │ │ requiring the same type be requested out of it as was assigned to it. │ │ │ │ │ @@ -17,31 +17,31 @@ │ │ │ │ │ { │ │ │ │ │ cclliieenntt__ddaattaa__tt () = default; │ │ │ │ │ explicit cclliieenntt__ddaattaa__tt (T* v); │ │ │ │ │ client_data_t& ooppeerraattoorr== (T* v); │ │ │ │ │ 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] │ │ │ │ │ -********** ooppeerraattoorr==(()) ccoonnsstt**(()) vvooiidd**(()) ********** │ │ │ │ │ +********** vvooiidd**(()) ooppeerraattoorr==(()) ccoonnsstt**(()) ********** │ │ │ │ │ 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 │ │ │ │ @@ -50,15 +50,15 @@ │ │ │ │
  • tracker_url()
    • │ │ │ │ │ │ │ │ │ │ │ │
  • torrent_removed_alert
    • │ │ │ │
  • read_piece_alert
    • │ │ │ │
  • file_completed_alert
    • │ │ │ │
  • file_renamed_alert │ │ │ │
    • │ │ │ │
  • file_rename_failed_alert
    • │ │ │ │
  • performance_alert │ │ │ │
    • │ │ │ │ @@ -551,17 +551,17 @@ │ │ │ │ char const* new_name () const; │ │ │ │ char const* old_name () const; │ │ │ │ │ │ │ │ static constexpr alert_category_t static_category = alert_category::storage; │ │ │ │ file_index_t const index; │ │ │ │ }; │ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -

    old_name() new_name()

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

    new_name() old_name()

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

    returns the new and previous file name, respectively.

    │ │ │ │ [report issue]
    │ │ │ │
    index
    │ │ │ │ @@ -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 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

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -15,15 +15,15 @@ │ │ │ │ │ * _p_e_e_r___a_l_e_r_t │ │ │ │ │ * _t_r_a_c_k_e_r___a_l_e_r_t │ │ │ │ │ o _t_r_a_c_k_e_r___u_r_l_(_) │ │ │ │ │ * _t_o_r_r_e_n_t___r_e_m_o_v_e_d___a_l_e_r_t │ │ │ │ │ * _r_e_a_d___p_i_e_c_e___a_l_e_r_t │ │ │ │ │ * _f_i_l_e___c_o_m_p_l_e_t_e_d___a_l_e_r_t │ │ │ │ │ * _f_i_l_e___r_e_n_a_m_e_d___a_l_e_r_t │ │ │ │ │ - o _o_l_d___n_a_m_e_(_)_ _n_e_w___n_a_m_e_(_) │ │ │ │ │ + o _n_e_w___n_a_m_e_(_)_ _o_l_d___n_a_m_e_(_) │ │ │ │ │ * _f_i_l_e___r_e_n_a_m_e___f_a_i_l_e_d___a_l_e_r_t │ │ │ │ │ * _p_e_r_f_o_r_m_a_n_c_e___a_l_e_r_t │ │ │ │ │ o _e_n_u_m_ _p_e_r_f_o_r_m_a_n_c_e___w_a_r_n_i_n_g___t │ │ │ │ │ * _s_t_a_t_e___c_h_a_n_g_e_d___a_l_e_r_t │ │ │ │ │ * _t_r_a_c_k_e_r___e_r_r_o_r___a_l_e_r_t │ │ │ │ │ o _f_a_i_l_u_r_e___r_e_a_s_o_n_(_) │ │ │ │ │ * _t_r_a_c_k_e_r___w_a_r_n_i_n_g___a_l_e_r_t │ │ │ │ │ @@ -408,15 +408,15 @@ │ │ │ │ │ char const* oolldd__nnaammee () const; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category:: │ │ │ │ │ storage; │ │ │ │ │ file_index_t const index; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** oolldd__nnaammee(()) nneeww__nnaammee(()) ********** │ │ │ │ │ +********** nneeww__nnaammee(()) oolldd__nnaammee(()) ********** │ │ │ │ │ char const* nneeww__nnaammee () const; │ │ │ │ │ char const* oolldd__nnaammee () const; │ │ │ │ │ returns the new and previous file name, respectively. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ index │ │ │ │ │ refers to the index of the file that was renamed, │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ @@ -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 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" │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Bdecoding.html │ │ │ │ @@ -35,18 +35,18 @@ │ │ │ │
  • bdecode_node │ │ │ │ @@ -62,45 +62,45 @@ │ │ │ │ to be able to copy it as a reference for instance). For that, use the │ │ │ │ non_owning() member function.

    │ │ │ │

    There are 5 different types of nodes, see type_t.

    │ │ │ │ 
    │ │ │ │  struct bdecode_node
│ │ │ │  {
│ │ │ │     bdecode_node () = default;
│ │ │ │ -   bdecode_node (bdecode_node&&) noexcept;
│ │ │ │     bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │     bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │     bdecode_node (bdecode_node const&);
│ │ │ │ +   bdecode_node (bdecode_node&&) noexcept;
│ │ │ │     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;
│ │ │ │ -   bdecode_node list_at (int i) const;
│ │ │ │ -   int list_size () const;
│ │ │ │ +   std::ptrdiff_t data_offset () const noexcept;
│ │ │ │     string_view list_string_value_at (int i
│ │ │ │        , string_view default_val = string_view()) const;
│ │ │ │ +   bdecode_node list_at (int i) const;
│ │ │ │     std::int64_t list_int_value_at (int i
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ +   int list_size () const;
│ │ │ │ +   int dict_size () const;
│ │ │ │ +   bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ +   bdecode_node dict_find (string_view key) const;
│ │ │ │     bdecode_node dict_find_int (string_view key) const;
│ │ │ │ -   bdecode_node dict_find_list (string_view key) 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_list (string_view key) const;
│ │ │ │     std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │     string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) 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_string (string_view key) const;
│ │ │ │ -   int dict_size () const;
│ │ │ │ -   bdecode_node dict_find (string_view key) const;
│ │ │ │     std::int64_t int_value () const;
│ │ │ │ -   char const* string_ptr () const;
│ │ │ │ -   int string_length () const;
│ │ │ │     string_view string_value () const;
│ │ │ │ +   int string_length () const;
│ │ │ │ +   char const* string_ptr () const;
│ │ │ │     std::ptrdiff_t string_offset () const;
│ │ │ │     void clear ();
│ │ │ │     void swap (bdecode_node& n);
│ │ │ │     void reserve (int tokens);
│ │ │ │     void switch_underlying_buffer (char const* buf) noexcept;
│ │ │ │     bool has_soft_error (span<char> error) const;
│ │ │ │  
│ │ │ │ @@ -121,18 +121,18 @@
│ │ │ │
    │ │ │ │

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

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

    operator=() bdecode_node()

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

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

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

    type()

    │ │ │ │ 
    │ │ │ │ @@ -155,66 +155,66 @@
│ │ │ │  
    return a non-owning reference to this node. This is useful to refer to
│ │ │ │  the root node without copying it in assignments.
    
│ │ │ │  
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    data_section() data_offset()

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

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

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

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

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

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

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

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

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

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

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

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

    │ │ │ │ 
    │ │ │ │ +int dict_size () const;
│ │ │ │ +bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ +bdecode_node dict_find (string_view key) const;
│ │ │ │  bdecode_node dict_find_int (string_view key) const;
│ │ │ │ -bdecode_node dict_find_list (string_view key) 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_list (string_view key) const;
│ │ │ │  std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │  string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) 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_string (string_view key) const;
│ │ │ │ -int dict_size () const;
│ │ │ │ -bdecode_node dict_find (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,24 +229,24 @@ │ │ │ │
    │ │ │ │

    int_value()

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

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

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

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

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

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

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

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

    │ │ │ │ @@ -346,18 +346,18 @@ │ │ │ │ that's returned.

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

    bdecode()

    │ │ │ │

    Declared in "libtorrent/bdecode.hpp"

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

    This function decodes/parses bdecoded data (for example a .torrent file). │ │ │ │ The data structure is returned in the ret argument. the buffer to parse │ │ │ │ is specified by the start of the buffer as well as the end, i.e. one │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -6,20 +6,20 @@ │ │ │ │ │ * _b_d_e_c_o_d_e___n_o_d_e │ │ │ │ │ o _b_d_e_c_o_d_e___n_o_d_e_(_) │ │ │ │ │ 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___s_e_c_t_i_o_n_(_)_ _d_a_t_a___o_f_f_s_e_t_(_) │ │ │ │ │ - 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_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___a_t___n_o_d_e_(_) │ │ │ │ │ - _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)_ _d_i_c_t___a_t_(_)_ _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___v_a_l_u_e_(_)_ _d_i_c_t___s_i_z_e_(_)_ _d_i_c_t___f_i_n_d___i_n_t_(_) │ │ │ │ │ + o _l_i_s_t___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_) │ │ │ │ │ + o _d_i_c_t___a_t___n_o_d_e_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)_ _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___s_i_z_e_(_)_ _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___i_n_t_(_) │ │ │ │ │ + _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_) │ │ │ │ │ o _i_n_t___v_a_l_u_e_(_) │ │ │ │ │ - o _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_) │ │ │ │ │ + o _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_) │ │ │ │ │ o _c_l_e_a_r_(_) │ │ │ │ │ o _s_w_a_p_(_) │ │ │ │ │ o _r_e_s_e_r_v_e_(_) │ │ │ │ │ o _s_w_i_t_c_h___u_n_d_e_r_l_y_i_n_g___b_u_f_f_e_r_(_) │ │ │ │ │ o _h_a_s___s_o_f_t___e_r_r_o_r_(_) │ │ │ │ │ o _e_n_u_m_ _t_y_p_e___t │ │ │ │ │ * _p_r_i_n_t___e_n_t_r_y_(_) │ │ │ │ │ @@ -30,45 +30,45 @@ │ │ │ │ │ Sometimes it's important to get a non-owning reference to the root node ( to be │ │ │ │ │ able to copy it as a reference for instance). For that, use the _n_o_n___o_w_n_i_n_g_(_) │ │ │ │ │ member function. │ │ │ │ │ There are 5 different types of nodes, see _t_y_p_e___t. │ │ │ │ │ struct bdecode_node │ │ │ │ │ { │ │ │ │ │ bbddeeccooddee__nnooddee () = default; │ │ │ │ │ - bbddeeccooddee__nnooddee (bdecode_node&&) noexcept; │ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default; │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node const&); │ │ │ │ │ + bbddeeccooddee__nnooddee (bdecode_node&&) noexcept; │ │ │ │ │ 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; │ │ │ │ │ - bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ - int lliisstt__ssiizzee () const; │ │ │ │ │ + std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept; │ │ │ │ │ string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i │ │ │ │ │ , string_view default_val = string_view()) const; │ │ │ │ │ + bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ + int lliisstt__ssiizzee () const; │ │ │ │ │ + int ddiicctt__ssiizzee () const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd (string_view key) const; │ │ │ │ │ bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) 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__lliisstt (string_view key) const; │ │ │ │ │ std::pair ddiicctt__aatt__nnooddee (int i) const; │ │ │ │ │ string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key │ │ │ │ │ , string_view default_value = string_view()) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ + std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ - int ddiicctt__ssiizzee () const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd (string_view key) const; │ │ │ │ │ std::int64_t iinntt__vvaalluuee () const; │ │ │ │ │ - char const* ssttrriinngg__ppttrr () const; │ │ │ │ │ - int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ + int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ + char const* ssttrriinngg__ppttrr () const; │ │ │ │ │ std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ void cclleeaarr (); │ │ │ │ │ void sswwaapp (bdecode_node& n); │ │ │ │ │ void rreesseerrvvee (int tokens); │ │ │ │ │ void sswwiittcchh__uunnddeerrllyyiinngg__bbuuffffeerr (char const* buf) noexcept; │ │ │ │ │ bool hhaass__ssoofftt__eerrrroorr (span error) const; │ │ │ │ │ │ │ │ │ │ @@ -83,18 +83,18 @@ │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** bbddeeccooddee__nnooddee(()) ********** │ │ │ │ │ bbddeeccooddee__nnooddee () = default; │ │ │ │ │ creates a default constructed node, it will have the type none_t. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ooppeerraattoorr==(()) bbddeeccooddee__nnooddee(()) ********** │ │ │ │ │ -bbddeeccooddee__nnooddee (bdecode_node&&) noexcept; │ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default; │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node const&); │ │ │ │ │ +bbddeeccooddee__nnooddee (bdecode_node&&) noexcept; │ │ │ │ │ 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] │ │ │ │ │ @@ -104,49 +104,49 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** nnoonn__oowwnniinngg(()) ********** │ │ │ │ │ bdecode_node nnoonn__oowwnniinngg () const; │ │ │ │ │ return a non-owning reference to this node. This is useful to refer to the root │ │ │ │ │ node without copying it in assignments. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ddaattaa__sseeccttiioonn(()) ddaattaa__ooffffsseett(()) ********** │ │ │ │ │ -std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept; │ │ │ │ │ span ddaattaa__sseeccttiioonn () const noexcept; │ │ │ │ │ +std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept; │ │ │ │ │ returns the buffer and length of the section in the original bencoded buffer │ │ │ │ │ where this node is defined. For a dictionary for instance, this starts with d │ │ │ │ │ and ends with e, and has all the content of the dictionary in between. the │ │ │ │ │ data_offset() function returns the byte-offset to this node in, starting from │ │ │ │ │ the beginning of the buffer that was parsed. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** lliisstt__ssttrriinngg__vvaalluuee__aatt(()) lliisstt__ssiizzee(()) lliisstt__aatt(()) lliisstt__iinntt__vvaalluuee__aatt(()) ********** │ │ │ │ │ -bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ -int lliisstt__ssiizzee () const; │ │ │ │ │ +********** lliisstt__aatt(()) lliisstt__ssiizzee(()) lliisstt__ssttrriinngg__vvaalluuee__aatt(()) 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; │ │ │ │ │ std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ +int lliisstt__ssiizzee () const; │ │ │ │ │ functions with the list_ prefix operate on lists. These functions are only │ │ │ │ │ valid if type() == list_t. list_at() returns the item in the list at index i. i │ │ │ │ │ may not be greater than or equal to the size of the list. size() returns the │ │ │ │ │ size of the list. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ffiinndd(()) ddiicctt__ffiinndd__lliisstt(()) ddiicctt__aatt__nnooddee(()) │ │ │ │ │ -ddiicctt__ffiinndd__ssttrriinngg(()) ddiicctt__aatt(()) ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) │ │ │ │ │ -ddiicctt__ssiizzee(()) ddiicctt__ffiinndd__iinntt(()) ********** │ │ │ │ │ +********** ddiicctt__aatt__nnooddee(()) ddiicctt__ffiinndd__ssttrriinngg(()) ddiicctt__ffiinndd(()) ddiicctt__ssiizzee(()) ddiicctt__aatt(()) │ │ │ │ │ +ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ffiinndd__iinntt(()) ddiicctt__ffiinndd__lliisstt(()) │ │ │ │ │ +ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) ********** │ │ │ │ │ +int ddiicctt__ssiizzee () const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd (string_view key) const; │ │ │ │ │ bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) 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__lliisstt (string_view key) const; │ │ │ │ │ std::pair ddiicctt__aatt__nnooddee (int i) const; │ │ │ │ │ string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key │ │ │ │ │ , string_view default_value = string_view()) const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ +std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ -int ddiicctt__ssiizzee () const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd (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,18 +158,18 @@ │ │ │ │ │ string). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** iinntt__vvaalluuee(()) ********** │ │ │ │ │ std::int64_t iinntt__vvaalluuee () const; │ │ │ │ │ this function is only valid if type() == int_t. It returns the value of the │ │ │ │ │ integer. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ssttrriinngg__ooffffsseett(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__ppttrr(()) ssttrriinngg__vvaalluuee(()) ********** │ │ │ │ │ -char const* ssttrriinngg__ppttrr () const; │ │ │ │ │ -int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ +********** ssttrriinngg__vvaalluuee(()) ssttrriinngg__ppttrr(()) ssttrriinngg__ooffffsseett(()) ssttrriinngg__lleennggtthh(()) ********** │ │ │ │ │ string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ +int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ +char const* ssttrriinngg__ppttrr () const; │ │ │ │ │ std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ these functions are only valid if type() == string_t. They return the string │ │ │ │ │ values. Note that string_ptr() is nnoott 0-terminated. string_length() returns the │ │ │ │ │ number of bytes in the string. string_offset() returns the byte offset from the │ │ │ │ │ start of the parsed bencoded buffer this string can be found. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** cclleeaarr(()) ********** │ │ │ │ │ @@ -215,18 +215,18 @@ │ │ │ │ │ , 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" │ │ │ │ │ bdecode_node bbddeeccooddee (span buffer │ │ │ │ │ - , int depth_limit = 100, int token_limit = 2000000); │ │ │ │ │ -bdecode_node bbddeeccooddee (span buffer │ │ │ │ │ , error_code& ec, int* error_pos = nullptr, int depth_limit = 100 │ │ │ │ │ , int token_limit = 2000000); │ │ │ │ │ +bdecode_node bbddeeccooddee (span buffer │ │ │ │ │ + , int depth_limit = 100, int token_limit = 2000000); │ │ │ │ │ int bbddeeccooddee (char const* start, char const* end, bdecode_node& ret │ │ │ │ │ , error_code& ec, int* error_pos = nullptr, int depth_limit = 100 │ │ │ │ │ , int token_limit = 2000000); │ │ │ │ │ This function decodes/parses bdecoded data (for example a .torrent file). The │ │ │ │ │ data structure is returned in the ret argument. the buffer to parse is │ │ │ │ │ specified by the start of the buffer as well as the end, i.e. one byte past the │ │ │ │ │ end. If the buffer fails to parse, the function returns a non-zero value and │ │ │ ├── ./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 (span<char const>);
│ │ │ │ -   entry (preformatted_type);
│ │ │ │ -   entry (dictionary_type);
│ │ │ │     entry (integer_type);
│ │ │ │     entry (list_type);
│ │ │ │ +   entry (preformatted_type);
│ │ │ │ +   entry (dictionary_type);
│ │ │ │ +   entry (span<char const>);
│ │ │ │     entry (U v);
│ │ │ │     entry (data_type t);
│ │ │ │     entry (bdecode_node const& n);
│ │ │ │ -   entry& operator= (span<char const>) &;
│ │ │ │     entry& operator= (entry&&) & noexcept;
│ │ │ │     entry& operator= (dictionary_type) &;
│ │ │ │ -   entry& operator= (bdecode_node const&) &;
│ │ │ │ +   entry& operator= (span<char const>) &;
│ │ │ │     entry& operator= (list_type) &;
│ │ │ │ -   entry& operator= (integer_type) &;
│ │ │ │ -   entry& operator= (preformatted_type) &;
│ │ │ │     entry& operator= (entry const&) &;
│ │ │ │ +   entry& operator= (preformatted_type) &;
│ │ │ │ +   entry& operator= (bdecode_node const&) &;
│ │ │ │ +   entry& operator= (integer_type) &;
│ │ │ │     entry& operator= (U v) &;
│ │ │ │ -   string_type const& string () const;
│ │ │ │ -   integer_type& integer ();
│ │ │ │ -   preformatted_type& preformatted ();
│ │ │ │ -   list_type& list ();
│ │ │ │ +   dictionary_type& dict ();
│ │ │ │     dictionary_type const& dict () const;
│ │ │ │     preformatted_type const& preformatted () const;
│ │ │ │ +   string_type const& string () const;
│ │ │ │ +   preformatted_type& preformatted ();
│ │ │ │ +   integer_type const& integer () const;
│ │ │ │     string_type& string ();
│ │ │ │ +   integer_type& integer ();
│ │ │ │ +   list_type& list ();
│ │ │ │     list_type const& list () const;
│ │ │ │ -   integer_type const& integer () const;
│ │ │ │ -   dictionary_type& dict ();
│ │ │ │     void swap (entry& e);
│ │ │ │     entry const& operator[] (string_view key) const;
│ │ │ │     entry& operator[] (string_view key);
│ │ │ │ -   entry* find_key (string_view key);
│ │ │ │     entry const* find_key (string_view key) const;
│ │ │ │ +   entry* find_key (string_view key);
│ │ │ │     std::string to_string (bool single_line = false) const;
│ │ │ │  
│ │ │ │     enum data_type
│ │ │ │     {
│ │ │ │        int_t,
│ │ │ │        string_t,
│ │ │ │        list_t,
│ │ │ │ @@ -124,19 +124,19 @@
│ │ │ │  data_type type () const;
│ │ │ │
      │ │ │ │

      returns the concrete type of the entry

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

    entry()

    │ │ │ │ 
    │ │ │ │ -entry (span<char const>);
│ │ │ │ -entry (preformatted_type);
│ │ │ │ -entry (dictionary_type);
│ │ │ │  entry (integer_type);
│ │ │ │  entry (list_type);
│ │ │ │ +entry (preformatted_type);
│ │ │ │ +entry (dictionary_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()

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

    construct from bdecode_node parsed form (see bdecode())

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

    operator=()

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

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

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

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

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

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

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

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

    The const version of operator[] will only return a reference to an │ │ │ │ existing element at the given key. If the key is not found, it will │ │ │ │ throw system_error.

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

    find_key()

    │ │ │ │ 
    │ │ │ │ -entry* find_key (string_view key);
│ │ │ │  entry const* find_key (string_view key) const;
│ │ │ │ +entry* find_key (string_view key);
│ │ │ │
    │ │ │ │

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

    │ │ │ │

    They will look for an element at the given key in the dictionary, if │ │ │ │ the element cannot be found, they will return nullptr. If an element │ │ │ │ with the given key is found, the return a pointer to it.

    │ │ │ │ [report issue]
    │ │ │ │ ├── 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 _s_t_r_i_n_g_(_)_ _d_i_c_t_(_)_ _i_n_t_e_g_e_r_(_)_ _l_i_s_t_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_) │ │ │ │ │ + o _d_i_c_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_(_)_ _l_i_s_t_(_) │ │ │ │ │ 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 (span); │ │ │ │ │ - eennttrryy (preformatted_type); │ │ │ │ │ - eennttrryy (dictionary_type); │ │ │ │ │ eennttrryy (integer_type); │ │ │ │ │ eennttrryy (list_type); │ │ │ │ │ + eennttrryy (preformatted_type); │ │ │ │ │ + eennttrryy (dictionary_type); │ │ │ │ │ + eennttrryy (span); │ │ │ │ │ eennttrryy (U v); │ │ │ │ │ eennttrryy (data_type t); │ │ │ │ │ eennttrryy (bdecode_node const& n); │ │ │ │ │ - entry& ooppeerraattoorr== (span) &; │ │ │ │ │ entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ - entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ + entry& ooppeerraattoorr== (span) &; │ │ │ │ │ entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ - entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ - entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ + entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ + entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ entry& ooppeerraattoorr== (U v) &; │ │ │ │ │ - string_type const& ssttrriinngg () const; │ │ │ │ │ - integer_type& iinntteeggeerr (); │ │ │ │ │ - preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ - list_type& lliisstt (); │ │ │ │ │ + dictionary_type& ddiicctt (); │ │ │ │ │ dictionary_type const& ddiicctt () const; │ │ │ │ │ preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ + string_type const& ssttrriinngg () const; │ │ │ │ │ + preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ + integer_type const& iinntteeggeerr () const; │ │ │ │ │ string_type& ssttrriinngg (); │ │ │ │ │ + integer_type& iinntteeggeerr (); │ │ │ │ │ + list_type& lliisstt (); │ │ │ │ │ list_type const& lliisstt () const; │ │ │ │ │ - integer_type const& iinntteeggeerr () const; │ │ │ │ │ - dictionary_type& ddiicctt (); │ │ │ │ │ void sswwaapp (entry& e); │ │ │ │ │ entry const& ooppeerraattoorr[[]] (string_view key) const; │ │ │ │ │ entry& ooppeerraattoorr[[]] (string_view key); │ │ │ │ │ - entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ entry const* ffiinndd__kkeeyy (string_view key) const; │ │ │ │ │ + entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ std::string ttoo__ssttrriinngg (bool single_line = false) const; │ │ │ │ │ │ │ │ │ │ enum data_type │ │ │ │ │ { │ │ │ │ │ int_t, │ │ │ │ │ string_t, │ │ │ │ │ list_t, │ │ │ │ │ @@ -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 (span); │ │ │ │ │ -eennttrryy (preformatted_type); │ │ │ │ │ -eennttrryy (dictionary_type); │ │ │ │ │ eennttrryy (integer_type); │ │ │ │ │ eennttrryy (list_type); │ │ │ │ │ +eennttrryy (preformatted_type); │ │ │ │ │ +eennttrryy (dictionary_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== (span) &; │ │ │ │ │ entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ -entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ +entry& ooppeerraattoorr== (span) &; │ │ │ │ │ entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ -entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ -entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ +entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ +entry& ooppeerraattoorr== (integer_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] │ │ │ │ │ -********** ssttrriinngg(()) ddiicctt(()) iinntteeggeerr(()) lliisstt(()) pprreeffoorrmmaatttteedd(()) ********** │ │ │ │ │ -string_type const& ssttrriinngg () const; │ │ │ │ │ -integer_type& iinntteeggeerr (); │ │ │ │ │ -preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ -list_type& lliisstt (); │ │ │ │ │ +********** ddiicctt(()) pprreeffoorrmmaatttteedd(()) ssttrriinngg(()) iinntteeggeerr(()) lliisstt(()) ********** │ │ │ │ │ +dictionary_type& ddiicctt (); │ │ │ │ │ dictionary_type const& ddiicctt () const; │ │ │ │ │ preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ +string_type const& ssttrriinngg () const; │ │ │ │ │ +preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ +integer_type const& iinntteeggeerr () const; │ │ │ │ │ string_type& ssttrriinngg (); │ │ │ │ │ +integer_type& iinntteeggeerr (); │ │ │ │ │ +list_type& lliisstt (); │ │ │ │ │ list_type const& lliisstt () const; │ │ │ │ │ -integer_type const& iinntteeggeerr () const; │ │ │ │ │ -dictionary_type& ddiicctt (); │ │ │ │ │ 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. │ │ │ │ │ @@ -172,16 +172,16 @@ │ │ │ │ │ The non-const versions of the operator[] will return a reference to either the │ │ │ │ │ existing element at the given key or, if there is no element with the given │ │ │ │ │ key, a reference to a newly inserted element at that key. │ │ │ │ │ The const version of operator[] will only return a reference to an existing │ │ │ │ │ element at the given key. If the key is not found, it will throw system_error. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ffiinndd__kkeeyy(()) ********** │ │ │ │ │ -entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ entry const* ffiinndd__kkeeyy (string_view key) const; │ │ │ │ │ +entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ These functions requires the _e_n_t_r_y to be a dictionary, if it isn't they will │ │ │ │ │ throw system_error. │ │ │ │ │ They will look for an element at the given key in the dictionary, if the │ │ │ │ │ element cannot be found, they will return nullptr. If an element with the given │ │ │ │ │ key is found, the return a pointer to it. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ttoo__ssttrriinngg(()) ********** │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Core.html │ │ │ │ @@ -34,26 +34,26 @@ │ │ │ │
    │ │ │ │ 
    │ │ │ │  struct info_hash_t
│ │ │ │  {
│ │ │ │ -   info_hash_t () noexcept = default;
│ │ │ │ -   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_v1 () const;
│ │ │ │ +   info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │     bool has_v2 () const;
│ │ │ │ +   bool has_v1 () const;
│ │ │ │     bool has (protocol_version v) const;
│ │ │ │     sha1_hash get (protocol_version v) const;
│ │ │ │     sha1_hash get_best () const;
│ │ │ │     friend bool operator!= (info_hash_t const& lhs, info_hash_t const& rhs);
│ │ │ │     friend bool operator== (info_hash_t const& lhs, info_hash_t const& rhs) noexcept;
│ │ │ │     template <typename F> void for_each (F f) const;
│ │ │ │     bool operator< (info_hash_t const& o) const;
│ │ │ │ @@ -587,32 +587,32 @@
│ │ │ │     sha1_hash v1;
│ │ │ │     sha256_hash v2;
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    info_hash_t()

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

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

    │ │ │ │

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

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

    has() has_v2() has_v1()

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

    has_v1() has_v2() has()

    │ │ │ │ 
    │ │ │ │ -bool has_v1 () const;
│ │ │ │  bool has_v2 () const;
│ │ │ │ +bool has_v1 () const;
│ │ │ │  bool has (protocol_version v) 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 (piece_index_t p_index, int b_index);
│ │ │ │     piece_block () = default;
│ │ │ │ +   piece_block (piece_index_t p_index, int b_index);
│ │ │ │     bool operator< (piece_block const& b) const;
│ │ │ │     bool operator== (piece_block const& b) const;
│ │ │ │     bool operator!= (piece_block const& b) const;
│ │ │ │  
│ │ │ │     static const piece_block invalid;
│ │ │ │     piece_index_t piece_index {0};
│ │ │ │     int block_index  = 0;
│ │ │ │ @@ -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_parsed() load_torrent_file() load_torrent_buffer()

    │ │ │ │

    Declared in "libtorrent/load_torrent.hpp"

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

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

    │ │ │ │ @@ -728,16 +728,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_handle const& handle);
│ │ │ │ +std::string make_magnet_uri (add_torrent_params const& atp);
│ │ │ │  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:

    │ │ │ │
    │ │ │ │ @@ -758,16 +758,16 @@ │ │ │ │ an empty string is returned.

    │ │ │ │

    For more information about magnet links, see magnet links.

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

    parse_magnet_uri()

    │ │ │ │

    Declared in "libtorrent/magnet_uri.hpp"

    │ │ │ │ 
    │ │ │ │ -add_torrent_params parse_magnet_uri (string_view uri, 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.

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -3,22 +3,22 @@ │ │ │ │ │ VVeerrssiioonn:: 2.0.10 │ │ │ │ │ _h_o_m_e │ │ │ │ │ Table of contents │ │ │ │ │ * _p_e_e_r___i_n_f_o │ │ │ │ │ o _i_2_p___d_e_s_t_i_n_a_t_i_o_n_(_) │ │ │ │ │ * _i_n_f_o___h_a_s_h___t │ │ │ │ │ o _i_n_f_o___h_a_s_h___t_(_) │ │ │ │ │ - o _h_a_s_(_)_ _h_a_s___v_2_(_)_ _h_a_s___v_1_(_) │ │ │ │ │ + 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___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___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 () noexcept = default; │ │ │ │ │ - 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__vv11 () const; │ │ │ │ │ + iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ │ bool hhaass__vv22 () const; │ │ │ │ │ + bool hhaass__vv11 () const; │ │ │ │ │ bool hhaass (protocol_version v) const; │ │ │ │ │ sha1_hash ggeett (protocol_version v) const; │ │ │ │ │ sha1_hash ggeett__bbeesstt () const; │ │ │ │ │ friend bool ooppeerraattoorr!!== (info_hash_t const& lhs, info_hash_t const& rhs); │ │ │ │ │ friend bool ooppeerraattoorr==== (info_hash_t const& lhs, info_hash_t const& rhs) │ │ │ │ │ noexcept; │ │ │ │ │ template void ffoorr__eeaacchh (F f) const; │ │ │ │ │ @@ -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 () noexcept = default; │ │ │ │ │ -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 (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ │ The default constructor creates an object that has neither a v1 or v2 hash. │ │ │ │ │ For backwards compatibility, make it possible to construct directly from a v1 │ │ │ │ │ hash. This constructor allows iimmpplliicciitt conversion from a v1 hash, but the │ │ │ │ │ implicitness is deprecated. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** hhaass(()) hhaass__vv22(()) hhaass__vv11(()) ********** │ │ │ │ │ -bool hhaass__vv11 () const; │ │ │ │ │ +********** hhaass__vv11(()) hhaass__vv22(()) hhaass(()) ********** │ │ │ │ │ bool hhaass__vv22 () const; │ │ │ │ │ +bool hhaass__vv11 () const; │ │ │ │ │ bool hhaass (protocol_version v) const; │ │ │ │ │ returns true if the corresponding info hash is present in this object. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ggeett(()) ********** │ │ │ │ │ sha1_hash ggeett (protocol_version v) const; │ │ │ │ │ returns the has for the specified protocol version │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ @@ -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 (piece_index_t p_index, int b_index); │ │ │ │ │ ppiieeccee__bblloocckk () = default; │ │ │ │ │ + ppiieeccee__bblloocckk (piece_index_t p_index, int b_index); │ │ │ │ │ bool ooppeerraattoorr<< (piece_block const& b) const; │ │ │ │ │ bool ooppeerraattoorr==== (piece_block const& b) const; │ │ │ │ │ bool ooppeerraattoorr!!== (piece_block const& b) const; │ │ │ │ │ │ │ │ │ │ static const piece_block invalid; │ │ │ │ │ piece_index_t piece_index {0}; │ │ │ │ │ int bblloocckk__iinnddeexx = 0; │ │ │ │ │ @@ -506,40 +506,40 @@ │ │ │ │ │ [_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__ppaarrsseedd(()) llooaadd__ttoorrrreenntt__ffiillee(()) llooaadd__ttoorrrreenntt__bbuuffffeerr(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_l_o_a_d___t_o_r_r_e_n_t_._h_p_p" │ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd ( │ │ │ │ │ + bdecode_node const& torrent_file); │ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr ( │ │ │ │ │ + span buffer, load_torrent_limits const& cfg); │ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ffiillee ( │ │ │ │ │ + std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd ( │ │ │ │ │ bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ffiillee ( │ │ │ │ │ std::string const& filename); │ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ffiillee ( │ │ │ │ │ - std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr ( │ │ │ │ │ span buffer); │ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr ( │ │ │ │ │ - span buffer, load_torrent_limits const& cfg); │ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd ( │ │ │ │ │ - bdecode_node const& torrent_file); │ │ │ │ │ These functions load the content of a .torrent file into an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s │ │ │ │ │ object. The immutable part of a torrent file (the info-dictionary) is stored in │ │ │ │ │ the ti field in the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object (as a _t_o_r_r_e_n_t___i_n_f_o object). The │ │ │ │ │ returned object is suitable to be: │ │ │ │ │ * added to a _s_e_s_s_i_o_n via _a_d_d___t_o_r_r_e_n_t_(_) or _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) │ │ │ │ │ * saved as a .torrent_file via _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_) │ │ │ │ │ * turned into a magnet link via _m_a_k_e___m_a_g_n_e_t___u_r_i_(_) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ mmaakkee__mmaaggnneett__uurrii(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p" │ │ │ │ │ -std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp); │ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle); │ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp); │ │ │ │ │ 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. │ │ │ │ │ @@ -555,16 +555,16 @@ │ │ │ │ │ The overload that takes a _t_o_r_r_e_n_t___h_a_n_d_l_e will make blocking calls to query │ │ │ │ │ information about the torrent. If the torrent handle is invalid, an empty │ │ │ │ │ string is returned. │ │ │ │ │ For more information about magnet links, see _m_a_g_n_e_t_ _l_i_n_k_s. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ppaarrssee__mmaaggnneett__uurrii(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p" │ │ │ │ │ -add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri, 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] │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Create_Torrents.html │ │ │ │ @@ -30,22 +30,22 @@ │ │ │ │ │ │ │ │

    home

    │ │ │ │
    │ │ │ │

    Table of contents

    │ │ │ │
      │ │ │ │
    • create_torrent
        │ │ │ │
      • create_torrent()
        • │ │ │ │ -
      • generate_buf() generate()
        • │ │ │ │ +
      • generate() generate_buf()
        • │ │ │ │
      • files()
        • │ │ │ │
      • set_comment()
        • │ │ │ │
      • set_creator()
        • │ │ │ │
      • set_creation_date()
        • │ │ │ │
      • set_hash()
        • │ │ │ │
      • set_hash2()
        • │ │ │ │ -
      • add_http_seed() add_url_seed()
        • │ │ │ │ +
      • add_url_seed() add_http_seed()
        • │ │ │ │
      • add_node()
        • │ │ │ │
      • add_tracker()
        • │ │ │ │
      • set_root_cert()
        • │ │ │ │
      • priv() set_priv()
        • │ │ │ │
      • num_pieces()
        • │ │ │ │
      • piece_range()
        • │ │ │ │
      • file_range()
        • │ │ │ │ @@ -108,16 +108,16 @@ │ │ │ │ .torrent file using bencode().

        │ │ │ │ 
        │ │ │ │  struct create_torrent
│ │ │ │  {
│ │ │ │     explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ │        , create_flags_t flags = {});
│ │ │ │     explicit create_torrent (torrent_info const& ti);
│ │ │ │ -   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);
│ │ │ │ @@ -132,16 +132,16 @@
│ │ │ │     int num_pieces () const;
│ │ │ │     piece_index_t end_piece () const;
│ │ │ │     index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │     file_index_t end_file () const;
│ │ │ │     index_range<file_index_t> file_range () const noexcept;
│ │ │ │     index_range<piece_index_t::diff_type> file_piece_range (file_index_t f);
│ │ │ │     std::int64_t total_size () const;
│ │ │ │ -   int piece_size (piece_index_t i) const;
│ │ │ │     int piece_length () const;
│ │ │ │ +   int piece_size (piece_index_t i) const;
│ │ │ │     void add_collection (string_view c);
│ │ │ │     void add_similar_torrent (sha1_hash ih);
│ │ │ │  
│ │ │ │     static constexpr create_flags_t modification_time  = 2_bit;
│ │ │ │     static constexpr create_flags_t symlinks  = 3_bit;
│ │ │ │     static constexpr create_flags_t v2_only  = 5_bit;
│ │ │ │     static constexpr create_flags_t v1_only  = 6_bit;
│ │ │ │ @@ -173,21 +173,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()

    │ │ │ │ 
    │ │ │ │ -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 │ │ │ │ @@ -270,18 +270,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_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 │ │ │ │ @@ -372,16 +372,16 @@ │ │ │ │ │ │ │ │

    the total number of bytes of all files and pad files

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

    piece_size() piece_length()

    │ │ │ │ 
    │ │ │ │ -int piece_size (piece_index_t i) const;
│ │ │ │  int piece_length () const;
│ │ │ │ +int piece_size (piece_index_t i) 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]
    │ │ │ │
    │ │ │ │ @@ -457,17 +457,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:

    │ │ │ │ 
    │ │ │ │ @@ -481,25 +481,25 @@
│ │ │ │  constructor.
    
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    set_piece_hashes()

    │ │ │ │

    Declared in "libtorrent/create_torrent.hpp"

    │ │ │ │ 
    │ │ │ │  void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ +   , settings_interface const& settings
│ │ │ │     , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │  void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │     , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p);
│ │ │ │  inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │     , settings_interface const& settings
│ │ │ │     , std::function<void(piece_index_t)> const& f);
│ │ │ │  void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , settings_interface const& settings
│ │ │ │ +   , 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);
│ │ │ │  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
│ │ │ │     , 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 │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -1,22 +1,22 @@ │ │ │ │ │ > │ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_] │ │ │ │ │ VVeerrssiioonn:: 2.0.10 │ │ │ │ │ _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 _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_(_) │ │ │ │ │ @@ -69,16 +69,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 (file_storage& fs, int piece_size = 0 │ │ │ │ │ , create_flags_t flags = {}); │ │ │ │ │ explicit ccrreeaattee__ttoorrrreenntt (torrent_info const& ti); │ │ │ │ │ - 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); │ │ │ │ │ @@ -94,16 +94,16 @@ │ │ │ │ │ int nnuumm__ppiieecceess () const; │ │ │ │ │ piece_index_t eenndd__ppiieeccee () const; │ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept; │ │ │ │ │ file_index_t eenndd__ffiillee () const; │ │ │ │ │ index_range ffiillee__rraannggee () const noexcept; │ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t f); │ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const; │ │ │ │ │ - int ppiieeccee__ssiizzee (piece_index_t i) const; │ │ │ │ │ int ppiieeccee__lleennggtthh () const; │ │ │ │ │ + int ppiieeccee__ssiizzee (piece_index_t i) const; │ │ │ │ │ void aadddd__ccoolllleeccttiioonn (string_view c); │ │ │ │ │ void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih); │ │ │ │ │ │ │ │ │ │ static constexpr create_flags_t mmooddiiffiiccaattiioonn__ttiimmee = 2_bit; │ │ │ │ │ static constexpr create_flags_t ssyymmlliinnkkss = 3_bit; │ │ │ │ │ static constexpr create_flags_t vv22__oonnllyy = 5_bit; │ │ │ │ │ static constexpr create_flags_t vv11__oonnllyy = 6_bit; │ │ │ │ │ @@ -130,17 +130,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(()) ********** │ │ │ │ │ -std::vector ggeenneerraattee__bbuuff () const; │ │ │ │ │ +********** ggeenneerraattee(()) ggeenneerraattee__bbuuff(()) ********** │ │ │ │ │ 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 │ │ │ │ │ @@ -197,15 +197,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__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. │ │ │ │ │ @@ -263,16 +263,16 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ -int ppiieeccee__ssiizzee (piece_index_t i) const; │ │ │ │ │ int ppiieeccee__lleennggtthh () const; │ │ │ │ │ +int ppiieeccee__ssiizzee (piece_index_t i) const; │ │ │ │ │ piece_length() returns the piece size of all pieces but the last one. │ │ │ │ │ piece_size() returns the size of the specified piece. these functions are just │ │ │ │ │ forwarding to the associated _f_i_l_e___s_t_o_r_a_g_e. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** aadddd__ssiimmiillaarr__ttoorrrreenntt(()) aadddd__ccoolllleeccttiioonn(()) ********** │ │ │ │ │ void aadddd__ccoolllleeccttiioonn (string_view c); │ │ │ │ │ void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih); │ │ │ │ │ @@ -329,17 +329,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,25 +348,25 @@ │ │ │ │ │ The ".." directory is never traversed. │ │ │ │ │ The flags argument should be the same as the flags passed to the _c_r_e_a_t_e___t_o_r_r_e_n_t │ │ │ │ │ constructor. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ sseett__ppiieeccee__hhaasshheess(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_c_r_e_a_t_e___t_o_r_r_e_n_t_._h_p_p" │ │ │ │ │ void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p │ │ │ │ │ + , settings_interface const& settings │ │ │ │ │ , std::function const& f, error_code& ec); │ │ │ │ │ void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p │ │ │ │ │ - , settings_interface const& settings, disk_io_constructor_type disk_io │ │ │ │ │ , std::function const& f, error_code& ec); │ │ │ │ │ +inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p); │ │ │ │ │ inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p │ │ │ │ │ , settings_interface const& settings │ │ │ │ │ , std::function const& f); │ │ │ │ │ void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p │ │ │ │ │ - , settings_interface const& settings │ │ │ │ │ + , 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); │ │ │ │ │ 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 │ │ │ │ │ , 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 │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Custom_Storage.html │ │ │ │ @@ -32,15 +32,15 @@ │ │ │ │

    │ │ │ │

    Table of contents

    │ │ │ │
      │ │ │ │
    • open_file_state
      • │ │ │ │
    • disk_interface
        │ │ │ │
      • new_torrent()
        • │ │ │ │
      • remove_torrent()
        • │ │ │ │ -
      • async_write() async_read()
        • │ │ │ │ +
      • async_read() async_write()
        • │ │ │ │
      • async_hash()
        • │ │ │ │
      • async_hash2()
        • │ │ │ │
      • async_move_storage()
        • │ │ │ │
      • async_release_files()
        • │ │ │ │
      • async_check_files()
        • │ │ │ │
      • async_stop_torrent()
        • │ │ │ │
      • async_rename_file()
        • │ │ │ │ @@ -133,21 +133,21 @@ │ │ │ │ the constructor. The callbacks will be run in the network thread.

        │ │ │ │ 
        │ │ │ │  struct disk_interface
│ │ │ │  {
│ │ │ │     virtual storage_holder new_torrent (storage_params const& p
│ │ │ │        , std::shared_ptr<void> const& torrent) = 0;
│ │ │ │     virtual void remove_torrent (storage_index_t) = 0;
│ │ │ │ -   virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ -      , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ -      , disk_job_flags_t flags = {}) = 0;
│ │ │ │     virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ │        , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ │        , std::function<void(storage_error const&)> handler
│ │ │ │        , disk_job_flags_t flags = {}) = 0;
│ │ │ │ +   virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ +      , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ +      , disk_job_flags_t flags = {}) = 0;
│ │ │ │     virtual void async_hash (storage_index_t storage, piece_index_t piece, span<sha256_hash> v2
│ │ │ │        , disk_job_flags_t flags
│ │ │ │        , std::function<void(piece_index_t, sha1_hash const&, storage_error const&)> handler) = 0;
│ │ │ │     virtual void async_hash2 (storage_index_t storage, piece_index_t piece, int offset, disk_job_flags_t flags
│ │ │ │        , std::function<void(piece_index_t, sha256_hash const&, storage_error const&)> handler) = 0;
│ │ │ │     virtual void async_move_storage (storage_index_t storage, std::string p, move_flags_t flags
│ │ │ │        , std::function<void(status_t, std::string const&, storage_error const&)> handler) = 0;
│ │ │ │ @@ -199,26 +199,26 @@
│ │ │ │  
        remove_torrent()
        
│ │ │ │  
        │ │ │ │  virtual void remove_torrent (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.
        
│ │ │ │ -
│ │ │ │ -[report issue]
    │ │ │ │ -
    │ │ │ │ -

    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
│ │ │ │        , disk_job_flags_t flags = {}) = 0;
│ │ │ │ +virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ +      , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ +      , disk_job_flags_t flags = {}) = 0;
│ │ │ │
    │ │ │ │

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

    │ │ │ │

    The disk_observer is a callback to indicate that │ │ │ │ @@ -469,16 +469,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 () = default;
│ │ │ │     ~storage_holder ();
│ │ │ │ +   storage_holder () = default;
│ │ │ │     storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ │     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;
│ │ │ │ @@ -610,20 +610,20 @@
│ │ │ │  
    settings_interface
    
│ │ │ │  
    Declared in "libtorrent/settings_pack.hpp"
    
│ │ │ │  
    the common interface to settings_pack and the internal representation of
│ │ │ │  settings.
    
│ │ │ │  
    │ │ │ │  struct settings_interface
│ │ │ │  {
│ │ │ │ -   virtual void set_str (int name, std::string val) = 0;
│ │ │ │     virtual bool has_val (int name) const = 0;
│ │ │ │ -   virtual void set_int (int name, int val) = 0;
│ │ │ │ +   virtual void set_str (int name, std::string val) = 0;
│ │ │ │     virtual void set_bool (int name, bool val) = 0;
│ │ │ │ -   virtual bool get_bool (int name) const = 0;
│ │ │ │ +   virtual void set_int (int name, int val) = 0;
│ │ │ │     virtual int get_int (int name) const = 0;
│ │ │ │ +   virtual bool get_bool (int name) const = 0;
│ │ │ │     virtual std::string const& get_str (int name) const = 0;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    file_open_mode_t

    │ │ │ │

    Declared in "libtorrent/disk_interface.hpp"

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -3,15 +3,15 @@ │ │ │ │ │ VVeerrssiioonn:: 2.0.10 │ │ │ │ │ _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_(_) │ │ │ │ │ @@ -90,21 +90,21 @@ │ │ │ │ │ thread via the io_context object passed into the constructor. The callbacks │ │ │ │ │ will be run in the network thread. │ │ │ │ │ struct disk_interface │ │ │ │ │ { │ │ │ │ │ virtual storage_holder nneeww__ttoorrrreenntt (storage_params const& p │ │ │ │ │ , std::shared_ptr const& torrent) = 0; │ │ │ │ │ virtual void rreemmoovvee__ttoorrrreenntt (storage_index_t) = 0; │ │ │ │ │ - virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r │ │ │ │ │ - , std::function handler │ │ │ │ │ - , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ virtual bool aassyynncc__wwrriittee (storage_index_t storage, peer_request const& r │ │ │ │ │ , char const* buf, std::shared_ptr o │ │ │ │ │ , std::function handler │ │ │ │ │ , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ + virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r │ │ │ │ │ + , std::function handler │ │ │ │ │ + , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ virtual void aassyynncc__hhaasshh (storage_index_t storage, piece_index_t piece, │ │ │ │ │ span v2 │ │ │ │ │ , disk_job_flags_t flags │ │ │ │ │ , std::function handler) = 0; │ │ │ │ │ virtual void aassyynncc__hhaasshh22 (storage_index_t storage, piece_index_t piece, int │ │ │ │ │ offset, disk_job_flags_t flags │ │ │ │ │ @@ -159,22 +159,22 @@ │ │ │ │ │ [_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(()) ********** │ │ │ │ │ -virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r │ │ │ │ │ - , std::function handler │ │ │ │ │ - , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ +********** aassyynncc__rreeaadd(()) aassyynncc__wwrriittee(()) ********** │ │ │ │ │ virtual bool aassyynncc__wwrriittee (storage_index_t storage, peer_request const& r │ │ │ │ │ , char const* buf, std::shared_ptr o │ │ │ │ │ , std::function handler │ │ │ │ │ , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ +virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r │ │ │ │ │ + , std::function handler │ │ │ │ │ + , disk_job_flags_t flags = {}) = 0; │ │ │ │ │ perform a read or write operation from/to the specified storage index and the │ │ │ │ │ specified request. When the operation completes, call handler possibly with a │ │ │ │ │ _d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r, holding the buffer with the result. Flags may be set to │ │ │ │ │ affect the read operation. See disk_job_flags_t. │ │ │ │ │ The _d_i_s_k___o_b_s_e_r_v_e_r is a callback to indicate that the store buffer/disk write │ │ │ │ │ queue is below the watermark to let peers start writing buffers to disk again. │ │ │ │ │ When async_write() returns true, indicating the write queue is full, the peer │ │ │ │ │ @@ -361,16 +361,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 () = default; │ │ │ │ │ ~~ssttoorraaggee__hhoollddeerr (); │ │ │ │ │ + ssttoorraaggee__hhoollddeerr () = default; │ │ │ │ │ ssttoorraaggee__hhoollddeerr (storage_index_t idx, disk_interface& disk_io); │ │ │ │ │ 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; │ │ │ │ │ @@ -460,20 +460,20 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ sseettttiinnggss__iinntteerrffaaccee ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p" │ │ │ │ │ the common interface to _s_e_t_t_i_n_g_s___p_a_c_k and the internal representation of │ │ │ │ │ settings. │ │ │ │ │ struct settings_interface │ │ │ │ │ { │ │ │ │ │ - virtual void sseett__ssttrr (int name, std::string val) = 0; │ │ │ │ │ virtual bool hhaass__vvaall (int name) const = 0; │ │ │ │ │ - virtual void sseett__iinntt (int name, int val) = 0; │ │ │ │ │ + virtual void sseett__ssttrr (int name, std::string val) = 0; │ │ │ │ │ virtual void sseett__bbooooll (int name, bool val) = 0; │ │ │ │ │ - virtual bool ggeett__bbooooll (int name) const = 0; │ │ │ │ │ + virtual void sseett__iinntt (int name, int val) = 0; │ │ │ │ │ virtual int ggeett__iinntt (int name) const = 0; │ │ │ │ │ + virtual bool ggeett__bbooooll (int name) const = 0; │ │ │ │ │ virtual std::string const& ggeett__ssttrr (int name) const = 0; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ffiillee__ooppeenn__mmooddee__tt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_i_s_k___i_n_t_e_r_f_a_c_e_._h_p_p" │ │ │ │ │ read_only │ │ │ │ │ open the file for reading only │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Error_Codes.html │ │ │ │┄ Ordering differences only │ │ │ │ @@ -61,16 +61,16 @@ │ │ │ │

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

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

    bool()

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

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

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

    file()

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

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

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

    │ │ │ │

    A default constructed ip_filter does not filter any address.

    │ │ │ │ 
    │ │ │ │  struct ip_filter
│ │ │ │  {
│ │ │ │ -   ip_filter (ip_filter&&);
│ │ │ │ -   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&&);
│ │ │ │     bool empty () const;
│ │ │ │     void add_rule (address const& first, address const& last, std::uint32_t flags);
│ │ │ │     std::uint32_t access (address const& addr) const;
│ │ │ │     filter_tuple_t export_filter () const;
│ │ │ │  
│ │ │ │     enum access_flags
│ │ │ │     {
│ │ │ │ @@ -153,20 +153,20 @@
│ │ │ │  
    the port filter maps non-overlapping port ranges to flags. This
│ │ │ │  is primarily used to indicate whether a range of ports should
│ │ │ │  be connected to or not. The default is to have the full port
│ │ │ │  range (0-65535) set to flag 0.
    
│ │ │ │  
    │ │ │ │  class port_filter
│ │ │ │  {
│ │ │ │ -   port_filter (port_filter&&);
│ │ │ │ -   port_filter& operator= (port_filter&&);
│ │ │ │ -   port_filter (port_filter const&);
│ │ │ │ -   ~port_filter ();
│ │ │ │     port_filter ();
│ │ │ │ +   ~port_filter ();
│ │ │ │     port_filter& operator= (port_filter const&);
│ │ │ │ +   port_filter& operator= (port_filter&&);
│ │ │ │ +   port_filter (port_filter&&);
│ │ │ │ +   port_filter (port_filter const&);
│ │ │ │     void add_rule (std::uint16_t first, std::uint16_t last, std::uint32_t flags);
│ │ │ │     std::uint32_t access (std::uint16_t port) const;
│ │ │ │  
│ │ │ │     enum access_flags
│ │ │ │     {
│ │ │ │        blocked,
│ │ │ │     };
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -19,20 +19,20 @@
│ │ │ │ │  The ip_filter class is a set of rules that uniquely categorizes all ip
│ │ │ │ │  addresses as allowed or disallowed. The default constructor creates a single
│ │ │ │ │  rule that allows all addresses (0.0.0.0 - 255.255.255.255 for the IPv4 range,
│ │ │ │ │  and the equivalent range covering all addresses for the IPv6 range).
│ │ │ │ │  A default constructed _i_p___f_i_l_t_e_r does not filter any address.
│ │ │ │ │  struct ip_filter
│ │ │ │ │  {
│ │ │ │ │ -   iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │ -   iipp__ffiilltteerr ();
│ │ │ │ │     iipp__ffiilltteerr (ip_filter const&);
│ │ │ │ │ -   ~~iipp__ffiilltteerr ();
│ │ │ │ │     ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │ +   ~~iipp__ffiilltteerr ();
│ │ │ │ │     ip_filter& ooppeerraattoorr== (ip_filter const&);
│ │ │ │ │ +   iipp__ffiilltteerr ();
│ │ │ │ │ +   iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │     bool eemmppttyy () const;
│ │ │ │ │     void aadddd__rruullee (address const& first, address const& last, std::uint32_t
│ │ │ │ │  flags);
│ │ │ │ │     std::uint32_t aacccceessss (address const& addr) const;
│ │ │ │ │     filter_tuple_t eexxppoorrtt__ffiilltteerr () const;
│ │ │ │ │  
│ │ │ │ │     enum access_flags
│ │ │ │ │ @@ -81,20 +81,20 @@
│ │ │ │ │  ************ ppoorrtt__ffiilltteerr ************
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_p___f_i_l_t_e_r_._h_p_p"
│ │ │ │ │  the port filter maps non-overlapping port ranges to flags. This is primarily
│ │ │ │ │  used to indicate whether a range of ports should be connected to or not. The
│ │ │ │ │  default is to have the full port range (0-65535) set to flag 0.
│ │ │ │ │  class port_filter
│ │ │ │ │  {
│ │ │ │ │ -   ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │ -   port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ -   ppoorrtt__ffiilltteerr (port_filter const&);
│ │ │ │ │ -   ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │     ppoorrtt__ffiilltteerr ();
│ │ │ │ │ +   ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │     port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │ +   port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ +   ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │ +   ppoorrtt__ffiilltteerr (port_filter const&);
│ │ │ │ │     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
│ │ │ │ @@ -31,15 +31,15 @@
│ │ │ │  
    home
    
│ │ │ │  
    
│ │ │ │  
    Table of contents
    
│ │ │ │  
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -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
│ │ │ │ @@ -127,23 +127,23 @@
│ │ │ │     };
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  
│ │ │ │  [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()
    
│ │ │ │ +
│ │ │ │ +[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);
│ │ │ │  
    
│ │ │ │  
    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
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -2,15 +2,15 @@
│ │ │ │ │  _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │  VVeerrssiioonn:: 2.0.10
│ │ │ │ │  _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 _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_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
│ │ │ │ │  [_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_(_)
│ │ │ │ │  calls.
│ │ │ │ │ @@ -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
│ │ │ │ │ @@ -79,20 +79,20 @@
│ │ │ │ │        ssl_utp_socket,
│ │ │ │ │        i2p_socket,
│ │ │ │ │        num_socket_types,
│ │ │ │ │     };
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** rreemmoovvee(()) aadddd(()) **********
│ │ │ │ │ -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);
│ │ │ │ │  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(()) **********
│ │ │ │ │ +********** aallllooww(()) ddiissaallllooww(()) **********
│ │ │ │ │  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
│ │ │ │ │  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]
│ │ │ ├── ./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
│ │ │ │ @@ -348,16 +348,16 @@
│ │ │ │  
    │ │ │ │  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 tick ();
│ │ │ │ -   virtual bool on_resume ();
│ │ │ │     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);
│ │ │ │  
│ │ │ │     static constexpr add_peer_flags_t first_time  = 1_bit;
│ │ │ │     static constexpr add_peer_flags_t filtered  = 2_bit;
│ │ │ │ @@ -376,18 +376,18 @@
│ │ │ │  are supposed to return an instance of your peer_plugin class. Which in
│ │ │ │  turn will have its hook functions called on event specific to that peer.
    
│ │ │ │  
    The peer_connection_handle will be valid as long as the shared_ptr
│ │ │ │  is being held by the torrent object. So, it is generally a good idea to not
│ │ │ │  keep a shared_ptr to your own peer_plugin. If you want to keep references
│ │ │ │  to it, use weak_ptr.
    
│ │ │ │  
    If this function throws an exception, the connection will be closed.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    • 
│ │ │ │ -
    
│ │ │ │ -
    on_piece_pass() on_piece_failed()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_piece_failed() on_piece_pass()
    
│ │ │ │  
    │ │ │ │  virtual void on_piece_pass (piece_index_t);
│ │ │ │  virtual void on_piece_failed (piece_index_t);
│ │ │ │  
    
│ │ │ │  
    These hooks are called when a piece passes the hash check or fails the hash
│ │ │ │  check, respectively. The index is the piece index that was downloaded.
│ │ │ │  It is possible to access the list of peers that participated in sending the
│ │ │ │ @@ -396,21 +396,21 @@
│ │ │ │  
    
│ │ │ │  
    tick()
    
│ │ │ │  
    │ │ │ │  virtual void tick ();
│ │ │ │  
    
│ │ │ │  
    This hook is called approximately once per second. It is a way of making it
│ │ │ │  easy for plugins to do timed events, for sending messages or whatever.
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    on_resume() on_pause()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_pause() on_resume()
    
│ │ │ │  
    │ │ │ │ -virtual bool on_resume ();
│ │ │ │  virtual bool on_pause ();
│ │ │ │ +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
│ │ │ │  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 resume.
    
│ │ │ │ @@ -475,43 +475,43 @@
│ │ │ │  {
│ │ │ │     virtual string_view type () const;
│ │ │ │     virtual void add_handshake (entry&);
│ │ │ │     virtual void on_disconnect (error_code const&);
│ │ │ │     virtual void on_connected ();
│ │ │ │     virtual bool on_handshake (span<char const>);
│ │ │ │     virtual bool on_extension_handshake (bdecode_node const&);
│ │ │ │ +   virtual bool on_interested ();
│ │ │ │ +   virtual bool on_have_none ();
│ │ │ │     virtual bool on_not_interested ();
│ │ │ │ -   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ -   virtual bool on_have (piece_index_t);
│ │ │ │ -   virtual bool on_have_all ();
│ │ │ │ +   virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +   virtual bool on_choke ();
│ │ │ │     virtual bool on_unchoke ();
│ │ │ │ -   virtual bool on_request (peer_request const&);
│ │ │ │ +   virtual bool on_have_all ();
│ │ │ │     virtual bool on_dont_have (piece_index_t);
│ │ │ │ -   virtual bool on_choke ();
│ │ │ │ -   virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ -   virtual bool on_interested ();
│ │ │ │ -   virtual bool on_have_none ();
│ │ │ │ +   virtual bool on_have (piece_index_t);
│ │ │ │ +   virtual bool on_request (peer_request const&);
│ │ │ │ +   virtual bool on_allowed_fast (piece_index_t);
│ │ │ │     virtual bool on_piece (peer_request const& /*piece*/
│ │ │ │        , span<char const> /*buf*/);
│ │ │ │     virtual bool on_reject (peer_request const&);
│ │ │ │ -   virtual bool on_cancel (peer_request const&);
│ │ │ │     virtual bool on_suggest (piece_index_t);
│ │ │ │ +   virtual bool on_cancel (peer_request const&);
│ │ │ │     virtual void sent_have_none ();
│ │ │ │ +   virtual void sent_request (peer_request const&);
│ │ │ │     virtual void sent_allow_fast (piece_index_t);
│ │ │ │     virtual void sent_have_all ();
│ │ │ │ -   virtual void sent_reject_request (peer_request const&);
│ │ │ │     virtual void sent_cancel (peer_request const&);
│ │ │ │ -   virtual void sent_choke ();
│ │ │ │ -   virtual void sent_request (peer_request const&);
│ │ │ │     virtual void sent_suggest (piece_index_t);
│ │ │ │ +   virtual void sent_choke ();
│ │ │ │ +   virtual void sent_reject_request (peer_request const&);
│ │ │ │ +   virtual void sent_piece (peer_request const&);
│ │ │ │     virtual void sent_unchoke ();
│ │ │ │ -   virtual void sent_not_interested ();
│ │ │ │     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);
│ │ │ │ @@ -570,38 +570,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_unchoke() on_have() on_dont_have() on_choke() on_have_all() on_have_none() on_request() on_bitfield() on_interested() on_not_interested() on_allowed_fast()

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

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

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

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

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

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

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

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

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

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

    │ │ │ │ 
    │ │ │ │ +virtual void sent_piece (peer_request const&);
│ │ │ │  virtual void sent_unchoke ();
│ │ │ │ -virtual void sent_not_interested ();
│ │ │ │  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 */);
│ │ │ │ @@ -669,18 +669,18 @@
│ │ │ │  
    
│ │ │ │  
    on_unknown_message()
    
│ │ │ │  
    │ │ │ │  virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ │        span<char const> /*body*/);
│ │ │ │  
    
│ │ │ │  
    this is not called for web seeds
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    on_piece_pass() on_piece_failed()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    on_piece_failed() on_piece_pass()
    
│ │ │ │  
    │ │ │ │  virtual void on_piece_pass (piece_index_t);
│ │ │ │  virtual void on_piece_failed (piece_index_t);
│ │ │ │  
    
│ │ │ │  
    called when a piece that this peer participated in either
│ │ │ │  fails or passes the hash_check
    
│ │ │ │  [report issue]
    
│ │ │ │ @@ -703,16 +703,16 @@
│ │ │ │
    │ │ │ │
    │ │ │ │

    crypto_plugin

    │ │ │ │

    Declared in "libtorrent/extensions.hpp"

    │ │ │ │ 
    │ │ │ │  struct crypto_plugin
│ │ │ │  {
│ │ │ │ -   virtual void set_incoming_key (span<char const> key) = 0;
│ │ │ │     virtual void set_outgoing_key (span<char const> key) = 0;
│ │ │ │ +   virtual void set_incoming_key (span<char const> key) = 0;
│ │ │ │     encrypt (span<span<char>> /*send_vec*/) = 0;
│ │ │ │     virtual std::tuple<int, int, int> decrypt (span<span<char>> /*receive_vec*/) = 0;
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    decrypt()

    │ │ │ │ 
    │ │ │ │ @@ -746,59 +746,59 @@
│ │ │ │     bool upload_only () const;
│ │ │ │     bool has_piece (piece_index_t i) const;
│ │ │ │     peer_id const& pid () const;
│ │ │ │     bool is_choked () const;
│ │ │ │     bool is_interesting () const;
│ │ │ │     bool is_peer_interested () const;
│ │ │ │     bool has_peer_choked () const;
│ │ │ │ -   void maybe_unchoke_this_peer ();
│ │ │ │     void choke_this_peer ();
│ │ │ │ +   void maybe_unchoke_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;
│ │ │ │ +   bool is_connecting () const;
│ │ │ │     void disconnect (error_code const& ec, operation_t op
│ │ │ │        , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ -   bool is_connecting () const;
│ │ │ │ -   bool is_outgoing () const;
│ │ │ │     bool is_disconnecting () const;
│ │ │ │ +   bool is_outgoing () const;
│ │ │ │     bool ignore_unchoke_slots () const;
│ │ │ │     bool on_local_network () const;
│ │ │ │     bool failed () 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);
│ │ │ │     time_point time_of_last_unchoke () const;
│ │ │ │     std::time_t last_seen_complete () const;
│ │ │ │ +   bool operator< (peer_connection_handle const& o) const;
│ │ │ │     bool operator!= (peer_connection_handle const& o) const;
│ │ │ │     bool operator== (peer_connection_handle const& o) const;
│ │ │ │ -   bool operator< (peer_connection_handle const& o) const;
│ │ │ │     std::shared_ptr<peer_connection> native_handle () const;
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │
    │ │ │ │

    bt_peer_connection_handle

    │ │ │ │

    Declared in "libtorrent/peer_connection_handle.hpp"

    │ │ │ │

    The bt_peer_connection_handle provides a handle to the internal bittorrent │ │ │ │ peer connection object to plugins. It's low level and may not be a stable API │ │ │ │ across libtorrent versions.

    │ │ │ │ 
    │ │ │ │  struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │  {
│ │ │ │     explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ │ -   bool support_extensions () const;
│ │ │ │     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___p_a_s_s_(_)_ _o_n___p_i_e_c_e___f_a_i_l_e_d_(_) │ │ │ │ │ + o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_) │ │ │ │ │ o _t_i_c_k_(_) │ │ │ │ │ - o _o_n___r_e_s_u_m_e_(_)_ _o_n___p_a_u_s_e_(_) │ │ │ │ │ + o _o_n___p_a_u_s_e_(_)_ _o_n___r_e_s_u_m_e_(_) │ │ │ │ │ o _o_n___f_i_l_e_s___c_h_e_c_k_e_d_(_) │ │ │ │ │ o _o_n___s_t_a_t_e_(_) │ │ │ │ │ o _o_n___a_d_d___p_e_e_r_(_) │ │ │ │ │ * _p_e_e_r___p_l_u_g_i_n │ │ │ │ │ o _t_y_p_e_(_) │ │ │ │ │ o _a_d_d___h_a_n_d_s_h_a_k_e_(_) │ │ │ │ │ o _o_n___d_i_s_c_o_n_n_e_c_t_(_) │ │ │ │ │ o _o_n___c_o_n_n_e_c_t_e_d_(_) │ │ │ │ │ o _o_n___h_a_n_d_s_h_a_k_e_(_) │ │ │ │ │ o _o_n___e_x_t_e_n_s_i_o_n___h_a_n_d_s_h_a_k_e_(_) │ │ │ │ │ - o _o_n___u_n_c_h_o_k_e_(_)_ _o_n___h_a_v_e_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___c_h_o_k_e_(_)_ _o_n___h_a_v_e___a_l_l_(_) │ │ │ │ │ - _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_) │ │ │ │ │ - _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_) │ │ │ │ │ + o _o_n___u_n_c_h_o_k_e_(_)_ _o_n___h_a_v_e___a_l_l_(_)_ _o_n___c_h_o_k_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___r_e_q_u_e_s_t │ │ │ │ │ + _(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _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___h_a_v_e___n_o_n_e_(_)_ _o_n___h_a_v_e_(_) │ │ │ │ │ o _o_n___p_i_e_c_e_(_) │ │ │ │ │ - o _s_e_n_t___p_i_e_c_e_(_)_ _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___i_n_t_e_r_e_s_t_e_d_(_) │ │ │ │ │ + o _s_e_n_t___u_n_c_h_o_k_e_(_)_ _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___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_(_) │ │ │ │ │ o _s_e_n_t___p_a_y_l_o_a_d_(_) │ │ │ │ │ o _c_a_n___d_i_s_c_o_n_n_e_c_t_(_) │ │ │ │ │ o _o_n___e_x_t_e_n_d_e_d_(_) │ │ │ │ │ o _o_n___u_n_k_n_o_w_n___m_e_s_s_a_g_e_(_) │ │ │ │ │ - o _o_n___p_i_e_c_e___p_a_s_s_(_)_ _o_n___p_i_e_c_e___f_a_i_l_e_d_(_) │ │ │ │ │ + o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_) │ │ │ │ │ o _t_i_c_k_(_) │ │ │ │ │ o _w_r_i_t_e___r_e_q_u_e_s_t_(_) │ │ │ │ │ * _c_r_y_p_t_o___p_l_u_g_i_n │ │ │ │ │ o _d_e_c_r_y_p_t_(_) │ │ │ │ │ * _p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e │ │ │ │ │ * _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e │ │ │ │ │ * _c_r_e_a_t_e___u_t___p_e_x___p_l_u_g_i_n_(_) │ │ │ │ │ @@ -259,16 +259,16 @@ │ │ │ │ │ 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 ttiicckk (); │ │ │ │ │ - virtual bool oonn__rreessuummee (); │ │ │ │ │ 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); │ │ │ │ │ │ │ │ │ │ static constexpr add_peer_flags_t ffiirrsstt__ttiimmee = 1_bit; │ │ │ │ │ static constexpr add_peer_flags_t ffiilltteerreedd = 2_bit; │ │ │ │ │ @@ -285,30 +285,30 @@ │ │ │ │ │ have its hook functions called on event specific to that peer. │ │ │ │ │ The peer_connection_handle will be valid as long as the shared_ptr is being │ │ │ │ │ held by the torrent object. So, it is generally a good idea to not keep a │ │ │ │ │ shared_ptr to your own _p_e_e_r___p_l_u_g_i_n. If you want to keep references to it, use │ │ │ │ │ weak_ptr. │ │ │ │ │ If this function throws an exception, the connection will be closed. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) ********** │ │ │ │ │ +********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) ********** │ │ │ │ │ virtual void oonn__ppiieeccee__ppaassss (piece_index_t); │ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t); │ │ │ │ │ These hooks are called when a piece passes the hash check or fails the hash │ │ │ │ │ check, respectively. The index is the piece index that was downloaded. It is │ │ │ │ │ possible to access the list of peers that participated in sending the piece │ │ │ │ │ through the torrent and the piece_picker. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ttiicckk(()) ********** │ │ │ │ │ virtual void ttiicckk (); │ │ │ │ │ This hook is called approximately once per second. It is a way of making it │ │ │ │ │ easy for plugins to do timed events, for sending messages or whatever. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** oonn__rreessuummee(()) oonn__ppaauussee(()) ********** │ │ │ │ │ -virtual bool oonn__rreessuummee (); │ │ │ │ │ +********** oonn__ppaauussee(()) oonn__rreessuummee(()) ********** │ │ │ │ │ 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 │ │ │ │ │ resume. │ │ │ │ │ Note that if you call pause() or resume() on the torrent from your handler it │ │ │ │ │ @@ -354,43 +354,43 @@ │ │ │ │ │ { │ │ │ │ │ virtual string_view ttyyppee () const; │ │ │ │ │ virtual void aadddd__hhaannddsshhaakkee (entry&); │ │ │ │ │ virtual void oonn__ddiissccoonnnneecctt (error_code const&); │ │ │ │ │ virtual void oonn__ccoonnnneecctteedd (); │ │ │ │ │ virtual bool oonn__hhaannddsshhaakkee (span); │ │ │ │ │ virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (bdecode_node const&); │ │ │ │ │ + virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ + virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ virtual bool oonn__nnoott__iinntteerreesstteedd (); │ │ │ │ │ - virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ - virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ - virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ + virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ + virtual bool oonn__cchhookkee (); │ │ │ │ │ virtual bool oonn__uunncchhookkee (); │ │ │ │ │ - virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ + virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ virtual bool oonn__ddoonntt__hhaavvee (piece_index_t); │ │ │ │ │ - virtual bool oonn__cchhookkee (); │ │ │ │ │ - virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ - virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ - virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ + virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ + virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ + virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**// │ │ │ │ │ , span //**bbuuff**//); │ │ │ │ │ virtual bool oonn__rreejjeecctt (peer_request const&); │ │ │ │ │ - virtual bool oonn__ccaanncceell (peer_request const&); │ │ │ │ │ virtual bool oonn__ssuuggggeesstt (piece_index_t); │ │ │ │ │ + virtual bool oonn__ccaanncceell (peer_request const&); │ │ │ │ │ virtual void sseenntt__hhaavvee__nnoonnee (); │ │ │ │ │ + virtual void sseenntt__rreeqquueesstt (peer_request const&); │ │ │ │ │ virtual void sseenntt__aallllooww__ffaasstt (piece_index_t); │ │ │ │ │ virtual void sseenntt__hhaavvee__aallll (); │ │ │ │ │ - virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&); │ │ │ │ │ virtual void sseenntt__ccaanncceell (peer_request const&); │ │ │ │ │ - virtual void sseenntt__cchhookkee (); │ │ │ │ │ - virtual void sseenntt__rreeqquueesstt (peer_request const&); │ │ │ │ │ virtual void sseenntt__ssuuggggeesstt (piece_index_t); │ │ │ │ │ + virtual void sseenntt__cchhookkee (); │ │ │ │ │ + virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&); │ │ │ │ │ + virtual void sseenntt__ppiieeccee (peer_request const&); │ │ │ │ │ virtual void sseenntt__uunncchhookkee (); │ │ │ │ │ - virtual void sseenntt__nnoott__iinntteerreesstteedd (); │ │ │ │ │ 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); │ │ │ │ │ @@ -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__hhaavvee(()) oonn__ddoonntt__hhaavvee(()) oonn__cchhookkee(()) oonn__hhaavvee__aallll(()) │ │ │ │ │ -oonn__hhaavvee__nnoonnee(()) oonn__rreeqquueesstt(()) oonn__bbiittffiieelldd(()) oonn__iinntteerreesstteedd(()) oonn__nnoott__iinntteerreesstteedd(()) │ │ │ │ │ -oonn__aalllloowweedd__ffaasstt(()) ********** │ │ │ │ │ +********** oonn__uunncchhookkee(()) oonn__hhaavvee__aallll(()) oonn__cchhookkee(()) oonn__aalllloowweedd__ffaasstt(()) oonn__rreeqquueesstt(()) │ │ │ │ │ +oonn__bbiittffiieelldd(()) oonn__iinntteerreesstteedd(()) oonn__ddoonntt__hhaavvee(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee__nnoonnee(()) │ │ │ │ │ +oonn__hhaavvee(()) ********** │ │ │ │ │ +virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ +virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ virtual bool oonn__nnoott__iinntteerreesstteedd (); │ │ │ │ │ -virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ -virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ -virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ +virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ +virtual bool oonn__cchhookkee (); │ │ │ │ │ virtual bool oonn__uunncchhookkee (); │ │ │ │ │ -virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ +virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ virtual bool oonn__ddoonntt__hhaavvee (piece_index_t); │ │ │ │ │ -virtual bool oonn__cchhookkee (); │ │ │ │ │ -virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ -virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ -virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ +virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ +virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ +virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ 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__ppiieeccee(()) sseenntt__hhaavvee(()) sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__uunncchhookkee(()) │ │ │ │ │ -sseenntt__iinntteerreesstteedd(()) ********** │ │ │ │ │ +********** sseenntt__uunncchhookkee(()) sseenntt__hhaavvee(()) sseenntt__ppiieeccee(()) sseenntt__iinntteerreesstteedd(()) │ │ │ │ │ +sseenntt__nnoott__iinntteerreesstteedd(()) ********** │ │ │ │ │ +virtual void sseenntt__ppiieeccee (peer_request const&); │ │ │ │ │ virtual void sseenntt__uunncchhookkee (); │ │ │ │ │ -virtual void sseenntt__nnoott__iinntteerreesstteedd (); │ │ │ │ │ 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] │ │ │ │ │ @@ -490,15 +490,15 @@ │ │ │ │ │ receiving large messages. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** oonn__uunnkknnoowwnn__mmeessssaaggee(()) ********** │ │ │ │ │ virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//, │ │ │ │ │ span //**bbooddyy**//); │ │ │ │ │ this is not called for web seeds │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) ********** │ │ │ │ │ +********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) ********** │ │ │ │ │ virtual void oonn__ppiieeccee__ppaassss (piece_index_t); │ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t); │ │ │ │ │ called when a piece that this peer participated in either fails or passes the │ │ │ │ │ hash_check │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ttiicckk(()) ********** │ │ │ │ │ virtual void ttiicckk (); │ │ │ │ │ @@ -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__iinnccoommiinngg__kkeeyy (span key) = 0; │ │ │ │ │ virtual void sseett__oouuttggooiinngg__kkeeyy (span key) = 0; │ │ │ │ │ + virtual void sseett__iinnccoommiinngg__kkeeyy (span key) = 0; │ │ │ │ │ eennccrryypptt (span> //**sseenndd__vveecc**//) = 0; │ │ │ │ │ virtual std::tuple ddeeccrryypptt (span> //**rreecceeiivvee__vveecc**// │ │ │ │ │ ) = 0; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ddeeccrryypptt(()) ********** │ │ │ │ │ virtual std::tuple ddeeccrryypptt (span> //**rreecceeiivvee__vveecc**//) = │ │ │ │ │ @@ -548,57 +548,57 @@ │ │ │ │ │ bool uuppllooaadd__oonnllyy () const; │ │ │ │ │ bool hhaass__ppiieeccee (piece_index_t i) const; │ │ │ │ │ peer_id const& ppiidd () const; │ │ │ │ │ bool iiss__cchhookkeedd () const; │ │ │ │ │ bool iiss__iinntteerreessttiinngg () const; │ │ │ │ │ bool iiss__ppeeeerr__iinntteerreesstteedd () const; │ │ │ │ │ bool hhaass__ppeeeerr__cchhookkeedd () const; │ │ │ │ │ - void mmaayybbee__uunncchhookkee__tthhiiss__ppeeeerr (); │ │ │ │ │ void cchhookkee__tthhiiss__ppeeeerr (); │ │ │ │ │ + void mmaayybbee__uunncchhookkee__tthhiiss__ppeeeerr (); │ │ │ │ │ void ggeett__ppeeeerr__iinnffoo (peer_info& p) const; │ │ │ │ │ torrent_handle aassssoocciiaatteedd__ttoorrrreenntt () const; │ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t llooccaall__eennddppooiinntt () const; │ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t const& rreemmoottee () const; │ │ │ │ │ + bool iiss__ccoonnnneeccttiinngg () const; │ │ │ │ │ void ddiissccoonnnneecctt (error_code const& ec, operation_t op │ │ │ │ │ , disconnect_severity_t = peer_connection_interface::normal); │ │ │ │ │ - bool iiss__ccoonnnneeccttiinngg () const; │ │ │ │ │ - bool iiss__oouuttggooiinngg () const; │ │ │ │ │ bool iiss__ddiissccoonnnneeccttiinngg () const; │ │ │ │ │ + bool iiss__oouuttggooiinngg () const; │ │ │ │ │ bool iiggnnoorree__uunncchhookkee__sslloottss () const; │ │ │ │ │ bool oonn__llooccaall__nneettwwoorrkk () const; │ │ │ │ │ bool ffaaiilleedd () 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); │ │ │ │ │ time_point ttiimmee__ooff__llaasstt__uunncchhookkee () const; │ │ │ │ │ std::time_t llaasstt__sseeeenn__ccoommpplleettee () const; │ │ │ │ │ + bool ooppeerraattoorr<< (peer_connection_handle const& o) const; │ │ │ │ │ bool ooppeerraattoorr!!== (peer_connection_handle const& o) const; │ │ │ │ │ bool ooppeerraattoorr==== (peer_connection_handle const& o) const; │ │ │ │ │ - bool ooppeerraattoorr<< (peer_connection_handle const& o) const; │ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e_._h_p_p" │ │ │ │ │ The _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e provides a handle to the internal bittorrent peer │ │ │ │ │ connection object to plugins. It's low level and may not be a stable API across │ │ │ │ │ libtorrent versions. │ │ │ │ │ struct bt_peer_connection_handle : peer_connection_handle │ │ │ │ │ { │ │ │ │ │ explicit bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (peer_connection_handle pc); │ │ │ │ │ - bool ssuuppppoorrtt__eexxtteennssiioonnss () const; │ │ │ │ │ bool ppaacckkeett__ffiinniisshheedd () const; │ │ │ │ │ + bool 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 │ │ │ │┄ Ordering differences only │ │ │ │ @@ -38,22 +38,22 @@ │ │ │ │
  • write_torrent_flags_t
    • │ │ │ │ │ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    read_resume_data()

    │ │ │ │

    Declared in "libtorrent/read_resume_data.hpp"

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

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

    │ │ │ │

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

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

    write_resume_data() write_resume_data_buf()

    │ │ │ │

    Declared in "libtorrent/write_resume_data.hpp"

    │ │ │ │ 
    │ │ │ │ -std::vector<char> write_resume_data_buf (add_torrent_params const& atp);
│ │ │ │  entry write_resume_data (add_torrent_params const& atp);
│ │ │ │ +std::vector<char> write_resume_data_buf (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);
│ │ │ │  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);
│ │ │ │ +entry write_torrent_file (add_torrent_params const& atp, write_torrent_flags_t flags);
│ │ │ │
    │ │ │ │

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

    │ │ │ │
      │ │ │ │
    • The add_torrent_params object passed to this function does not contain the │ │ │ │ info dictionary (the ti field)
      • │ │ │ │
    • The piece layers are not complete for all files that need them
      • │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -6,22 +6,22 @@ │ │ │ │ │ * _r_e_a_d___r_e_s_u_m_e___d_a_t_a_(_) │ │ │ │ │ * _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_)_ _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a___b_u_f_(_) │ │ │ │ │ * _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_) │ │ │ │ │ * _w_r_i_t_e___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 (span buffer │ │ │ │ │ - , load_torrent_limits const& cfg = {}); │ │ │ │ │ -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 (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 (span buffer │ │ │ │ │ + , error_code& ec, load_torrent_limits const& cfg = {}); │ │ │ │ │ these functions are used to parse resume data and populate the appropriate │ │ │ │ │ fields in an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object. This object can then be used to add the │ │ │ │ │ actual _t_o_r_r_e_n_t___i_n_f_o object to and pass to session::add_torrent() or session:: │ │ │ │ │ async_add_torrent(). │ │ │ │ │ If the client wants to override any field that was loaded from the resume data, │ │ │ │ │ e.g. save_path, those fields must be changed after loading resume data but │ │ │ │ │ before adding the torrent. │ │ │ │ │ @@ -31,26 +31,26 @@ │ │ │ │ │ limits on torrent sizes via load_torrent limits. │ │ │ │ │ In order to support large torrents, it may also be necessary to raise the │ │ │ │ │ _s_e_t_t_i_n_g_s___p_a_c_k_:_:_m_a_x___p_i_e_c_e___c_o_u_n_t setting and pass a higher limit to calls to │ │ │ │ │ _t_o_r_r_e_n_t___i_n_f_o_:_:_p_a_r_s_e___i_n_f_o___s_e_c_t_i_o_n_(_). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ wwrriittee__rreessuummee__ddaattaa(()) wwrriittee__rreessuummee__ddaattaa__bbuuff(()) ************ │ │ │ │ │ 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" │ │ │ │ │ -std::vector wwrriittee__rreessuummee__ddaattaa__bbuuff (add_torrent_params const& atp); │ │ │ │ │ entry wwrriittee__rreessuummee__ddaattaa (add_torrent_params const& atp); │ │ │ │ │ +std::vector wwrriittee__rreessuummee__ddaattaa__bbuuff (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, 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); │ │ │ │ │ -entry wwrriittee__ttoorrrreenntt__ffiillee (add_torrent_params const& atp); │ │ │ │ │ +entry wwrriittee__ttoorrrreenntt__ffiillee (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 │ │ │ │ │ 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 │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Session.html │ │ │ │ @@ -54,89 +54,89 @@ │ │ │ │
    • refresh_torrent_status() get_torrent_status()
      • │ │ │ │
    • post_torrent_updates()
      • │ │ │ │
    • post_session_stats()
      • │ │ │ │
    • post_dht_stats()
      • │ │ │ │
    • set_dht_state()
      • │ │ │ │
    • get_torrents() find_torrent()
      • │ │ │ │
    • async_add_torrent() add_torrent()
      • │ │ │ │ -
    • resume() is_paused() pause()
      • │ │ │ │ +
    • pause() resume() is_paused()
      • │ │ │ │
    • is_dht_running()
      • │ │ │ │
    • set_dht_storage()
      • │ │ │ │
    • add_dht_node()
      • │ │ │ │
    • dht_get_item()
      • │ │ │ │
    • dht_get_item()
      • │ │ │ │
    • dht_put_item()
      • │ │ │ │
    • dht_put_item()
      • │ │ │ │
    • dht_announce() dht_get_peers()
      • │ │ │ │
    • dht_live_nodes()
      • │ │ │ │
    • dht_sample_infohashes()
      • │ │ │ │
    • dht_direct_request()
      • │ │ │ │
    • add_extension()
      • │ │ │ │
    • set_ip_filter() get_ip_filter()
      • │ │ │ │
    • set_port_filter()
      • │ │ │ │ -
    • is_listening() listen_port() ssl_listen_port()
      • │ │ │ │ +
    • listen_port() ssl_listen_port() is_listening()
      • │ │ │ │
    • set_peer_class_filter() get_peer_class_filter()
      • │ │ │ │ -
    • set_peer_class_type_filter() get_peer_class_type_filter()
      • │ │ │ │ +
    • get_peer_class_type_filter() set_peer_class_type_filter()
      • │ │ │ │
    • create_peer_class()
      • │ │ │ │
    • delete_peer_class()
      • │ │ │ │ -
    • set_peer_class() get_peer_class()
      • │ │ │ │ +
    • get_peer_class() set_peer_class()
      • │ │ │ │
    • remove_torrent()
      • │ │ │ │
    • apply_settings() get_settings()
      • │ │ │ │ -
    • pop_alerts() set_alert_notify() wait_for_alert()
      • │ │ │ │ +
    • set_alert_notify() wait_for_alert() pop_alerts()
      • │ │ │ │
    • add_port_mapping() delete_port_mapping()
      • │ │ │ │
    • reopen_network_sockets()
      • │ │ │ │
    • native_handle()
      • │ │ │ │
    │ │ │ │ │ │ │ │ -
  • write_session_params() write_session_params_buf() read_session_params()
    • │ │ │ │ +
  • write_session_params_buf() write_session_params() read_session_params()
    • │ │ │ │ │ │ │ │
    │ │ │ │ [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 (settings_pack const& sp);
│ │ │ │ -   session_params ();
│ │ │ │     session_params (settings_pack&& sp);
│ │ │ │ -   session_params (settings_pack const& sp
│ │ │ │ -      , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ +   session_params ();
│ │ │ │ +   session_params (settings_pack const& sp);
│ │ │ │     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 (settings_pack const& sp);
│ │ │ │ -session_params ();
│ │ │ │  session_params (settings_pack&& sp);
│ │ │ │ +session_params ();
│ │ │ │ +session_params (settings_pack const& sp);
│ │ │ │
    │ │ │ │

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

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

    session_params()

    │ │ │ │ 
    │ │ │ │ -session_params (settings_pack 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& operator= (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&&) noexcept;
│ │ │ │ +   ~session_proxy ();
│ │ │ │  };
│ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │

    ~session_proxy() operator=() session_proxy()

    │ │ │ │ 
    │ │ │ │ +session_proxy& operator= (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&&) noexcept;
│ │ │ │ +~session_proxy ();
│ │ │ │
    │ │ │ │

    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 (session_params&& params, session_flags_t flags);
│ │ │ │     session (session_params const& params, session_flags_t flags);
│ │ │ │ -   explicit session (session_params const& params);
│ │ │ │     explicit session (session_params&& params);
│ │ │ │ -   session (session_params&& params, io_context& ios);
│ │ │ │ +   session (session_params&& params, session_flags_t flags);
│ │ │ │ +   session ();
│ │ │ │ +   explicit session (session_params const& params);
│ │ │ │     session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ -   session (session_params const& params, io_context& ios);
│ │ │ │ +   session (session_params&& params, io_context& ios);
│ │ │ │     session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +   session (session_params const& params, io_context& ios);
│ │ │ │     ~session ();
│ │ │ │     session_proxy abort ();
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    session()

    │ │ │ │ 
    │ │ │ │ -session ();
│ │ │ │ -session (session_params&& params, session_flags_t flags);
│ │ │ │  session (session_params const& params, session_flags_t flags);
│ │ │ │ -explicit session (session_params const& params);
│ │ │ │  explicit session (session_params&& params);
│ │ │ │ +session (session_params&& params, session_flags_t flags);
│ │ │ │ +session ();
│ │ │ │ +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&& params, io_context& ios, session_flags_t);
│ │ │ │ -session (session_params const& params, io_context& ios);
│ │ │ │ +session (session_params&& params, io_context& ios);
│ │ │ │  session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +session (session_params const& params, io_context& ios);
│ │ │ │
    │ │ │ │

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

    │ │ │ │
    │ │ │ │ @@ -318,30 +318,30 @@ │ │ │ │ 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;
│ │ │ │ +   void set_dht_state (dht::dht_state const& st);
│ │ │ │     torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ -   void async_add_torrent (add_torrent_params&& params);
│ │ │ │ +   std::vector<torrent_handle> get_torrents () const;
│ │ │ │ +   torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │     torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ +   void async_add_torrent (add_torrent_params&& params);
│ │ │ │     void async_add_torrent (add_torrent_params const& params);
│ │ │ │ -   torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │     torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │     torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │     void pause ();
│ │ │ │     bool is_paused () const;
│ │ │ │     void resume ();
│ │ │ │     bool is_dht_running () const;
│ │ │ │     void set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ │ @@ -350,40 +350,40 @@
│ │ │ │     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_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_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │     void dht_live_nodes (sha1_hash const& nid);
│ │ │ │     void dht_sample_infohashes (udp::endpoint const& ep, sha1_hash const& target);
│ │ │ │     void dht_direct_request (udp::endpoint const& ep, entry const& e, client_data_t userdata = {});
│ │ │ │ +   void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │     void add_extension (std::function<std::shared_ptr<torrent_plugin>(
│ │ │ │        torrent_handle const&, client_data_t)> ext);
│ │ │ │ -   void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │     ip_filter get_ip_filter () const;
│ │ │ │     void set_ip_filter (ip_filter f);
│ │ │ │     void set_port_filter (port_filter const& f);
│ │ │ │     bool is_listening () const;
│ │ │ │ -   unsigned short ssl_listen_port () const;
│ │ │ │     unsigned short listen_port () 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 remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ │ +   settings_pack get_settings () const;
│ │ │ │     void apply_settings (settings_pack&&);
│ │ │ │     void apply_settings (settings_pack const&);
│ │ │ │ -   settings_pack get_settings () const;
│ │ │ │     alert* wait_for_alert (time_duration max_wait);
│ │ │ │     void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │     void set_alert_notify (std::function<void()> const& fun);
│ │ │ │     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;
│ │ │ │ @@ -425,19 +425,19 @@
│ │ │ │  the flags parameter can be used to only save certain parts of the
│ │ │ │  session state
    
│ │ │ │  
│ │ │ │  [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.

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

    This will cause a dht_stats_alert to be posted.

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

    set_dht_state()

    │ │ │ │ 
    │ │ │ │ -void set_dht_state (dht::dht_state const& st);
│ │ │ │  void set_dht_state (dht::dht_state&& st);
│ │ │ │ +void set_dht_state (dht::dht_state const& 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]
    │ │ │ │
    │ │ │ │

    get_torrents() find_torrent()

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

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

    │ │ │ │

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

    │ │ │ │

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

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

    async_add_torrent() add_torrent()

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

    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 │ │ │ │ @@ -561,19 +561,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]
    │ │ │ │ -
    │ │ │ │ -

    resume() is_paused() pause()

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

    pause() resume() is_paused()

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

    Pausing the session has the same effect as pausing every torrent in │ │ │ │ it, except that torrents will not be resumed by the auto-manage │ │ │ │ @@ -690,16 +690,16 @@ │ │ │ │ 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()

    │ │ │ │ 
    │ │ │ │ -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_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │
    │ │ │ │

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

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

    add_extension()

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

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

    │ │ │ │ @@ -806,23 +806,23 @@ │ │ │ │ 
    │ │ │ │  void set_port_filter (port_filter const& f);
│ │ │ │
    │ │ │ │

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

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

    is_listening() listen_port() ssl_listen_port()

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

    listen_port() ssl_listen_port() is_listening()

    │ │ │ │ 
    │ │ │ │  bool is_listening () const;
│ │ │ │ -unsigned short ssl_listen_port () const;
│ │ │ │  unsigned short listen_port () 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.

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

    │ │ │ │

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

    │ │ │ │

    The get_peer_class_filter() function returns the current filter.

    │ │ │ │

    For more information, see peer classes.

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

    set_peer_class_type_filter() get_peer_class_type_filter()

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

    │ │ │ │
      │ │ │ │ @@ -909,18 +909,18 @@ │ │ │ │ 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;
│ │ │ │
    │ │ │ │

    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 │ │ │ │ @@ -968,26 +968,26 @@ │ │ │ │ advised to remove them from the back of the queue, to minimize the │ │ │ │ shifting.

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

    apply_settings() get_settings()

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

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

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

    pop_alerts() set_alert_notify() wait_for_alert()

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

    set_alert_notify() wait_for_alert() pop_alerts()

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

    Alerts is the main mechanism for libtorrent to report errors and │ │ │ │ events. pop_alerts fills in the vector passed to it with pointers │ │ │ │ @@ -1117,29 +1117,29 @@ │ │ │ │ [report issue]

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

    write_session_params() write_session_params_buf() read_session_params()

    │ │ │ │ +
    │ │ │ │ +

    write_session_params_buf() write_session_params() read_session_params()

    │ │ │ │

    Declared in "libtorrent/session_params.hpp"

    │ │ │ │ 
    │ │ │ │ -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
│ │ │ │ +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());
│ │ │ │ -session_params read_session_params (span<char const> buf
│ │ │ │ +std::vector<char> write_session_params_buf (session_params const& sp
│ │ │ │ +   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ +entry write_session_params (session_params const& sp
│ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │
    │ │ │ │

    These functions serialize and de-serialize a session_params object to and │ │ │ │ from bencoded form. The session_params object is used to initialize a new │ │ │ │ session using the state from a previous one (or by programmatically configure │ │ │ │ the session up-front). │ │ │ │ The flags parameter can be used to only save and load certain aspects of the │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -19,79 +19,79 @@ │ │ │ │ │ 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 _g_e_t___t_o_r_r_e_n_t_s_(_)_ _f_i_n_d___t_o_r_r_e_n_t_(_) │ │ │ │ │ o _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)_ _a_d_d___t_o_r_r_e_n_t_(_) │ │ │ │ │ - o _r_e_s_u_m_e_(_)_ _i_s___p_a_u_s_e_d_(_)_ _p_a_u_s_e_(_) │ │ │ │ │ + o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)_ _i_s___p_a_u_s_e_d_(_) │ │ │ │ │ o _i_s___d_h_t___r_u_n_n_i_n_g_(_) │ │ │ │ │ o _s_e_t___d_h_t___s_t_o_r_a_g_e_(_) │ │ │ │ │ o _a_d_d___d_h_t___n_o_d_e_(_) │ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_) │ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_) │ │ │ │ │ o _d_h_t___p_u_t___i_t_e_m_(_) │ │ │ │ │ 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___l_i_v_e___n_o_d_e_s_(_) │ │ │ │ │ o _d_h_t___s_a_m_p_l_e___i_n_f_o_h_a_s_h_e_s_(_) │ │ │ │ │ o _d_h_t___d_i_r_e_c_t___r_e_q_u_e_s_t_(_) │ │ │ │ │ o _a_d_d___e_x_t_e_n_s_i_o_n_(_) │ │ │ │ │ o _s_e_t___i_p___f_i_l_t_e_r_(_)_ _g_e_t___i_p___f_i_l_t_e_r_(_) │ │ │ │ │ o _s_e_t___p_o_r_t___f_i_l_t_e_r_(_) │ │ │ │ │ - o _i_s___l_i_s_t_e_n_i_n_g_(_)_ _l_i_s_t_e_n___p_o_r_t_(_)_ _s_s_l___l_i_s_t_e_n___p_o_r_t_(_) │ │ │ │ │ + o _l_i_s_t_e_n___p_o_r_t_(_)_ _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)_ _i_s___l_i_s_t_e_n_i_n_g_(_) │ │ │ │ │ o _s_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_) │ │ │ │ │ - o _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 _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 _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 _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 _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_(_) │ │ │ │ │ - * _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_(_)_ _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_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ sseessssiioonn__ppaarraammss ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p" │ │ │ │ │ The _s_e_s_s_i_o_n___p_a_r_a_m_s is a parameters pack for configuring the _s_e_s_s_i_o_n before it's │ │ │ │ │ started. │ │ │ │ │ struct session_params │ │ │ │ │ { │ │ │ │ │ - sseessssiioonn__ppaarraammss (settings_pack const& sp); │ │ │ │ │ - sseessssiioonn__ppaarraammss (); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp); │ │ │ │ │ - sseessssiioonn__ppaarraammss (settings_pack const& sp │ │ │ │ │ - , std::vector> exts); │ │ │ │ │ + sseessssiioonn__ppaarraammss (); │ │ │ │ │ + sseessssiioonn__ppaarraammss (settings_pack const& sp); │ │ │ │ │ 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 (settings_pack const& sp); │ │ │ │ │ -sseessssiioonn__ppaarraammss (); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp); │ │ │ │ │ +sseessssiioonn__ppaarraammss (); │ │ │ │ │ +sseessssiioonn__ppaarraammss (settings_pack const& sp); │ │ │ │ │ This constructor can be used to start with the default plugins (ut_metadata, │ │ │ │ │ ut_pex and smart_ban). Pass a _s_e_t_t_i_n_g_s___p_a_c_k to set the initial settings when │ │ │ │ │ the _s_e_s_s_i_o_n starts. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseessssiioonn__ppaarraammss(()) ********** │ │ │ │ │ -sseessssiioonn__ppaarraammss (settings_pack 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 │ │ │ │ │ { │ │ │ │ │ + session_proxy& ooppeerraattoorr== (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 (session_proxy&&) noexcept; │ │ │ │ │ + ~~sseessssiioonn__pprrooxxyy (); │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ~~sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) sseessssiioonn__pprrooxxyy(()) ********** │ │ │ │ │ +session_proxy& ooppeerraattoorr== (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 (session_proxy&&) noexcept; │ │ │ │ │ +~~sseessssiioonn__pprrooxxyy (); │ │ │ │ │ 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 (); │ │ │ │ │ - sseessssiioonn (session_params&& params, session_flags_t flags); │ │ │ │ │ sseessssiioonn (session_params const& params, session_flags_t flags); │ │ │ │ │ - explicit sseessssiioonn (session_params const& params); │ │ │ │ │ explicit sseessssiioonn (session_params&& params); │ │ │ │ │ - sseessssiioonn (session_params&& params, io_context& ios); │ │ │ │ │ + sseessssiioonn (session_params&& params, session_flags_t flags); │ │ │ │ │ + sseessssiioonn (); │ │ │ │ │ + explicit sseessssiioonn (session_params const& params); │ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios, session_flags_t); │ │ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ + sseessssiioonn (session_params&& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ + sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ ~~sseessssiioonn (); │ │ │ │ │ session_proxy aabboorrtt (); │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseessssiioonn(()) ********** │ │ │ │ │ -sseessssiioonn (); │ │ │ │ │ -sseessssiioonn (session_params&& params, session_flags_t flags); │ │ │ │ │ sseessssiioonn (session_params const& params, session_flags_t flags); │ │ │ │ │ -explicit sseessssiioonn (session_params const& params); │ │ │ │ │ explicit sseessssiioonn (session_params&& params); │ │ │ │ │ +sseessssiioonn (session_params&& params, session_flags_t flags); │ │ │ │ │ +sseessssiioonn (); │ │ │ │ │ +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&& params, io_context& ios, session_flags_t); │ │ │ │ │ -sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ +sseessssiioonn (session_params&& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ +sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ Overload of the constructor that takes an external io_context to run the │ │ │ │ │ _s_e_s_s_i_o_n object on. This is primarily useful for tests that may want to run │ │ │ │ │ multiple sessions on a single io_context, or low resource systems where │ │ │ │ │ additional threads are expensive and sharing an io_context with other events is │ │ │ │ │ fine. │ │ │ │ │ Warning │ │ │ │ │ The _s_e_s_s_i_o_n object does not cleanly terminate with an external io_context. The │ │ │ │ │ @@ -232,30 +232,30 @@ │ │ │ │ │ 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; │ │ │ │ │ + void sseett__ddhhtt__ssttaattee (dht::dht_state const& st); │ │ │ │ │ torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const; │ │ │ │ │ - void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ + std::vector ggeett__ttoorrrreennttss () const; │ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ + void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& │ │ │ │ │ ec); │ │ │ │ │ void ppaauussee (); │ │ │ │ │ bool iiss__ppaauusseedd () const; │ │ │ │ │ void rreessuummee (); │ │ │ │ │ bool iiss__ddhhtt__rruunnnniinngg () const; │ │ │ │ │ @@ -265,43 +265,43 @@ │ │ │ │ │ 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); │ │ │ │ │ - void aadddd__eexxtteennssiioonn (std::shared_ptr ext); │ │ │ │ │ ip_filter ggeett__iipp__ffiilltteerr () const; │ │ │ │ │ void sseett__iipp__ffiilltteerr (ip_filter f); │ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f); │ │ │ │ │ bool iiss__lliisstteenniinngg () const; │ │ │ │ │ - unsigned short ssssll__lliisstteenn__ppoorrtt () const; │ │ │ │ │ unsigned short lliisstteenn__ppoorrtt () 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 rreemmoovvee__ttoorrrreenntt (const torrent_handle&, remove_flags_t = {}); │ │ │ │ │ + settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&); │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack const&); │ │ │ │ │ - settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts); │ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun); │ │ │ │ │ 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 = │ │ │ │ │ @@ -334,19 +334,19 @@ │ │ │ │ │ returns the current _s_e_s_s_i_o_n state. This can be passed to _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) │ │ │ │ │ to save the state to disk and restored using _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) when │ │ │ │ │ constructing a new _s_e_s_s_i_o_n. The kind of state that's included is all settings, │ │ │ │ │ the DHT routing table, possibly plugin-specific state. the flags parameter can │ │ │ │ │ be used to only save certain parts of the _s_e_s_s_i_o_n state │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) ggeett__ttoorrrreenntt__ssttaattuuss(()) ********** │ │ │ │ │ -void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret │ │ │ │ │ - , status_flags_t flags = {}) const; │ │ │ │ │ std::vector ggeett__ttoorrrreenntt__ssttaattuuss ( │ │ │ │ │ std::function const& pred │ │ │ │ │ , status_flags_t flags = {}) const; │ │ │ │ │ +void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret │ │ │ │ │ + , status_flags_t flags = {}) const; │ │ │ │ │ Note │ │ │ │ │ these calls are potentially expensive and won't scale well with lots of │ │ │ │ │ torrents. If you're concerned about performance, consider using │ │ │ │ │ post_torrent_updates() instead. │ │ │ │ │ get_torrent_status returns a vector of the _t_o_r_r_e_n_t___s_t_a_t_u_s for every torrent │ │ │ │ │ which satisfies pred, which is a predicate function which determines if a │ │ │ │ │ torrent should be included in the returned set or not. Returning true means it │ │ │ │ │ @@ -391,35 +391,35 @@ │ │ │ │ │ For more information, see the _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ppoosstt__ddhhtt__ssttaattss(()) ********** │ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss (); │ │ │ │ │ This will cause a _d_h_t___s_t_a_t_s___a_l_e_r_t to be posted. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseett__ddhhtt__ssttaattee(()) ********** │ │ │ │ │ -void sseett__ddhhtt__ssttaattee (dht::dht_state const& st); │ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state&& st); │ │ │ │ │ +void sseett__ddhhtt__ssttaattee (dht::dht_state const& st); │ │ │ │ │ set the DHT state for the _s_e_s_s_i_o_n. This will be taken into account the next │ │ │ │ │ time the DHT is started, as if it had been passed in via the _s_e_s_s_i_o_n___p_a_r_a_m_s on │ │ │ │ │ startup. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ggeett__ttoorrrreennttss(()) ffiinndd__ttoorrrreenntt(()) ********** │ │ │ │ │ -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(()) ********** │ │ │ │ │ -void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ +void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec); │ │ │ │ │ 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 │ │ │ │ │ @@ -438,15 +438,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] │ │ │ │ │ -********** rreessuummee(()) iiss__ppaauusseedd(()) ppaauussee(()) ********** │ │ │ │ │ +********** ppaauussee(()) rreessuummee(()) iiss__ppaauusseedd(()) ********** │ │ │ │ │ void ppaauussee (); │ │ │ │ │ bool iiss__ppaauusseedd () const; │ │ │ │ │ void rreessuummee (); │ │ │ │ │ Pausing the _s_e_s_s_i_o_n has the same effect as pausing every torrent in it, except │ │ │ │ │ that torrents will not be resumed by the auto-manage mechanism. Resuming will │ │ │ │ │ restore the torrents to their previous paused state. i.e. the _s_e_s_s_i_o_n pause │ │ │ │ │ state is separate from the torrent pause state. A torrent is inactive if it is │ │ │ │ │ @@ -526,17 +526,17 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ +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); │ │ │ │ │ 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). │ │ │ │ │ @@ -567,17 +567,17 @@ │ │ │ │ │ Send an arbitrary DHT request directly to the specified endpoint. This function │ │ │ │ │ is intended for use by plugins. When a response is received or the request │ │ │ │ │ times out, a _d_h_t___d_i_r_e_c_t___r_e_s_p_o_n_s_e___a_l_e_r_t will be posted with the response (if │ │ │ │ │ any) and the userdata pointer passed in here. Since this _a_l_e_r_t is a response to │ │ │ │ │ an explicit call, it will always be posted, regardless of the _a_l_e_r_t mask. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** aadddd__eexxtteennssiioonn(()) ********** │ │ │ │ │ +void aadddd__eexxtteennssiioonn (std::shared_ptr ext); │ │ │ │ │ void aadddd__eexxtteennssiioonn (std::function( │ │ │ │ │ torrent_handle const&, client_data_t)> ext); │ │ │ │ │ -void aadddd__eexxtteennssiioonn (std::shared_ptr ext); │ │ │ │ │ This function adds an extension to this _s_e_s_s_i_o_n. The argument is a function │ │ │ │ │ object that is called with a torrent_handle and which should return a std:: │ │ │ │ │ shared_ptr. To write custom plugins, see _l_i_b_t_o_r_r_e_n_t_ _p_l_u_g_i_n_s. │ │ │ │ │ For the typical bittorrent client all of these extensions should be added. The │ │ │ │ │ main plugins implemented in libtorrent are: │ │ │ │ │ uTorrent metadata │ │ │ │ │ Allows peers to download the metadata (.torrent files) from the swarm │ │ │ │ │ @@ -610,18 +610,18 @@ │ │ │ │ │ ********** sseett__ppoorrtt__ffiilltteerr(()) ********** │ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f); │ │ │ │ │ apply _p_o_r_t___f_i_l_t_e_r f to incoming and outgoing peers. a port filter will reject │ │ │ │ │ making outgoing peer connections to certain remote ports. The main intention is │ │ │ │ │ to be able to avoid triggering certain anti-virus software by connecting to │ │ │ │ │ SMTP, FTP ports. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** iiss__lliisstteenniinngg(()) lliisstteenn__ppoorrtt(()) ssssll__lliisstteenn__ppoorrtt(()) ********** │ │ │ │ │ +********** lliisstteenn__ppoorrtt(()) ssssll__lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) ********** │ │ │ │ │ bool iiss__lliisstteenniinngg () const; │ │ │ │ │ -unsigned short ssssll__lliisstteenn__ppoorrtt () const; │ │ │ │ │ unsigned short lliisstteenn__ppoorrtt () 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(()) ********** │ │ │ │ │ @@ -647,17 +647,17 @@ │ │ │ │ │ in the IP range mapping. Only the set bits matter; no peer class will be │ │ │ │ │ removed from a peer as a result of this call, peer classes are only added. │ │ │ │ │ The peer_class argument cannot be greater than 31. The bitmasks representing │ │ │ │ │ peer classes in the peer_class_filter are 32 bits. │ │ │ │ │ The get_peer_class_filter() function returns the current filter. │ │ │ │ │ For more information, see _p_e_e_r_ _c_l_a_s_s_e_s. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) ********** │ │ │ │ │ -peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const; │ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) ********** │ │ │ │ │ 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 │ │ │ │ │ @@ -685,15 +685,15 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss(()) sseett__ppeeeerr__ccllaassss(()) ********** │ │ │ │ │ void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci); │ │ │ │ │ peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const; │ │ │ │ │ These functions queries information from a peer class and updates the │ │ │ │ │ configuration of a peer class, respectively. │ │ │ │ │ cid must refer to an existing peer class. If it does not, the return value of │ │ │ │ │ get_peer_class() is undefined. │ │ │ │ │ set_peer_class() sets all the information in the _p_e_e_r___c_l_a_s_s___i_n_f_o object in the │ │ │ │ │ @@ -726,22 +726,22 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ +settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&); │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack const&); │ │ │ │ │ -settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ Applies the settings specified by the _s_e_t_t_i_n_g_s___p_a_c_k s. This is an asynchronous │ │ │ │ │ operation that will return immediately and actually apply the settings to the │ │ │ │ │ main thread of libtorrent some time later. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ppoopp__aalleerrttss(()) sseett__aalleerrtt__nnoottiiffyy(()) wwaaiitt__ffoorr__aalleerrtt(()) ********** │ │ │ │ │ +********** sseett__aalleerrtt__nnoottiiffyy(()) wwaaiitt__ffoorr__aalleerrtt(()) ppoopp__aalleerrttss(()) ********** │ │ │ │ │ alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts); │ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun); │ │ │ │ │ Alerts is the main mechanism for libtorrent to report errors and events. │ │ │ │ │ pop_alerts fills in the vector passed to it with pointers to new alerts. The │ │ │ │ │ _s_e_s_s_i_o_n still owns these alerts and they will stay valid until the next time │ │ │ │ │ pop_alerts is called. You may not delete the _a_l_e_r_t objects. │ │ │ │ │ @@ -840,24 +840,24 @@ │ │ │ │ │ protocols used by _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ reopen_map_ports │ │ │ │ │ This option indicates if the ports are mapped using natpmp and upnp. If │ │ │ │ │ mapping was already made, they are deleted and added again. This only │ │ │ │ │ works if natpmp and/or upnp are configured to be enable. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -************ wwrriittee__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) rreeaadd__sseessssiioonn__ppaarraammss(()) │ │ │ │ │ +************ wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) wwrriittee__sseessssiioonn__ppaarraammss(()) rreeaadd__sseessssiioonn__ppaarraammss(()) │ │ │ │ │ ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p" │ │ │ │ │ -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 │ │ │ │ │ +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()); │ │ │ │ │ -session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf │ │ │ │ │ +std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (session_params const& sp │ │ │ │ │ + , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ +entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp │ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ These functions serialize and de-serialize a session_params object to and from │ │ │ │ │ bencoded form. The _s_e_s_s_i_o_n___p_a_r_a_m_s object is used to initialize a new _s_e_s_s_i_o_n │ │ │ │ │ using the state from a previous one (or by programmatically configure the │ │ │ │ │ _s_e_s_s_i_o_n up-front). The flags parameter can be used to only save and load │ │ │ │ │ certain aspects of the session's state. The _buf suffix indicates the function │ │ │ │ │ operates on buffer rather than the bencoded structure. The torrents in a │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Settings.html │ │ │ │ @@ -33,30 +33,30 @@ │ │ │ │

    Table of contents

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

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

    │ │ │ │

    The settings_pack object is a collection of settings updates that are applied │ │ │ │ @@ -4562,23 +4562,23 @@ │ │ │ │ i2p_port).

    │ │ │ │ 
    │ │ │ │  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_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_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);
│ │ │ │ -   int get_int (int name) const override;
│ │ │ │     bool get_bool (int name) const override;
│ │ │ │ +   int get_int (int name) const override;
│ │ │ │     std::string const& get_str (int name) const override;
│ │ │ │     void for_each (Fun&& f) const;
│ │ │ │  
│ │ │ │     enum type_bases
│ │ │ │     {
│ │ │ │        string_type_base,
│ │ │ │        int_type_base,
│ │ │ │ @@ -4654,18 +4654,18 @@
│ │ │ │  };
│ │ │ │
    │ │ │ │ │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │

    set_bool() set_str() set_int()

    │ │ │ │ 
    │ │ │ │ -void set_str (int name, std::string 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_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()

    │ │ │ │ @@ -4686,21 +4686,21 @@ │ │ │ │
    │ │ │ │

    clear()

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

    clear a specific setting from the pack

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

    get_str() get_bool() get_int()

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

    get_str() get_int() get_bool()

    │ │ │ │ 
    │ │ │ │ -int get_int (int name) const override;
│ │ │ │  bool get_bool (int name) const override;
│ │ │ │ +int get_int (int name) const override;
│ │ │ │  std::string const& get_str (int name) const override;
│ │ │ │
    │ │ │ │

    queries the current configuration option from the settings_pack. │ │ │ │ name is one of the enumeration values from string_types, int_types │ │ │ │ or bool_types. The enum value must match the type of the get_* │ │ │ │ function. If the specified setting field has not been set, the default │ │ │ │ value is returned.

    │ │ │ │ @@ -5118,22 +5118,22 @@ │ │ │ │ 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]
    │ │ │ │ -
    │ │ │ │ -

    min_memory_usage() high_performance_seed()

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

    high_performance_seed() min_memory_usage()

    │ │ │ │

    Declared in "libtorrent/session.hpp"

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

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

    │ │ │ │

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

    │ │ │ │

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

    │ │ │ │

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

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

    setting_by_name() name_for_setting()

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

    name_for_setting() setting_by_name()

    │ │ │ │

    Declared in "libtorrent/settings_pack.hpp"

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

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

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -4,28 +4,28 @@ │ │ │ │ │ _h_o_m_e │ │ │ │ │ Table of contents │ │ │ │ │ * _s_e_t_t_i_n_g_s___p_a_c_k │ │ │ │ │ o _s_e_t___b_o_o_l_(_)_ _s_e_t___s_t_r_(_)_ _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___s_t_r_(_)_ _g_e_t___b_o_o_l_(_)_ _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_(_) │ │ │ │ │ - * _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_(_) │ │ │ │ │ + * _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_(_) │ │ │ │ │ + * _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)_ _s_e_t_t_i_n_g___b_y___n_a_m_e_(_) │ │ │ │ │ * _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_) │ │ │ │ │ You have some control over _s_e_s_s_i_o_n configuration through the session:: │ │ │ │ │ apply_settings() member function. To change one or more configuration options, │ │ │ │ │ create a _s_e_t_t_i_n_g_s___p_a_c_k object and fill it with the settings to be set and pass │ │ │ │ │ it in to session::apply_settings(). │ │ │ │ │ The _s_e_t_t_i_n_g_s___p_a_c_k object is a collection of settings updates that are applied │ │ │ │ │ to the _s_e_s_s_i_o_n when passed to session::apply_settings(). It's empty when │ │ │ │ │ @@ -1420,23 +1420,23 @@ │ │ │ │ │ next time the SAM connection is re-established (by restarting or changing │ │ │ │ │ i2p_hostname or i2p_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__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__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); │ │ │ │ │ - int ggeett__iinntt (int name) const override; │ │ │ │ │ bool ggeett__bbooooll (int name) const override; │ │ │ │ │ + int ggeett__iinntt (int name) const override; │ │ │ │ │ std::string const& ggeett__ssttrr (int name) const override; │ │ │ │ │ void ffoorr__eeaacchh (Fun&& f) const; │ │ │ │ │ │ │ │ │ │ enum type_bases │ │ │ │ │ { │ │ │ │ │ string_type_base, │ │ │ │ │ int_type_base, │ │ │ │ │ @@ -1508,18 +1508,18 @@ │ │ │ │ │ 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; │ │ │ │ │ -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__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 │ │ │ │ │ @@ -1530,17 +1530,17 @@ │ │ │ │ │ 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__ssttrr(()) ggeett__bbooooll(()) ggeett__iinntt(()) ********** │ │ │ │ │ -int ggeett__iinntt (int name) const override; │ │ │ │ │ +********** ggeett__ssttrr(()) ggeett__iinntt(()) ggeett__bbooooll(()) ********** │ │ │ │ │ bool ggeett__bbooooll (int name) const override; │ │ │ │ │ +int ggeett__iinntt (int name) const override; │ │ │ │ │ std::string const& ggeett__ssttrr (int name) const override; │ │ │ │ │ queries the current configuration option from the _s_e_t_t_i_n_g_s___p_a_c_k. name is one of │ │ │ │ │ the enumeration values from string_types, int_types or bool_types. The enum │ │ │ │ │ value must match the type of the get_* function. If the specified setting field │ │ │ │ │ has not been set, the default value is returned. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eennuumm ttyyppee__bbaasseess ********** │ │ │ │ │ @@ -1693,18 +1693,18 @@ │ │ │ │ │ |_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] │ │ │ │ │ -************ mmiinn__mmeemmoorryy__uussaaggee(()) hhiigghh__ppeerrffoorrmmaannccee__sseeeedd(()) ************ │ │ │ │ │ +************ hhiigghh__ppeerrffoorrmmaannccee__sseeeedd(()) mmiinn__mmeemmoorryy__uussaaggee(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n_._h_p_p" │ │ │ │ │ -settings_pack mmiinn__mmeemmoorryy__uussaaggee (); │ │ │ │ │ settings_pack hhiigghh__ppeerrffoorrmmaannccee__sseeeedd (); │ │ │ │ │ +settings_pack mmiinn__mmeemmoorryy__uussaaggee (); │ │ │ │ │ The default values of the _s_e_s_s_i_o_n settings are set for a regular bittorrent │ │ │ │ │ client running on a desktop system. There are functions that can set the │ │ │ │ │ _s_e_s_s_i_o_n settings to pre set settings for other environments. These can be used │ │ │ │ │ for the basis, and should be tweaked to fit your needs better. │ │ │ │ │ min_memory_usage returns settings that will use the minimal amount of RAM, at │ │ │ │ │ the potential expense of upload and download performance. It adjusts the socket │ │ │ │ │ buffer sizes, disables the disk cache, lowers the send buffer watermarks so │ │ │ │ │ @@ -1717,15 +1717,15 @@ │ │ │ │ │ This configuration is intended to be the starting point for embedded devices. │ │ │ │ │ It will significantly reduce memory usage. │ │ │ │ │ high_performance_seed returns settings optimized for a seed box, serving many │ │ │ │ │ peers and that doesn't do any downloading. It has a 128 MB disk cache and has a │ │ │ │ │ limit of 400 files in its file pool. It support fast upload rates by allowing │ │ │ │ │ large send buffers. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -************ sseettttiinngg__bbyy__nnaammee(()) nnaammee__ffoorr__sseettttiinngg(()) ************ │ │ │ │ │ +************ nnaammee__ffoorr__sseettttiinngg(()) sseettttiinngg__bbyy__nnaammee(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p" │ │ │ │ │ char const* nnaammee__ffoorr__sseettttiinngg (int s); │ │ │ │ │ int sseettttiinngg__bbyy__nnaammee (string_view name); │ │ │ │ │ converts a setting integer (from the enums string_types, int_types or │ │ │ │ │ bool_types) to a string, and vice versa. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ddeeffaauulltt__sseettttiinnggss(()) ************ │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Stats.html │ │ │ │┄ Ordering differences only │ │ │ │ @@ -45,28 +45,28 @@ │ │ │ │ [report issue]
    │ │ │ │

    counters

    │ │ │ │

    Declared in "libtorrent/performance_counters.hpp"

    │ │ │ │ 
    │ │ │ │  struct counters
│ │ │ │  {
│ │ │ │     counters () ;
│ │ │ │ -   counters (counters const&) ;
│ │ │ │     counters& operator= (counters const&) & ;
│ │ │ │ -   std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ +   counters (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) ;
│ │ │ │  };
│ │ │ │
    │ │ │ │ │ │ │ │ [report issue]
    │ │ │ │

    inc_stats_counter() operator[]()

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

    returns the new value

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

    stats_metric

    │ │ │ │

    Declared in "libtorrent/session_stats.hpp"

    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -11,25 +11,25 @@ │ │ │ │ │ * _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 () ; │ │ │ │ │ - ccoouunntteerrss (counters const&) ; │ │ │ │ │ counters& ooppeerraattoorr== (counters const&) & ; │ │ │ │ │ - std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ; │ │ │ │ │ + ccoouunntteerrss (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) ; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** iinncc__ssttaattss__ccoouunntteerr(()) ooppeerraattoorr[[]](()) ********** │ │ │ │ │ -std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ; │ │ │ │ │ std::int64_t ooppeerraattoorr[[]] (int i) const ; │ │ │ │ │ +std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ; │ │ │ │ │ returns the new value │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ssttaattss__mmeettrriicc ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___s_t_a_t_s_._h_p_p" │ │ │ │ │ describes one statistics metric from the _s_e_s_s_i_o_n. For more information, see the │ │ │ │ │ _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section. │ │ │ │ │ struct stats_metric │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Storage.html │ │ │ │ @@ -32,15 +32,15 @@ │ │ │ │
    │ │ │ │

    Table of contents

    │ │ │ │
      │ │ │ │
    • file_slice
      • │ │ │ │
    • file_storage │ │ │ │
      • │ │ │ │
    • storage_params
      • │ │ │ │ @@ -117,76 +117,76 @@ │ │ │ │ size. Everything necessary to interpret a regular bittorrent storage │ │ │ │ file structure.

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

    add_file_borrow() add_file()

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

    add_file() add_file_borrow()

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

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

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

    │ │ │ │ │ │ │ │ [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;
│ │ │ │ @@ -438,37 +438,37 @@
│ │ │ │  
    
│ │ │ │  
    canonicalize()
    
│ │ │ │  
    │ │ │ │  void canonicalize ();
│ │ │ │  
    
│ │ │ │  
    arrange files and padding to match the canonical form required
│ │ │ │  by BEP 52
    
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │  
│ │ │ │ +
│ │ │ │ +
│ │ │ │  
│ │ │ │ +
│ │ │ │ +
│ │ │ │  
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
│ │ │ │ +
│ │ │ │ -
    
│ │ │ │ -
    file_num_blocks() file_num_pieces() file_piece_range()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    file_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;
│ │ │ │  
    
│ │ │ │  
    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_piece_node (file_index_t index) const;
│ │ │ │  int file_first_block_node (file_index_t index) const;
│ │ │ │  
    
│ │ │ │  
    index of first piece node in the merkle tree
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ @@ -547,21 +547,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_piece (piece_index_t piece) 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;
│ │ │ │  
    
│ │ │ │  
    returns the index of the file at the given offset in the torrent
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    file_index_for_root()
    
│ │ │ │  
    │ │ │ │  file_index_t file_index_for_root (sha256_hash const& root_hash) const;
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │  VVeerrssiioonn:: 2.0.10
│ │ │ │ │  _h_o_m_e
│ │ │ │ │  Table of contents
│ │ │ │ │      * _f_i_l_e___s_l_i_c_e
│ │ │ │ │      * _f_i_l_e___s_t_o_r_a_g_e
│ │ │ │ │            o _i_s___v_a_l_i_d_(_)
│ │ │ │ │            o _r_e_s_e_r_v_e_(_)
│ │ │ │ │ -          o _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)_ _a_d_d___f_i_l_e_(_)
│ │ │ │ │ +          o _a_d_d___f_i_l_e_(_)_ _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)
│ │ │ │ │            o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │            o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │            o _m_a_p___f_i_l_e_(_)
│ │ │ │ │            o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │            o _e_n_d___f_i_l_e_(_)
│ │ │ │ │            o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ │            o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ @@ -23,23 +23,23 @@
│ │ │ │ │            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_w_a_p_(_)
│ │ │ │ │            o _c_a_n_o_n_i_c_a_l_i_z_e_(_)
│ │ │ │ │ -          o _s_y_m_l_i_n_k_(_)_ _f_i_l_e___p_a_t_h_(_)_ _h_a_s_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_(_)_ _r_o_o_t_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _p_a_d___f_i_l_e___a_t_(_)
│ │ │ │ │ -          o _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ -          o _f_i_l_e___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 _m_t_i_m_e_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _r_o_o_t___p_t_r_(_)_ _f_i_l_e___p_a_t_h_(_)_ _s_y_m_l_i_n_k
│ │ │ │ │ +            _(_)_ _f_i_l_e___s_i_z_e_(_)_ _r_o_o_t_(_)_ _f_i_l_e___n_a_m_e_(_)_ _h_a_s_h_(_)
│ │ │ │ │ +          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___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_(_)
│ │ │ │ │ @@ -77,80 +77,80 @@
│ │ │ │ │  Declared in "_l_i_b_t_o_r_r_e_n_t_/_f_i_l_e___s_t_o_r_a_g_e_._h_p_p"
│ │ │ │ │  The file_storage class represents a file list and the piece size. Everything
│ │ │ │ │  necessary to interpret a regular bittorrent storage file structure.
│ │ │ │ │  class file_storage
│ │ │ │ │  {
│ │ │ │ │     bool iiss__vvaalliidd () const;
│ │ │ │ │     void rreesseerrvvee (int num_files);
│ │ │ │ │ -   void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ +   void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ -   void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ +   void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t
│ │ │ │ │ +file_size
│ │ │ │ │ +      , file_flags_t file_flags = {}
│ │ │ │ │ +      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │ │ +   void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │     void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}
│ │ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ -   void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t
│ │ │ │ │ -file_size
│ │ │ │ │ -      , file_flags_t file_flags = {}
│ │ │ │ │ -      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │ │     void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │     std::vector mmaapp__bblloocckk (piece_index_t piece, std::int64_t offset
│ │ │ │ │        , std::int64_t size) const;
│ │ │ │ │     peer_request mmaapp__ffiillee (file_index_t file, std::int64_t offset, int size)
│ │ │ │ │  const;
│ │ │ │ │     int nnuumm__ffiilleess () const noexcept;
│ │ │ │ │     file_index_t eenndd__ffiillee () const noexcept;
│ │ │ │ │     index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │     std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ -   int nnuumm__ppiieecceess () const;
│ │ │ │ │     void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ +   int nnuumm__ppiieecceess () const;
│ │ │ │ │     piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │     piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │     index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │     void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │     int ppiieeccee__lleennggtthh () const;
│ │ │ │ │     int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │     int ppiieeccee__ssiizzee22 (piece_index_t index) const;
│ │ │ │ │     int bblloocckkss__iinn__ppiieeccee22 (piece_index_t index) const;
│ │ │ │ │     int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │     std::string const& nnaammee () const;
│ │ │ │ │     void sseett__nnaammee (std::string const& n);
│ │ │ │ │     void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │     void ccaannoonniiccaalliizzee ();
│ │ │ │ │ -   sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ -   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ -   std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ -"") const;
│ │ │ │ │ -   bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │     std::time_t mmttiimmee (file_index_t index) 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;
│ │ │ │ │     string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +   sha1_hash hhaasshh (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;
│ │ │ │ │ +   char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +   sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +   std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +   bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │     int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │     int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │     index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │     int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │     int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │     std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const&
│ │ │ │ │  save_path) const;
│ │ │ │ │     void aallll__ppaatthh__hhaasshheess (std::unordered_set& table) const;
│ │ │ │ │     file_flags_t ffiillee__ffllaaggss (file_index_t index) const;
│ │ │ │ │     bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │ -   file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) 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__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │     piece_index_t ppiieeccee__iinnddeexx__aatt__ffiillee (file_index_t f) const;
│ │ │ │ │     void ssaanniittiizzee__ssyymmlliinnkkss ();
│ │ │ │ │     bool vv22 () const;
│ │ │ │ │  
│ │ │ │ │     static constexpr file_flags_t ffllaagg__ppaadd__ffiillee  = 0_bit;
│ │ │ │ │     static constexpr file_flags_t ffllaagg__hhiiddddeenn  = 1_bit;
│ │ │ │ │ @@ -166,33 +166,33 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** rreesseerrvvee(()) **********
│ │ │ │ │  void rreesseerrvvee (int num_files);
│ │ │ │ │  allocates space for num_files in the internal file list. This can be used to
│ │ │ │ │  avoid reallocating the internal file list when the number of files to be added
│ │ │ │ │  is known up-front.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__ffiillee__bboorrrrooww(()) aadddd__ffiillee(()) **********
│ │ │ │ │ -void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ +********** aadddd__ffiillee(()) aadddd__ffiillee__bboorrrrooww(()) **********
│ │ │ │ │ +void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ -void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ +void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ │ +      , file_flags_t file_flags = {}
│ │ │ │ │ +      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ +      , char const* root_hash = nullptr);
│ │ │ │ │ +void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │        , std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │        , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │  void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │        , file_flags_t file_flags = {}
│ │ │ │ │        , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │        , char const* root_hash = nullptr);
│ │ │ │ │ -void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ │ -      , file_flags_t file_flags = {}
│ │ │ │ │ -      , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ -      , char const* root_hash = nullptr);
│ │ │ │ │  Adds a file to the file storage. The add_file_borrow version expects that
│ │ │ │ │  filename is the file name (without a path) of the file that's being added. This
│ │ │ │ │  memory is bboorrrroowweedd, i.e. it is the caller's responsibility to make sure it
│ │ │ │ │  stays valid throughout the lifetime of this _f_i_l_e___s_t_o_r_a_g_e object or any copy of
│ │ │ │ │  it. The same thing applies to filehash, which is an optional pointer to a 20
│ │ │ │ │  byte binary SHA-1 hash of the file.
│ │ │ │ │  if filename is empty, the filename from path is used and not borrowed.
│ │ │ │ │ @@ -262,16 +262,16 @@
│ │ │ │ │  _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;
│ │ │ │ │  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(()) **********
│ │ │ │ │ @@ -323,27 +323,27 @@
│ │ │ │ │  void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │  swap all content of tthhiiss with ttii.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ccaannoonniiccaalliizzee(()) **********
│ │ │ │ │  void ccaannoonniiccaalliizzee ();
│ │ │ │ │  arrange files and padding to match the canonical form required by BEP 52
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssyymmlliinnkk(()) ffiillee__ppaatthh(()) hhaasshh(()) ffiillee__nnaammee(()) mmttiimmee(()) rroooott__ppttrr(()) ffiillee__ssiizzee(())
│ │ │ │ │ -rroooott(()) ffiillee__ooffffsseett(()) ppaadd__ffiillee__aatt(()) **********
│ │ │ │ │ -sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ -std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ -const;
│ │ │ │ │ -bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ +********** mmttiimmee(()) ppaadd__ffiillee__aatt(()) ffiillee__ooffffsseett(()) rroooott__ppttrr(()) ffiillee__ppaatthh(()) ssyymmlliinnkk(())
│ │ │ │ │ +ffiillee__ssiizzee(()) rroooott(()) ffiillee__nnaammee(()) hhaasshh(()) **********
│ │ │ │ │  std::time_t mmttiimmee (file_index_t index) 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;
│ │ │ │ │  string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +sha1_hash hhaasshh (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;
│ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │  These functions are used to query attributes of files at a given index.
│ │ │ │ │  The hash() is a SHA-1 hash of the file, or 0 if none was provided in the
│ │ │ │ │  torrent file. This can potentially be used to join a bittorrent network with
│ │ │ │ │  other file sharing networks.
│ │ │ │ │  root() returns the SHA-256 merkle tree root of the specified file, in case this
│ │ │ │ │  is a v2 torrent. Otherwise returns zeros. root_ptr() returns a pointer to the
│ │ │ │ │  SHA-256 merkle tree root hash for the specified file. The pointer points into
│ │ │ │ │ @@ -356,24 +356,24 @@
│ │ │ │ │  file_size() returns the size of a file.
│ │ │ │ │  pad_file_at() returns true if the file at the given index is a pad-file.
│ │ │ │ │  file_name() returns jjuusstt the name of the file, whereas file_path() returns the
│ │ │ │ │  path (inside the torrent file) with the filename appended.
│ │ │ │ │  file_offset() returns the byte offset within the torrent file where this file
│ │ │ │ │  starts. It can be used to map the file to a piece index (given the piece size).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__nnuumm__bblloocckkss(()) ffiillee__nnuumm__ppiieecceess(()) ffiillee__ppiieeccee__rraannggee(()) **********
│ │ │ │ │ +********** ffiillee__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;
│ │ │ │ │  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__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │  int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │  index of first piece node in the merkle tree
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__ppaatthh__hhaasshh(()) **********
│ │ │ │ │  std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const& save_path)
│ │ │ │ │  const;
│ │ │ │ │ @@ -392,17 +392,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__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ +********** ffiillee__iinnddeexx__aatt__ppiieeccee(()) ffiillee__iinnddeexx__aatt__ooffffsseett(()) **********
│ │ │ │ │  file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │ +file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │  returns the index of the file at the given offset in the torrent
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiillee__iinnddeexx__ffoorr__rroooott(()) **********
│ │ │ │ │  file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │  finds the file with the given root hash and returns its index if there is no
│ │ │ │ │  file with the root hash, file_index_t{-1} is returned
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Handle.html
│ │ │ │ @@ -29,62 +29,62 @@
│ │ │ │  
│ │ │ │  
│ │ │ │  
    home
    
│ │ │ │  
    
│ │ │ │  
    Table of contents
    
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    set_peer() peer()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    peer() set_peer()
    
│ │ │ │  
    │ │ │ │  tcp::endpoint peer () const;
│ │ │ │  void set_peer (tcp::endpoint const& ep);
│ │ │ │  
    
│ │ │ │  
    The peer is the ip address of the peer this block was downloaded from.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │ @@ -263,110 +263,110 @@
│ │ │ │  handle will remain valid between two calls.
    
│ │ │ │  
    
│ │ │ │  
    │ │ │ │  struct torrent_handle
│ │ │ │  {
│ │ │ │     friend std::size_t hash_value (torrent_handle const& th);
│ │ │ │     torrent_handle () noexcept = default;
│ │ │ │ -   void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │     void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ +   void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │     void read_piece (piece_index_t piece) const;
│ │ │ │     bool have_piece (piece_index_t piece) const;
│ │ │ │ -   void post_peer_info () const;
│ │ │ │     void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ -   torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +   void post_peer_info () const;
│ │ │ │     void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ -   std::vector<partial_piece_info> get_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 post_download_queue () const;
│ │ │ │ -   void clear_piece_deadlines () const;
│ │ │ │ +   std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │     void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ +   void clear_piece_deadlines () const;
│ │ │ │     void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ -   std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ -   void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │     void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ +   void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ +   std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │     std::vector<open_file_state> file_status () const;
│ │ │ │     void clear_error () const;
│ │ │ │     void post_trackers () const;
│ │ │ │ -   void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │     void add_tracker (announce_entry const&) const;
│ │ │ │     std::vector<announce_entry> trackers () const;
│ │ │ │ +   void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │     void add_url_seed (std::string const& url) const;
│ │ │ │ -   void remove_url_seed (std::string const& url) const;
│ │ │ │     std::set<std::string> url_seeds () const;
│ │ │ │ -   std::set<std::string> http_seeds () const;
│ │ │ │ -   void add_http_seed (std::string const& url) const;
│ │ │ │ +   void remove_url_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 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, torrent_flags_t mask) const;
│ │ │ │ -   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 (resume_data_flags_t flags) const;
│ │ │ │     bool need_save_resume_data () const;
│ │ │ │ -   void queue_position_bottom () const;
│ │ │ │ +   bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ +   void queue_position_up () const;
│ │ │ │     queue_position_t queue_position () const;
│ │ │ │ -   void queue_position_down () const;
│ │ │ │     void queue_position_top () const;
│ │ │ │ -   void queue_position_up () const;
│ │ │ │ +   void queue_position_bottom () const;
│ │ │ │ +   void queue_position_down () const;
│ │ │ │     void queue_position_set (queue_position_t p) const;
│ │ │ │     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 post_piece_availability () const;
│ │ │ │     void piece_availability (std::vector<int>& avail) const;
│ │ │ │ -   void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ +   void post_piece_availability () 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_piece_priorities () const;
│ │ │ │ +   void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │     void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ +   std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │     std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ +   void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │     void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │     download_priority_t file_priority (file_index_t index) const;
│ │ │ │ -   void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │     void force_dht_announce () const;
│ │ │ │ -   void force_lsd_announce () const;
│ │ │ │     void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ +   void force_lsd_announce () const;
│ │ │ │     void scrape_tracker (int idx = -1) const;
│ │ │ │ +   int download_limit () const;
│ │ │ │     void set_download_limit (int limit) const;
│ │ │ │     int upload_limit () const;
│ │ │ │ -   int download_limit () const;
│ │ │ │     void set_upload_limit (int limit) const;
│ │ │ │     void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │        , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │     void clear_peers ();
│ │ │ │     void set_max_uploads (int max_uploads) const;
│ │ │ │     int max_uploads () const;
│ │ │ │     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;
│ │ │ │ +   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;
│ │ │ │ -   bool operator!= (const torrent_handle& h) const;
│ │ │ │     std::uint32_t id () const;
│ │ │ │     std::shared_ptr<torrent> native_handle () const;
│ │ │ │     client_data_t userdata () const;
│ │ │ │     bool in_session () const;
│ │ │ │  
│ │ │ │     static constexpr add_piece_flags_t overwrite_existing  = 0_bit;
│ │ │ │     static constexpr status_flags_t query_distributed_copies  = 0_bit;
│ │ │ │ @@ -398,16 +398,16 @@
│ │ │ │  
    
│ │ │ │  
    constructs a torrent handle that does not refer to a torrent.
│ │ │ │  i.e. is_valid() will return false.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    add_piece()
    
│ │ │ │  
    │ │ │ │ -void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │  void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ +void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │  
    
│ │ │ │  
    This function will write data to the storage as piece piece,
│ │ │ │  as if it had been downloaded from a peer.
    
│ │ │ │  
    By default, data that's already been downloaded is not overwritten by
│ │ │ │  this buffer. If you trust this data to be correct (and pass the piece
│ │ │ │  hash check) you may pass the overwrite_existing flag. This will
│ │ │ │  instruct libtorrent to overwrite any data that may already have been
│ │ │ │ @@ -449,16 +449,16 @@
│ │ │ │  
    Returns true if this piece has been completely downloaded and written
│ │ │ │  to disk, and false otherwise.
    
│ │ │ │  
│ │ │ │  [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
│ │ │ │ @@ -467,16 +467,16 @@
│ │ │ │  the vector contains information about that particular peer. See
│ │ │ │  peer_info.
    
│ │ │ │  
│ │ │ │  [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
│ │ │ │ @@ -486,37 +486,37 @@
│ │ │ │  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]
    
│ │ │ │  
    
│ │ │ │  
    set_piece_deadline() clear_piece_deadlines() reset_piece_deadline()
    
│ │ │ │  
    │ │ │ │ -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;
│ │ │ │  void reset_piece_deadline (piece_index_t index) 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
│ │ │ │ @@ -533,17 +533,17 @@
│ │ │ │  
    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()
    
│ │ │ │  
    │ │ │ │ -std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ -void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │  void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ +void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ +std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │  
    
│ │ │ │  
    This function fills in the supplied vector, or returns a vector, with
│ │ │ │  the number of bytes downloaded of each file in this torrent. The
│ │ │ │  progress values are ordered the same as the files in the
│ │ │ │  torrent_info.
    
│ │ │ │  
    This operation is not very cheap. Its complexity is O(n + mj).
│ │ │ │  Where n is the number of files, m is the number of currently
│ │ │ │ @@ -572,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() replace_trackers() add_tracker() post_trackers()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    replace_trackers() trackers() add_tracker() post_trackers()
    
│ │ │ │  
    │ │ │ │  void post_trackers () const;
│ │ │ │ -void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │  void add_tracker (announce_entry const&) const;
│ │ │ │  std::vector<announce_entry> trackers () const;
│ │ │ │ +void replace_trackers (std::vector<announce_entry> const&) 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,42 +602,42 @@
│ │ │ │  
    add_tracker() will look if the specified tracker is already in the
│ │ │ │  set. If it is, it doesn't do anything. If it's not in the current set
│ │ │ │  of trackers, it will insert it in the tier specified in the
│ │ │ │  announce_entry.
    
│ │ │ │  
    The updated set of trackers will be saved in the resume data, and when
│ │ │ │  a torrent is started with resume data, the trackers from the resume
│ │ │ │  data will replace the original ones.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    remove_url_seed() url_seeds() add_url_seed()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    url_seeds() add_url_seed() remove_url_seed()
    
│ │ │ │  
    │ │ │ │  void add_url_seed (std::string const& url) const;
│ │ │ │ -void remove_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]
    
│ │ │ │ -
    
│ │ │ │ -
    add_http_seed() remove_http_seed() http_seeds()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    remove_http_seed() add_http_seed() http_seeds()
    
│ │ │ │  
    │ │ │ │ -std::set<std::string> http_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;
│ │ │ │  
    
│ │ │ │  
    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()
    
│ │ │ │ @@ -679,21 +679,21 @@
│ │ │ │  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]
    
│ │ │ │ -
    
│ │ │ │ -
    resume() pause()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    pause() resume()
    
│ │ │ │  
    │ │ │ │ -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.
    
│ │ │ │ @@ -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]
    
│ │ │ │ -
    
│ │ │ │ -
    unset_flags() set_flags() flags()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    set_flags() unset_flags() flags()
    
│ │ │ │  
    │ │ │ │ -void set_flags (torrent_flags_t flags) const;
│ │ │ │ +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;
│ │ │ │ -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 (resume_data_flags_t flags) const;
│ │ │ │  bool need_save_resume_data () const;
│ │ │ │ +bool need_save_resume_data (resume_data_flags_t flags) 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() queue_position_top() queue_position_bottom() queue_position_down() queue_position_up()
    
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    queue_position_top() queue_position_up() queue_position() queue_position_bottom() queue_position_down()
    
│ │ │ │  
    │ │ │ │ -void queue_position_bottom () const;
│ │ │ │ +void queue_position_up () const;
│ │ │ │  queue_position_t queue_position () const;
│ │ │ │ -void queue_position_down () const;
│ │ │ │  void queue_position_top () const;
│ │ │ │ -void queue_position_up () const;
│ │ │ │ +void queue_position_bottom () 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
│ │ │ │ @@ -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
│ │ │ │ @@ -997,42 +997,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]
    
│ │ │ │ -
    
│ │ │ │ -
    piece_availability() post_piece_availability()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    post_piece_availability() 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]
    
│ │ │ │ +
    
│ │ │ │ +
    prioritize_pieces() get_piece_priorities() piece_priority()
    
│ │ │ │  
    │ │ │ │ -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;
│ │ │ │ -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 piece_priority (piece_index_t index, download_priority_t priority) 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
│ │ │ │ @@ -1055,23 +1055,23 @@
│ │ │ │  not allowed.
    
│ │ │ │  
    get_piece_priorities returns a vector with one element for each piece
│ │ │ │  in the torrent. Each element is the current priority of that piece.
    
│ │ │ │  
    It's possible to cancel the effect of file priorities by setting the
│ │ │ │  priorities for the affected pieces. Care has to be taken when mixing
│ │ │ │  usage of file- and piece priorities.
    
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    prioritize_files() file_priority() get_file_priorities()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    prioritize_files() get_file_priorities() file_priority()
    
│ │ │ │  
    │ │ │ │  std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ +void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │  void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │  download_priority_t file_priority (file_index_t index) const;
│ │ │ │ -void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │  
    
│ │ │ │  
    index must be in the range [0, number_of_files).
    
│ │ │ │  
    file_priority() queries or sets the priority of file index.
    
│ │ │ │  
    prioritize_files() takes a vector that has at as many elements as
│ │ │ │  there are files in the torrent. Each entry is the priority of that
│ │ │ │  file. The function sets the priorities of all the pieces in the
│ │ │ │  torrent based on the vector.
    
│ │ │ │ @@ -1094,23 +1094,23 @@
│ │ │ │  file_prio_alert.
    
│ │ │ │  
    When combining file- and piece priorities, the resume file will record
│ │ │ │  both. When loading the resume data, the file priorities will be applied
│ │ │ │  first, then the piece priorities.
    
│ │ │ │  
    Moving data from a file into the part file is currently not
│ │ │ │  supported. If a file has its priority set to 0 after it has already
│ │ │ │  been created, it will not be moved into the partfile.
    
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
    
│ │ │ │ -
    
│ │ │ │ -
    force_lsd_announce() force_dht_announce() force_reannounce()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    force_dht_announce() force_reannounce() force_lsd_announce()
    
│ │ │ │  
    │ │ │ │  void force_dht_announce () const;
│ │ │ │ -void force_lsd_announce () const;
│ │ │ │  void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ +void force_lsd_announce () const;
│ │ │ │  
    
│ │ │ │  
    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,24 +1134,24 @@
│ │ │ │  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]
    
│ │ │ │ +
    
│ │ │ │ +
    set_download_limit() download_limit() upload_limit() set_upload_limit()
    
│ │ │ │  
    │ │ │ │ +int download_limit () const;
│ │ │ │  void set_download_limit (int limit) const;
│ │ │ │  int upload_limit () const;
│ │ │ │ -int download_limit () const;
│ │ │ │  void set_upload_limit (int limit) const;
│ │ │ │  
    
│ │ │ │  
    set_upload_limit will limit the upload bandwidth used by this
│ │ │ │  particular torrent to the limit you set. It is given as the number of
│ │ │ │  bytes per second the torrent is allowed to upload.
│ │ │ │  set_download_limit works the same way but for download bandwidth
│ │ │ │  instead of upload bandwidth. Note that setting a higher limit on a
│ │ │ │ @@ -1198,18 +1198,18 @@
│ │ │ │
    │ │ │ │

    set_max_uploads() sets the maximum number of peers that's unchoked │ │ │ │ at the same time on this torrent. If you set this to -1, there will be │ │ │ │ no limit. This defaults to infinite. The primary setting controlling │ │ │ │ this is the global unchoke slots limit, set by unchoke_slots_limit in │ │ │ │ settings_pack.

    │ │ │ │

    max_uploads() returns the current settings.

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

    max_connections() set_max_connections()

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

    set_max_connections() max_connections()

    │ │ │ │ 
    │ │ │ │  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 │ │ │ │ @@ -1280,32 +1280,32 @@ │ │ │ │ operation is complete when either a file_renamed_alert or │ │ │ │ file_rename_failed_alert is posted.

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

    info_hash() info_hashes()

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

    │ │ │ │ 
    │ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,61 +1,61 @@
│ │ │ │ │  >
│ │ │ │ │  _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │  VVeerrssiioonn:: 2.0.10
│ │ │ │ │  _h_o_m_e
│ │ │ │ │  Table of contents
│ │ │ │ │      * _b_l_o_c_k___i_n_f_o
│ │ │ │ │ -          o _s_e_t___p_e_e_r_(_)_ _p_e_e_r_(_)
│ │ │ │ │ +          o _p_e_e_r_(_)_ _s_e_t___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 _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 _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 _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 _t_r_a_c_k_e_r_s_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _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_(_)_ _u_r_l___s_e_e_d_s_(_)_ _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 _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ +          o _u_r_l___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)
│ │ │ │ │ +          o _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _a_d_d___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 _u_n_s_e_t___f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)
│ │ │ │ │ +          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 _f_l_u_s_h___c_a_c_h_e_(_)
│ │ │ │ │            o _f_o_r_c_e___r_e_c_h_e_c_k_(_)
│ │ │ │ │            o _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │            o _n_e_e_d___s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ -          o _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_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___d_o_w_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)
│ │ │ │ │ +          o _q_u_e_u_e___p_o_s_i_t_i_o_n___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_(_)
│ │ │ │ │ +            _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)
│ │ │ │ │            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_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_)
│ │ │ │ │ -          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_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_(_)_ _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___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 _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_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_(_)_ _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 _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │            o _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_(_)
│ │ │ │ │ -            _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ +          o _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ +            _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │            o _c_o_n_n_e_c_t___p_e_e_r_(_)
│ │ │ │ │            o _c_l_e_a_r___p_e_e_r_s_(_)
│ │ │ │ │            o _m_a_x___u_p_l_o_a_d_s_(_)_ _s_e_t___m_a_x___u_p_l_o_a_d_s_(_)
│ │ │ │ │ -          o _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │ +          o _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │            o _m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ │            o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │            o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ -          o _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ +          o _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 ************
│ │ │ │ │ @@ -77,15 +77,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]
│ │ │ │ │ -********** sseett__ppeeeerr(()) ppeeeerr(()) **********
│ │ │ │ │ +********** ppeeeerr(()) sseett__ppeeeerr(()) **********
│ │ │ │ │  _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │  void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │  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"
│ │ │ │ │   _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
│ │ │ │ │ @@ -175,120 +175,120 @@
│ │ │ │ │  the handle is no longer referring to a torrent. There is one exception _i_s___v_a_l_i_d
│ │ │ │ │  _(_) will never throw. Since the torrents are processed by a background thread,
│ │ │ │ │  there is no guarantee that a handle will remain valid between two calls.
│ │ │ │ │  struct torrent_handle
│ │ │ │ │  {
│ │ │ │ │     friend std::size_t hhaasshh__vvaalluuee (torrent_handle const& th);
│ │ │ │ │     ttoorrrreenntt__hhaannddllee () noexcept = default;
│ │ │ │ │ -   void aadddd__ppiieeccee (piece_index_t piece, std::vector data,
│ │ │ │ │ -add_piece_flags_t flags = {}) const;
│ │ │ │ │     void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │ +   void aadddd__ppiieeccee (piece_index_t piece, std::vector data,
│ │ │ │ │ +add_piece_flags_t flags = {}) const;
│ │ │ │ │     void rreeaadd__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │     bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ -   void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │     void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ -   torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +   void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │     void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ -   std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ +   torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │     void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │     void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ -   void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ +   std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │     void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │ +   void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │     void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) 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;
│ │ │ │ │ +   void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ +   std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ +const;
│ │ │ │ │     std::vector ffiillee__ssttaattuuss () const;
│ │ │ │ │     void cclleeaarr__eerrrroorr () const;
│ │ │ │ │     void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ -   void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │     void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │     std::vector ttrraacckkeerrss () const;
│ │ │ │ │ +   void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │     void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ -   void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │     std::set uurrll__sseeeeddss () const;
│ │ │ │ │ -   std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ -   void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +   void rreemmoovvee__uurrll__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 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, torrent_flags_t mask) const;
│ │ │ │ │ -   torrent_flags_t ffllaaggss () 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 (resume_data_flags_t flags) const;
│ │ │ │ │     bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │ -   void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +   bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ +   void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │     queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ -   void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ -   void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ +   void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +   void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │     void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ │     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 ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │     void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ -   void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ +   void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │     download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │     void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces)
│ │ │ │ │  const;
│ │ │ │ │ -   std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ +   void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │     void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ │  const;
│ │ │ │ │ +   std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │     std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ +   void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │     void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │     download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ -   void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │     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__llssdd__aannnnoouunnccee () const;
│ │ │ │ │     void ssccrraappee__ttrraacckkeerr (int idx = -1) const;
│ │ │ │ │ +   int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │     void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │     int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ -   int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │     void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │     void ccoonnnneecctt__ppeeeerr (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │ │        , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │ │     void cclleeaarr__ppeeeerrss ();
│ │ │ │ │     void sseett__mmaaxx__uuppllooaaddss (int max_uploads) const;
│ │ │ │ │     int mmaaxx__uuppllooaaddss () const;
│ │ │ │ │     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;
│ │ │ │ │ +   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;
│ │ │ │ │ -   bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │     std::uint32_t iidd () const;
│ │ │ │ │     std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │     client_data_t uusseerrddaattaa () const;
│ │ │ │ │     bool iinn__sseessssiioonn () const;
│ │ │ │ │  
│ │ │ │ │     static constexpr add_piece_flags_t oovveerrwwrriittee__eexxiissttiinngg  = 0_bit;
│ │ │ │ │     static constexpr status_flags_t qquueerryy__ddiissttrriibbuutteedd__ccooppiieess  = 0_bit;
│ │ │ │ │ @@ -315,18 +315,18 @@
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ttoorrrreenntt__hhaannddllee(()) **********
│ │ │ │ │  ttoorrrreenntt__hhaannddllee () noexcept = default;
│ │ │ │ │  constructs a torrent handle that does not refer to a torrent. i.e. _i_s___v_a_l_i_d_(_)
│ │ │ │ │  will return false.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aadddd__ppiieeccee(()) **********
│ │ │ │ │ -void aadddd__ppiieeccee (piece_index_t piece, std::vector data, add_piece_flags_t
│ │ │ │ │ -flags = {}) const;
│ │ │ │ │  void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t flags
│ │ │ │ │  = {}) const;
│ │ │ │ │ +void aadddd__ppiieeccee (piece_index_t piece, std::vector data, add_piece_flags_t
│ │ │ │ │ +flags = {}) const;
│ │ │ │ │  This function will write data to the storage as piece piece, as if it had been
│ │ │ │ │  downloaded from a peer.
│ │ │ │ │  By default, data that's already been downloaded is not overwritten by this
│ │ │ │ │  buffer. If you trust this data to be correct (and pass the piece hash check)
│ │ │ │ │  you may pass the overwrite_existing flag. This will instruct libtorrent to
│ │ │ │ │  overwrite any data that may already have been downloaded with this data.
│ │ │ │ │  Since the data is written asynchronously, you may know that is passed or failed
│ │ │ │ │ @@ -355,29 +355,29 @@
│ │ │ │ │  [_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]
│ │ │ │ │  ********** ggeett__ppeeeerr__iinnffoo(()) ppoosstt__ppeeeerr__iinnffoo(()) **********
│ │ │ │ │ -void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │  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(()) **********
│ │ │ │ │ -torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │  void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │  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,28 +385,28 @@
│ │ │ │ │  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(()) **********
│ │ │ │ │ -std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ +********** ggeett__ddoowwnnllooaadd__qquueeuuee(()) ppoosstt__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 cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │  void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │ +void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │  void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) 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.
│ │ │ │ │ @@ -416,19 +416,19 @@
│ │ │ │ │  deadline is the number of milliseconds until this piece should be completed.
│ │ │ │ │  reset_piece_deadline removes the deadline from the piece. If it hasn't already
│ │ │ │ │  been downloaded, it will no longer be considered a priority.
│ │ │ │ │  clear_piece_deadlines() removes deadlines on all pieces in the torrent. As if
│ │ │ │ │  _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_) was called on all pieces.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ppoosstt__ffiillee__pprrooggrreessss(()) ffiillee__pprrooggrreessss(()) **********
│ │ │ │ │ -std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ -const;
│ │ │ │ │ -void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │  void ffiillee__pprrooggrreessss (std::vector& progress, file_progress_flags_t
│ │ │ │ │  flags = {}) const;
│ │ │ │ │ +void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ +std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ +const;
│ │ │ │ │  This function fills in the supplied vector, or returns a vector, with the
│ │ │ │ │  number of bytes downloaded of each file in this torrent. The progress values
│ │ │ │ │  are ordered the same as the files in the _t_o_r_r_e_n_t___i_n_f_o.
│ │ │ │ │  This operation is not very cheap. Its complexity is OO((nn ++ mmjj)). Where nn is the
│ │ │ │ │  number of files, mm is the number of currently downloading pieces and jj is the
│ │ │ │ │  number of blocks in a piece.
│ │ │ │ │  The flags parameter can be used to specify the granularity of the file
│ │ │ │ │ @@ -449,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(()) rreeppllaaccee__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) ppoosstt__ttrraacckkeerrss(()) **********
│ │ │ │ │ +********** rreeppllaaccee__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) ppoosstt__ttrraacckkeerrss(()) **********
│ │ │ │ │  void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ -void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │  void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │  std::vector ttrraacckkeerrss () const;
│ │ │ │ │ +void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) 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,30 +470,30 @@
│ │ │ │ │  add_tracker() will look if the specified tracker is already in the set. If it
│ │ │ │ │  is, it doesn't do anything. If it's not in the current set of trackers, it will
│ │ │ │ │  insert it in the tier specified in the _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │  The updated set of trackers will be saved in the resume data, and when a
│ │ │ │ │  torrent is started with resume data, the trackers from the resume data will
│ │ │ │ │  replace the original ones.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** rreemmoovvee__uurrll__sseeeedd(()) uurrll__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │ +********** uurrll__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) rreemmoovvee__uurrll__sseeeedd(()) **********
│ │ │ │ │  void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ -void rreemmoovvee__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]
│ │ │ │ │ -********** aadddd__hhttttpp__sseeeedd(()) rreemmoovvee__hhttttpp__sseeeedd(()) hhttttpp__sseeeeddss(()) **********
│ │ │ │ │ -std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +********** rreemmoovvee__hhttttpp__sseeeedd(()) aadddd__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&,
│ │ │ │ │ @@ -524,36 +524,36 @@
│ │ │ │ │  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]
│ │ │ │ │ -********** rreessuummee(()) ppaauussee(()) **********
│ │ │ │ │ -void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ +********** ppaauussee(()) rreessuummee(()) **********
│ │ │ │ │  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
│ │ │ │ │  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]
│ │ │ │ │ -********** uunnsseett__ffllaaggss(()) sseett__ffllaaggss(()) ffllaaggss(()) **********
│ │ │ │ │ -void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ +********** sseett__ffllaaggss(()) uunnsseett__ffllaaggss(()) ffllaaggss(()) **********
│ │ │ │ │ +torrent_flags_t ffllaaggss () const;
│ │ │ │ │  void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │  void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ -torrent_flags_t ffllaaggss () 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 (resume_data_flags_t flags) const;
│ │ │ │ │  bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │ +bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │  This function returns true if anything that is stored in the resume data has
│ │ │ │ │  changed since the last time resume data was saved. The overload that takes
│ │ │ │ │  flags let you ask if specific categories of properties have changed. These
│ │ │ │ │  flags have the same behavior as in the _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) call.
│ │ │ │ │  This is a bblloocckkiinngg call. It will wait for a response from libtorrent's main
│ │ │ │ │  thread. A way to avoid blocking is to instead call _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) directly,
│ │ │ │ │  specifying the conditions under which resume data should be saved.
│ │ │ │ │  Note
│ │ │ │ │  A torrent's resume data is considered saved as soon as the
│ │ │ │ │  _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t is posted. It is important to make sure this _a_l_e_r_t is
│ │ │ │ │  received and handled in order for this function to be meaningful.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__bboottttoomm(())
│ │ │ │ │ -qquueeuuee__ppoossiittiioonn__ddoowwnn(()) qquueeuuee__ppoossiittiioonn__uupp(()) **********
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +********** qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__uupp(()) qquueeuuee__ppoossiittiioonn(())
│ │ │ │ │ +qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) **********
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │  queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │  void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__bboottttoomm () 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
│ │ │ │ │ @@ -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.
│ │ │ │ │ @@ -770,33 +770,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]
│ │ │ │ │ -********** ppiieeccee__aavvaaiillaabbiilliittyy(()) ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy(()) **********
│ │ │ │ │ -void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ +********** ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy(()) 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(()) **********
│ │ │ │ │ -void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ +********** pprriioorriittiizzee__ppiieecceess(()) ggeett__ppiieeccee__pprriioorriittiieess(()) ppiieeccee__pprriioorriittyy(()) **********
│ │ │ │ │  download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │  void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) const;
│ │ │ │ │ -std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ +void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │  void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ │ +std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │  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]
│ │ │ │ │ -********** pprriioorriittiizzee__ffiilleess(()) ffiillee__pprriioorriittyy(()) ggeett__ffiillee__pprriioorriittiieess(()) **********
│ │ │ │ │ +********** pprriioorriittiizzee__ffiilleess(()) ggeett__ffiillee__pprriioorriittiieess(()) ffiillee__pprriioorriittyy(()) **********
│ │ │ │ │  std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ +void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │  void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │  download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ -void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │  index must be in the range [0, number_of_files).
│ │ │ │ │  file_priority() queries or sets the priority of file index.
│ │ │ │ │  prioritize_files() takes a vector that has at as many elements as there are
│ │ │ │ │  files in the torrent. Each _e_n_t_r_y is the priority of that file. The function
│ │ │ │ │  sets the priorities of all the pieces in the torrent based on the vector.
│ │ │ │ │  get_file_priorities() returns a vector with the priorities of all files.
│ │ │ │ │  The priority values are the same as for _p_i_e_c_e___p_r_i_o_r_i_t_y_(_). See
│ │ │ │ │ @@ -847,19 +847,19 @@
│ │ │ │ │  When combining file- and piece priorities, the resume file will record both.
│ │ │ │ │  When loading the resume data, the file priorities will be applied first, then
│ │ │ │ │  the piece priorities.
│ │ │ │ │  Moving data from a file into the part file is currently not supported. If a
│ │ │ │ │  file has its priority set to 0 aafftteerr it has already been created, it will not
│ │ │ │ │  be moved into the partfile.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffoorrccee__llssdd__aannnnoouunnccee(()) ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) **********
│ │ │ │ │ +********** ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) ffoorrccee__llssdd__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__llssdd__aannnnoouunnccee () const;
│ │ │ │ │  force_reannounce() will force this torrent to do another tracker request, to
│ │ │ │ │  receive new peers. The seconds argument specifies how many seconds from now to
│ │ │ │ │  issue the tracker announces.
│ │ │ │ │  If the tracker's min_interval has not passed since the last announce, the
│ │ │ │ │  forced announce will be scheduled to happen immediately as the min_interval
│ │ │ │ │  expires. This is to honor trackers minimum re-announce interval settings.
│ │ │ │ │  The tracker_index argument specifies which tracker to re-announce. If set to -
│ │ │ │ │ @@ -877,19 +877,19 @@
│ │ │ │ │  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(())
│ │ │ │ │ +********** sseett__ddoowwnnllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(())
│ │ │ │ │  **********
│ │ │ │ │ +int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │  void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │  int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ -int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │  void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │  set_upload_limit will limit the upload bandwidth used by this particular
│ │ │ │ │  torrent to the limit you set. It is given as the number of bytes per second the
│ │ │ │ │  torrent is allowed to upload. set_download_limit works the same way but for
│ │ │ │ │  download bandwidth instead of upload bandwidth. Note that setting a higher
│ │ │ │ │  limit on a torrent then the global limit (settings_pack::upload_rate_limit)
│ │ │ │ │  will not override the global rate limit. The torrent can never upload more than
│ │ │ │ │ @@ -922,15 +922,15 @@
│ │ │ │ │  int mmaaxx__uuppllooaaddss () const;
│ │ │ │ │  set_max_uploads() sets the maximum number of peers that's unchoked at the same
│ │ │ │ │  time on this torrent. If you set this to -1, there will be no limit. This
│ │ │ │ │  defaults to infinite. The primary setting controlling this is the global
│ │ │ │ │  unchoke slots limit, set by unchoke_slots_limit in _s_e_t_t_i_n_g_s___p_a_c_k.
│ │ │ │ │  max_uploads() returns the current settings.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** mmaaxx__ccoonnnneeccttiioonnss(()) sseett__mmaaxx__ccoonnnneeccttiioonnss(()) **********
│ │ │ │ │ +********** sseett__mmaaxx__ccoonnnneeccttiioonnss(()) mmaaxx__ccoonnnneeccttiioonnss(()) **********
│ │ │ │ │  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
│ │ │ │ │ @@ -983,26 +983,26 @@
│ │ │ │ │  ********** rreennaammee__ffiillee(()) **********
│ │ │ │ │  void rreennaammee__ffiillee (file_index_t index, std::string const& new_name) const;
│ │ │ │ │  Renames the file with the given index asynchronously. The rename operation is
│ │ │ │ │  complete when either a _f_i_l_e___r_e_n_a_m_e_d___a_l_e_r_t or _f_i_l_e___r_e_n_a_m_e___f_a_i_l_e_d___a_l_e_r_t is
│ │ │ │ │  posted.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │ -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====(()) **********
│ │ │ │ │ +********** ooppeerraattoorr!!==(()) ooppeerraattoorr====(()) ooppeerraattoorr<<(()) **********
│ │ │ │ │ +bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │  bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │  bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ │ -bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │  comparison operators. The order of the torrents is unspecified but stable.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** iidd(()) **********
│ │ │ │ │  std::uint32_t iidd () const;
│ │ │ │ │  returns a unique identifier for this torrent. It's not a dense index. It's not
│ │ │ │ │  preserved across sessions.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Info.html
│ │ │ │ @@ -38,35 +38,35 @@
│ │ │ │  
  • enum type_t
    • 
│ │ │ │  
│ │ │ │  
│ │ │ │  
  • load_torrent_limits
    • 
│ │ │ │  
  • torrent_info
      
│ │ │ │  
    • torrent_info()
      • 
│ │ │ │  
    • ~torrent_info()
      • 
│ │ │ │ -
    • orig_files() files()
      • 
│ │ │ │ +
    • files() orig_files()
      • 
│ │ │ │  
    • rename_file()
      • 
│ │ │ │  
    • remap_files()
      • 
│ │ │ │ -
    • trackers() add_tracker() clear_trackers()
      • 
│ │ │ │ -
    • collections() similar_torrents()
      • 
│ │ │ │ -
    • add_http_seed() add_url_seed() set_web_seeds() web_seeds()
      • 
│ │ │ │ +
    • clear_trackers() trackers() add_tracker()
      • 
│ │ │ │ +
    • similar_torrents() collections()
      • 
│ │ │ │ +
    • add_url_seed() add_http_seed() set_web_seeds() web_seeds()
      • 
│ │ │ │  
    • total_size()
      • 
│ │ │ │  
    • num_pieces() piece_length()
      • 
│ │ │ │  
    • blocks_per_piece()
      • 
│ │ │ │ -
    • piece_range() last_piece() end_piece()
      • 
│ │ │ │ +
    • last_piece() end_piece() piece_range()
      • 
│ │ │ │  
    • info_hash() info_hashes()
      • 
│ │ │ │ -
    • v1() v2()
      • 
│ │ │ │ +
    • v2() v1()
      • 
│ │ │ │  
    • num_files()
      • 
│ │ │ │  
    • map_block()
      • 
│ │ │ │  
    • map_file()
      • 
│ │ │ │  
    • ssl_cert()
      • 
│ │ │ │  
    • is_valid()
      • 
│ │ │ │  
    • priv()
      • 
│ │ │ │  
    • is_i2p()
      • 
│ │ │ │  
    • piece_size()
      • 
│ │ │ │ -
    • hash_for_piece_ptr() hash_for_piece()
      • 
│ │ │ │ +
    • hash_for_piece() hash_for_piece_ptr()
      • 
│ │ │ │  
    • name()
      • 
│ │ │ │  
    • creation_date()
      • 
│ │ │ │  
    • creator()
      • 
│ │ │ │  
    • comment()
      • 
│ │ │ │  
    • nodes()
      • 
│ │ │ │  
    • add_node()
      • 
│ │ │ │  
    • parse_info_section()
      • 
│ │ │ │ @@ -198,68 +198,68 @@
│ │ │ │  
      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, error_code& ec);
│ │ │ │ -   explicit torrent_info (std::string const& filename);
│ │ │ │     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);
│ │ │ │ +   explicit torrent_info (std::string const& filename);
│ │ │ │     torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │     torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +   torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +   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, load_torrent_limits const& cfg);
│ │ │ │ -   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +   torrent_info (torrent_info const& t);
│ │ │ │     torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -   explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │     torrent_info (char const* buffer, int size);
│ │ │ │ -   torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -   torrent_info (torrent_info const& t);
│ │ │ │     ~torrent_info ();
│ │ │ │     file_storage const& orig_files () const;
│ │ │ │     file_storage const& files () const;
│ │ │ │     void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │     void remap_files (file_storage const& f);
│ │ │ │ -   void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ -   std::vector<announce_entry> const& trackers () const;
│ │ │ │ -   void clear_trackers ();
│ │ │ │     void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ +   void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ +   void clear_trackers ();
│ │ │ │ +   std::vector<announce_entry> const& trackers () const;
│ │ │ │     std::vector<sha1_hash> similar_torrents () const;
│ │ │ │     std::vector<std::string> collections () const;
│ │ │ │ -   void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ -   void add_http_seed (std::string const& url
│ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │     std::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());
│ │ │ │ +   void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +   void add_http_seed (std::string const& url
│ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │     std::int64_t total_size () const;
│ │ │ │     int num_pieces () const;
│ │ │ │     int piece_length () const;
│ │ │ │     int blocks_per_piece () 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;
│ │ │ │ +   piece_index_t end_piece () const;
│ │ │ │     info_hash_t const& info_hashes () const;
│ │ │ │ -   bool v1 () const;
│ │ │ │ +   sha1_hash info_hash () const noexcept;
│ │ │ │     bool v2 () const;
│ │ │ │ +   bool v1 () const;
│ │ │ │     int num_files () const;
│ │ │ │     std::vector<file_slice> map_block (piece_index_t const piece
│ │ │ │        , std::int64_t offset, int size) const;
│ │ │ │     peer_request map_file (file_index_t const file, std::int64_t offset, int size) const;
│ │ │ │     string_view ssl_cert () const;
│ │ │ │     bool is_valid () const;
│ │ │ │     bool priv () const;
│ │ │ │     bool is_i2p () const;
│ │ │ │     int piece_size (piece_index_t index) const;
│ │ │ │ -   sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │     char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ +   sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │     bool is_loaded () const;
│ │ │ │     const std::string& name () const;
│ │ │ │     std::time_t creation_date () const;
│ │ │ │     const std::string& creator () const;
│ │ │ │     const std::string& comment () const;
│ │ │ │     std::vector<std::pair<std::string, int>> const& nodes () const;
│ │ │ │     void add_node (std::pair<std::string, int> const& node);
│ │ │ │ @@ -270,26 +270,26 @@
│ │ │ │     void free_piece_layers ();
│ │ │ │  };
│ │ │ │  
      
│ │ │ │  [report issue]
      
│ │ │ │  
      torrent_info()
      
│ │ │ │  
      │ │ │ │  torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ -explicit torrent_info (std::string const& filename);
│ │ │ │  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);
│ │ │ │ +explicit torrent_info (std::string const& filename);
│ │ │ │  torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │  torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +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, load_torrent_limits const& cfg);
│ │ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +torrent_info (torrent_info const& t);
│ │ │ │  torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │  torrent_info (char const* buffer, int size);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -torrent_info (torrent_info const& t);
│ │ │ │  
      
│ │ │ │  
      The constructor that takes an info-hash will initialize the info-hash
│ │ │ │  to the given value, but leave all other fields empty. This is used
│ │ │ │  internally when downloading torrents without the metadata. The
│ │ │ │  metadata will be created by libtorrent as soon as it has been
│ │ │ │  downloaded from the swarm.
      
│ │ │ │  
      The constructor that takes a bdecode_node will create a torrent_info
│ │ │ │ @@ -318,18 +318,18 @@
│ │ │ │  [report issue]
      
│ │ │ │  
      
│ │ │ │  
      ~torrent_info()
      
│ │ │ │  
      │ │ │ │  ~torrent_info ();
│ │ │ │  
      
│ │ │ │  
      frees all storage associated with this torrent_info object
      
│ │ │ │ -
│ │ │ │ -[report issue]
      
│ │ │ │ -
      
│ │ │ │ -
      orig_files() files()
      
│ │ │ │ +
│ │ │ │ +[report issue]
      
│ │ │ │ +
      
│ │ │ │ +
      files() orig_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
│ │ │ │ @@ -376,64 +376,64 @@
│ │ │ │  
      
│ │ │ │  
      Remaps the file storage to a new file layout. This can be used to, for
│ │ │ │  instance, download all data in a torrent to a single file, or to a
│ │ │ │  number of fixed size sector aligned files, regardless of the number
│ │ │ │  and sizes of the files in the torrent.
      
│ │ │ │  
      The new specified file_storage must have the exact same size as
│ │ │ │  the current one.
      
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
    • │ │ │ │ -
    │ │ │ │ -

    trackers() add_tracker() clear_trackers()

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

    clear_trackers() trackers() add_tracker()

    │ │ │ │ 
    │ │ │ │ -void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ -std::vector<announce_entry> const& trackers () const;
│ │ │ │ -void clear_trackers ();
│ │ │ │  void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ +void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ +void clear_trackers ();
│ │ │ │ +std::vector<announce_entry> const& trackers () const;
│ │ │ │
    │ │ │ │

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

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

    add_url_seed() add_http_seed() set_web_seeds() web_seeds()

    │ │ │ │ 
    │ │ │ │ -void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ -void add_http_seed (std::string const& url
│ │ │ │ -      , std::string const& extern_auth = std::string()
│ │ │ │ -      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │  std::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());
│ │ │ │ +void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +void add_http_seed (std::string const& url
│ │ │ │ +      , std::string const& extern_auth = std::string()
│ │ │ │ +      , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │
    │ │ │ │

    web_seeds() returns all url seeds and http seeds in the torrent. │ │ │ │ Each entry is a web_seed_entry and may refer to either a url seed │ │ │ │ or http seed.

    │ │ │ │

    add_url_seed() and add_http_seed() adds one url to the list of │ │ │ │ url/http seeds.

    │ │ │ │

    set_web_seeds() replaces all web seeds with the ones specified in │ │ │ │ @@ -476,48 +476,48 @@ │ │ │ │

    │ │ │ │

    blocks_per_piece()

    │ │ │ │ 
    │ │ │ │  int blocks_per_piece () const;
│ │ │ │
    │ │ │ │

    returns the number of blocks there are in the typical piece. There │ │ │ │ may be fewer in the last piece)

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

    piece_range() last_piece() end_piece()

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

    last_piece() end_piece() piece_range()

    │ │ │ │ 
    │ │ │ │  piece_index_t last_piece () const;
│ │ │ │ -piece_index_t end_piece () const;
│ │ │ │  index_range<piece_index_t> piece_range () const;
│ │ │ │ +piece_index_t end_piece () const;
│ │ │ │
    │ │ │ │

    last_piece() returns the index to the last piece in the torrent and │ │ │ │ end_piece() returns the index to the one-past-end piece in the │ │ │ │ torrent │ │ │ │ piece_range() returns an implementation-defined type that can be │ │ │ │ used as the container in a range-for loop. Where the values are the │ │ │ │ indices of all pieces in the file_storage.

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

    info_hash() info_hashes()

    │ │ │ │ 
    │ │ │ │ -sha1_hash info_hash () const noexcept;
│ │ │ │  info_hash_t const& info_hashes () const;
│ │ │ │ +sha1_hash info_hash () const noexcept;
│ │ │ │
    │ │ │ │

    returns the info-hash of the torrent. For BitTorrent v2 support, use │ │ │ │ info_hashes() to get an object that may hold both a v1 and v2 │ │ │ │ info-hash

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

    v1() v2()

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

    v2() v1()

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

    │ │ │ │ @@ -590,21 +590,21 @@ │ │ │ │
    │ │ │ │

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

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

    hash_for_piece() hash_for_piece_ptr()

    │ │ │ │ 
    │ │ │ │ -sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │  char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ +sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │
    │ │ │ │

    hash_for_piece() takes a piece-index and returns the 20-bytes │ │ │ │ sha1-hash for that piece and info_hash() returns the 20-bytes │ │ │ │ sha1-hash for the info-section of the torrent file. │ │ │ │ hash_for_piece_ptr() returns a pointer to the 20 byte sha1 digest │ │ │ │ for the piece. Note that the string is not 0-terminated.

    │ │ │ │ [report issue]
    │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -7,35 +7,35 @@ │ │ │ │ │ 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 _o_r_i_g___f_i_l_e_s_(_)_ _f_i_l_e_s_(_) │ │ │ │ │ + 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_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _w_e_b___s_e_e_d_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 _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 _a_d_d___u_r_l___s_e_e_d_(_)_ _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_(_) │ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_) │ │ │ │ │ o _n_u_m___p_i_e_c_e_s_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_) │ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_) │ │ │ │ │ - o _p_i_e_c_e___r_a_n_g_e_(_)_ _l_a_s_t___p_i_e_c_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_(_)_ _i_n_f_o___h_a_s_h_e_s_(_) │ │ │ │ │ - o _v_1_(_)_ _v_2_(_) │ │ │ │ │ + o _v_2_(_)_ _v_1_(_) │ │ │ │ │ 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___p_t_r_(_)_ _h_a_s_h___f_o_r___p_i_e_c_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 _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_(_) │ │ │ │ │ @@ -121,73 +121,73 @@ │ │ │ │ │ [_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, error_code& ec); │ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (std::string const& filename); │ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg, │ │ │ │ │ from_span_t); │ │ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const& │ │ │ │ │ +cfg); │ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (std::string const& filename); │ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec); │ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec); │ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash); │ │ │ │ │ explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t); │ │ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const& │ │ │ │ │ -cfg); │ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file); │ │ │ │ │ + ttoorrrreenntt__iinnffoo (torrent_info const& t); │ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t); │ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash); │ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file); │ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size); │ │ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec); │ │ │ │ │ - ttoorrrreenntt__iinnffoo (torrent_info const& t); │ │ │ │ │ ~~ttoorrrreenntt__iinnffoo (); │ │ │ │ │ file_storage const& oorriigg__ffiilleess () const; │ │ │ │ │ file_storage const& ffiilleess () const; │ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename); │ │ │ │ │ void rreemmaapp__ffiilleess (file_storage const& f); │ │ │ │ │ - void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0); │ │ │ │ │ - std::vector const& ttrraacckkeerrss () const; │ │ │ │ │ - void cclleeaarr__ttrraacckkeerrss (); │ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier │ │ │ │ │ , announce_entry::tracker_source source); │ │ │ │ │ + void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0); │ │ │ │ │ + void cclleeaarr__ttrraacckkeerrss (); │ │ │ │ │ + std::vector const& ttrraacckkeerrss () const; │ │ │ │ │ std::vector ssiimmiillaarr__ttoorrrreennttss () const; │ │ │ │ │ std::vector ccoolllleeccttiioonnss () const; │ │ │ │ │ - void sseett__wweebb__sseeeeddss (std::vector seeds); │ │ │ │ │ - void aadddd__hhttttpp__sseeeedd (std::string const& url │ │ │ │ │ - , std::string const& extern_auth = std::string() │ │ │ │ │ - , web_seed_entry::headers_t const& extra_headers = web_seed_entry:: │ │ │ │ │ -headers_t()); │ │ │ │ │ std::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()); │ │ │ │ │ + void sseett__wweebb__sseeeeddss (std::vector seeds); │ │ │ │ │ + void aadddd__hhttttpp__sseeeedd (std::string const& url │ │ │ │ │ + , std::string const& extern_auth = std::string() │ │ │ │ │ + , web_seed_entry::headers_t const& extra_headers = web_seed_entry:: │ │ │ │ │ +headers_t()); │ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const; │ │ │ │ │ int nnuumm__ppiieecceess () const; │ │ │ │ │ int ppiieeccee__lleennggtthh () const; │ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const; │ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const; │ │ │ │ │ - piece_index_t eenndd__ppiieeccee () const; │ │ │ │ │ index_range ppiieeccee__rraannggee () const; │ │ │ │ │ - sha1_hash iinnffoo__hhaasshh () const noexcept; │ │ │ │ │ + piece_index_t eenndd__ppiieeccee () const; │ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const; │ │ │ │ │ - bool vv11 () const; │ │ │ │ │ + sha1_hash iinnffoo__hhaasshh () const noexcept; │ │ │ │ │ bool vv22 () const; │ │ │ │ │ + bool vv11 () const; │ │ │ │ │ int nnuumm__ffiilleess () const; │ │ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t const piece │ │ │ │ │ , std::int64_t offset, int size) const; │ │ │ │ │ peer_request mmaapp__ffiillee (file_index_t const file, std::int64_t offset, int │ │ │ │ │ size) const; │ │ │ │ │ string_view ssssll__cceerrtt () const; │ │ │ │ │ bool iiss__vvaalliidd () const; │ │ │ │ │ bool pprriivv () const; │ │ │ │ │ bool iiss__ii22pp () const; │ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const; │ │ │ │ │ - sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const; │ │ │ │ │ char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const; │ │ │ │ │ + sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const; │ │ │ │ │ bool iiss__llooaaddeedd () const; │ │ │ │ │ const std::string& nnaammee () const; │ │ │ │ │ std::time_t ccrreeaattiioonn__ddaattee () const; │ │ │ │ │ const std::string& ccrreeaattoorr () const; │ │ │ │ │ const std::string& ccoommmmeenntt () const; │ │ │ │ │ std::vector> const& nnooddeess () const; │ │ │ │ │ void aadddd__nnooddee (std::pair const& node); │ │ │ │ │ @@ -197,28 +197,28 @@ │ │ │ │ │ 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, error_code& ec); │ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (std::string const& filename); │ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg, │ │ │ │ │ from_span_t); │ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const& │ │ │ │ │ +cfg); │ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (std::string const& filename); │ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec); │ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec); │ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash); │ │ │ │ │ explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t); │ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const& │ │ │ │ │ -cfg); │ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file); │ │ │ │ │ +ttoorrrreenntt__iinnffoo (torrent_info const& t); │ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t); │ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash); │ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file); │ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size); │ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec); │ │ │ │ │ -ttoorrrreenntt__iinnffoo (torrent_info const& t); │ │ │ │ │ The constructor that takes an info-hash will initialize the info-hash to the │ │ │ │ │ given value, but leave all other fields empty. This is used internally when │ │ │ │ │ downloading torrents without the metadata. The metadata will be created by │ │ │ │ │ libtorrent as soon as it has been downloaded from the swarm. │ │ │ │ │ The constructor that takes a _b_d_e_c_o_d_e___n_o_d_e will create a _t_o_r_r_e_n_t___i_n_f_o object │ │ │ │ │ from the information found in the given torrent_file. The _b_d_e_c_o_d_e___n_o_d_e │ │ │ │ │ represents a tree node in an bencoded file. To load an ordinary .torrent file │ │ │ │ │ @@ -241,15 +241,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] │ │ │ │ │ -********** oorriigg__ffiilleess(()) ffiilleess(()) ********** │ │ │ │ │ +********** ffiilleess(()) oorriigg__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 │ │ │ │ │ @@ -284,49 +284,49 @@ │ │ │ │ │ Remaps the file storage to a new file layout. This can be used to, for │ │ │ │ │ instance, download all data in a torrent to a single file, or to a number of │ │ │ │ │ fixed size sector aligned files, regardless of the number and sizes of the │ │ │ │ │ files in the torrent. │ │ │ │ │ The new specified file_storage must have the exact same size as the current │ │ │ │ │ one. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) cclleeaarr__ttrraacckkeerrss(()) ********** │ │ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0); │ │ │ │ │ -std::vector const& ttrraacckkeerrss () const; │ │ │ │ │ -void cclleeaarr__ttrraacckkeerrss (); │ │ │ │ │ +********** cclleeaarr__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) ********** │ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier │ │ │ │ │ , announce_entry::tracker_source source); │ │ │ │ │ +void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0); │ │ │ │ │ +void cclleeaarr__ttrraacckkeerrss (); │ │ │ │ │ +std::vector const& ttrraacckkeerrss () const; │ │ │ │ │ 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(()) ********** │ │ │ │ │ +********** 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(()) sseett__wweebb__sseeeeddss(()) wweebb__sseeeeddss(()) ********** │ │ │ │ │ -void sseett__wweebb__sseeeeddss (std::vector seeds); │ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (std::string const& url │ │ │ │ │ - , std::string const& extern_auth = std::string() │ │ │ │ │ - , web_seed_entry::headers_t const& extra_headers = web_seed_entry:: │ │ │ │ │ -headers_t()); │ │ │ │ │ +********** aadddd__uurrll__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) sseett__wweebb__sseeeeddss(()) wweebb__sseeeeddss(()) ********** │ │ │ │ │ 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()); │ │ │ │ │ +void sseett__wweebb__sseeeeddss (std::vector seeds); │ │ │ │ │ +void aadddd__hhttttpp__sseeeedd (std::string const& url │ │ │ │ │ + , std::string const& extern_auth = std::string() │ │ │ │ │ + , web_seed_entry::headers_t const& extra_headers = web_seed_entry:: │ │ │ │ │ +headers_t()); │ │ │ │ │ web_seeds() returns all url seeds and http seeds in the torrent. Each _e_n_t_r_y is │ │ │ │ │ a web_seed_entry and may refer to either a url seed or http seed. │ │ │ │ │ add_url_seed() and add_http_seed() adds one url to the list of url/http seeds. │ │ │ │ │ set_web_seeds() replaces all web seeds with the ones specified in the seeds │ │ │ │ │ vector. │ │ │ │ │ The extern_auth argument can be used for other authorization schemes than basic │ │ │ │ │ HTTP authorization. If set, it will override any username and password found in │ │ │ │ │ @@ -353,33 +353,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] │ │ │ │ │ -********** ppiieeccee__rraannggee(()) llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) ********** │ │ │ │ │ +********** llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) ppiieeccee__rraannggee(()) ********** │ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const; │ │ │ │ │ -piece_index_t eenndd__ppiieeccee () const; │ │ │ │ │ index_range ppiieeccee__rraannggee () const; │ │ │ │ │ +piece_index_t eenndd__ppiieeccee () const; │ │ │ │ │ last_piece() returns the index to the last piece in the torrent and end_piece() │ │ │ │ │ returns the index to the one-past-end piece in the torrent piece_range() │ │ │ │ │ returns an implementation-defined type that can be used as the container in a │ │ │ │ │ range-for loop. Where the values are the indices of all pieces in the │ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) ********** │ │ │ │ │ -sha1_hash iinnffoo__hhaasshh () const noexcept; │ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const; │ │ │ │ │ +sha1_hash iinnffoo__hhaasshh () const noexcept; │ │ │ │ │ returns the info-hash of the torrent. For BitTorrent v2 support, use │ │ │ │ │ info_hashes() to get an object that may hold both a v1 and v2 info-hash │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** vv11(()) vv22(()) ********** │ │ │ │ │ -bool vv11 () const; │ │ │ │ │ +********** vv22(()) vv11(()) ********** │ │ │ │ │ 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 │ │ │ │ │ @@ -427,17 +427,17 @@ │ │ │ │ │ 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__ppttrr(()) hhaasshh__ffoorr__ppiieeccee(()) ********** │ │ │ │ │ -sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const; │ │ │ │ │ +********** hhaasshh__ffoorr__ppiieeccee(()) hhaasshh__ffoorr__ppiieeccee__ppttrr(()) ********** │ │ │ │ │ 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] │ │ │ │ │ ********** nnaammee(()) ********** │ │ │ │ │ const std::string& nnaammee () const; │ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Trackers.html │ │ │ │ @@ -31,15 +31,15 @@ │ │ │ │

    home

    │ │ │ │
    │ │ │ │

    Table of contents

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

    announce_infohash

    │ │ │ │ @@ -131,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&);
│ │ │ │ -   explicit announce_entry (string_view u);
│ │ │ │     announce_entry ();
│ │ │ │ +   announce_entry (announce_entry const&);
│ │ │ │     ~announce_entry ();
│ │ │ │ +   explicit announce_entry (string_view u);
│ │ │ │ +   announce_entry& operator= (announce_entry const&) &;
│ │ │ │  
│ │ │ │     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() operator=() announce_entry()

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

    announce_entry() operator=() ~announce_entry()

    │ │ │ │ 
    │ │ │ │ -announce_entry& operator= (announce_entry const&) &;
│ │ │ │ -announce_entry (announce_entry const&);
│ │ │ │ -explicit announce_entry (string_view u);
│ │ │ │  announce_entry ();
│ │ │ │ +announce_entry (announce_entry const&);
│ │ │ │  ~announce_entry ();
│ │ │ │ +explicit announce_entry (string_view u);
│ │ │ │ +announce_entry& operator= (announce_entry const&) &;
│ │ │ │
    │ │ │ │

    constructs a tracker announce entry with u as the URL.

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

    enum tracker_source

    │ │ │ │

    Declared in "libtorrent/announce_entry.hpp"

    │ │ │ │ │ │ │ │ ├── html2text {} │ │ │ │ │ @@ -2,15 +2,15 @@ │ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_] │ │ │ │ │ VVeerrssiioonn:: 2.0.10 │ │ │ │ │ _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_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _a_n_n_o_u_n_c_e___e_n_t_r_y_(_) │ │ │ │ │ + o _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_) │ │ │ │ │ o _e_n_u_m_ _t_r_a_c_k_e_r___s_o_u_r_c_e │ │ │ │ │ [_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&); │ │ │ │ │ - explicit aannnnoouunnccee__eennttrryy (string_view u); │ │ │ │ │ aannnnoouunnccee__eennttrryy (); │ │ │ │ │ + aannnnoouunnccee__eennttrryy (announce_entry const&); │ │ │ │ │ ~~aannnnoouunnccee__eennttrryy (); │ │ │ │ │ + explicit aannnnoouunnccee__eennttrryy (string_view u); │ │ │ │ │ + announce_entry& ooppeerraattoorr== (announce_entry const&) &; │ │ │ │ │ │ │ │ │ │ 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(()) ooppeerraattoorr==(()) aannnnoouunnccee__eennttrryy(()) ********** │ │ │ │ │ -announce_entry& ooppeerraattoorr== (announce_entry const&) &; │ │ │ │ │ -aannnnoouunnccee__eennttrryy (announce_entry const&); │ │ │ │ │ -explicit aannnnoouunnccee__eennttrryy (string_view u); │ │ │ │ │ +********** aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) ~~aannnnoouunnccee__eennttrryy(()) ********** │ │ │ │ │ aannnnoouunnccee__eennttrryy (); │ │ │ │ │ +aannnnoouunnccee__eennttrryy (announce_entry const&); │ │ │ │ │ ~~aannnnoouunnccee__eennttrryy (); │ │ │ │ │ +explicit aannnnoouunnccee__eennttrryy (string_view u); │ │ │ │ │ +announce_entry& ooppeerraattoorr== (announce_entry const&) &; │ │ │ │ │ constructs a tracker announce _e_n_t_r_y with u as the URL. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eennuumm ttrraacckkeerr__ssoouurrccee ********** │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p" │ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ │ │ │ │ │ |_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ | │ │ │ │ │ |_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,16 +31,16 @@ │ │ │ │

    home

    │ │ │ │
    │ │ │ │

    Table of contents

    │ │ │ │
      │ │ │ │
    • bitfield
        │ │ │ │
      • bitfield()
        • │ │ │ │
      • assign()
        • │ │ │ │ -
      • operator[]() get_bit()
        • │ │ │ │ -
      • clear_bit() set_bit()
        • │ │ │ │ +
      • get_bit() operator[]()
        • │ │ │ │ +
      • set_bit() clear_bit()
        • │ │ │ │
      • all_set()
        • │ │ │ │
      • none_set()
        • │ │ │ │
      • size()
        • │ │ │ │
      • num_words()
        • │ │ │ │
      • num_bytes()
        • │ │ │ │
      • empty()
        • │ │ │ │
      • data()
        • │ │ │ │ @@ -70,48 +70,48 @@ │ │ │ │

        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;
│ │ │ │     bitfield (int bits, bool val);
│ │ │ │     explicit bitfield (int bits);
│ │ │ │ -   bitfield (char const* b, int bits);
│ │ │ │     bitfield (bitfield const& rhs);
│ │ │ │ -   bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ +   bitfield (char const* b, int bits);
│ │ │ │     bitfield () noexcept = default;
│ │ │ │     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;
│ │ │ │     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;
│ │ │ │  bitfield (int bits, bool val);
│ │ │ │  explicit bitfield (int bits);
│ │ │ │ -bitfield (char const* b, int bits);
│ │ │ │  bitfield (bitfield const& rhs);
│ │ │ │ -bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ +bitfield (char const* b, int bits);
│ │ │ │  bitfield () noexcept = default;
│ │ │ │
        │ │ │ │

        constructs a new bitfield. The default constructor creates an empty │ │ │ │ bitfield. bits is the size of the bitfield (specified in bits). │ │ │ │ val is the value to initialize the bits to. If not specified │ │ │ │ all bits are initialized to 0.

        │ │ │ │

        The constructor taking a pointer b and bits copies a bitfield │ │ │ │ @@ -121,27 +121,27 @@ │ │ │ │

        │ │ │ │

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

        operator[]() get_bit()

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

        get_bit() operator[]()

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

        set bit at index to 0 (clear_bit) or 1 (set_bit).

        │ │ │ │ [report issue]
        │ │ │ │
        │ │ │ │ @@ -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,41 +242,41 @@
│ │ │ │  
        The built-in software version of sha1-algorithm was implemented
│ │ │ │  by Steve Reid and released as public domain.
│ │ │ │  For more info, see src/sha1.cpp.
        
│ │ │ │  
        │ │ │ │  class hasher
│ │ │ │  {
│ │ │ │     hasher ();
│ │ │ │ +   hasher (hasher const&);
│ │ │ │     hasher& operator= (hasher const&) &;
│ │ │ │     explicit hasher (span<char const> data);
│ │ │ │     hasher (char const* data, int len);
│ │ │ │ -   hasher (hasher const&);
│ │ │ │ -   hasher& update (span<char const> data);
│ │ │ │     hasher& update (char const* data, int len);
│ │ │ │ +   hasher& update (span<char const> data);
│ │ │ │     sha1_hash final ();
│ │ │ │     void reset ();
│ │ │ │  };
│ │ │ │  
        
│ │ │ │  
│ │ │ │  [report issue]
        
│ │ │ │  
        operator=() hasher()
        
│ │ │ │  
        │ │ │ │ +hasher (hasher const&);
│ │ │ │  hasher& operator= (hasher const&) &;
│ │ │ │  explicit hasher (span<char const> data);
│ │ │ │  hasher (char const* data, int len);
│ │ │ │ -hasher (hasher const&);
│ │ │ │  
        
│ │ │ │  
        this is the same as default constructing followed by a call to
│ │ │ │  update(data, len).
        
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        update()
        
│ │ │ │  
        │ │ │ │ -hasher& update (span<char const> data);
│ │ │ │  hasher& update (char const* data, int len);
│ │ │ │ +hasher& update (span<char const> data);
│ │ │ │  
        
│ │ │ │  
        append the following bytes to what is being hashed
        
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        final()
        
│ │ │ │  
        │ │ │ │  sha1_hash final ();
│ │ │ │ @@ -296,42 +296,42 @@
│ │ │ │  
        
│ │ │ │  
        hasher256
        
│ │ │ │  
        Declared in "libtorrent/hasher.hpp"
        
│ │ │ │  
        │ │ │ │  class hasher256
│ │ │ │  {
│ │ │ │     hasher256 ();
│ │ │ │ -   hasher256 (hasher256 const&);
│ │ │ │ -   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& 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=()
        
│ │ │ │  
        │ │ │ │ -hasher256 (hasher256 const&);
│ │ │ │ -hasher256& operator= (hasher256 const&) &;
│ │ │ │  explicit hasher256 (span<char const> data);
│ │ │ │  hasher256 (char const* data, int len);
│ │ │ │ +hasher256 (hasher256 const&);
│ │ │ │ +hasher256& operator= (hasher256 const&) &;
│ │ │ │  
        
│ │ │ │  
        this is the same as default constructing followed by a call to
│ │ │ │  update(data, len).
        
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        update()
        
│ │ │ │  
        │ │ │ │ -hasher256& update (span<char const> data);
│ │ │ │  hasher256& update (char const* data, int len);
│ │ │ │ +hasher256& update (span<char const> data);
│ │ │ │  
        
│ │ │ │  
        append the following bytes to what is being hashed
        
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        final()
        
│ │ │ │  
        │ │ │ │  sha256_hash final ();
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -2,16 +2,16 @@
│ │ │ │ │  _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │  VVeerrssiioonn:: 2.0.10
│ │ │ │ │  _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 _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 _g_e_t___b_i_t_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ +          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_(_)
│ │ │ │ │ @@ -32,65 +32,65 @@
│ │ │ │ │  [_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;
│ │ │ │ │     bbiittffiieelldd (int bits, bool val);
│ │ │ │ │     explicit bbiittffiieelldd (int bits);
│ │ │ │ │ -   bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │     bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -   bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ +   bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │     bbiittffiieelldd () noexcept = default;
│ │ │ │ │     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;
│ │ │ │ │     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;
│ │ │ │ │  bbiittffiieelldd (int bits, bool val);
│ │ │ │ │  explicit bbiittffiieelldd (int bits);
│ │ │ │ │ -bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │  bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ +bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │  bbiittffiieelldd () noexcept = default;
│ │ │ │ │  constructs a new _b_i_t_f_i_e_l_d. The default constructor creates an empty _b_i_t_f_i_e_l_d.
│ │ │ │ │  bits is the size of the _b_i_t_f_i_e_l_d (specified in bits). val is the value to
│ │ │ │ │  initialize the bits to. If not specified all bits are initialized to 0.
│ │ │ │ │  The constructor taking a pointer b and bits copies a _b_i_t_f_i_e_l_d from the
│ │ │ │ │  specified buffer, and bits number of bits (rounded up to the nearest byte
│ │ │ │ │  boundary).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aassssiiggnn(()) **********
│ │ │ │ │  void aassssiiggnn (char const* b, int const bits);
│ │ │ │ │  copy _b_i_t_f_i_e_l_d from buffer b of bits number of bits, rounded up to the nearest
│ │ │ │ │  byte boundary.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr[[]](()) ggeett__bbiitt(()) **********
│ │ │ │ │ +********** ggeett__bbiitt(()) ooppeerraattoorr[[]](()) **********
│ │ │ │ │  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(()) **********
│ │ │ │ │ +********** sseett__bbiitt(()) cclleeaarr__bbiitt(()) **********
│ │ │ │ │  void sseett__bbiitt (int index) noexcept;
│ │ │ │ │  void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │  set bit at index to 0 (clear_bit) or 1 (set_bit).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** aallll__sseett(()) **********
│ │ │ │ │  bool aallll__sseett () const noexcept;
│ │ │ │ │  returns true if all bits in the _b_i_t_f_i_e_l_d are set
│ │ │ │ │ @@ -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,35 +151,35 @@
│ │ │ │ │  If you want to reuse the _h_a_s_h_e_r object once you have created a hash, you have
│ │ │ │ │  to call reset() to reinitialize it.
│ │ │ │ │  The built-in software version of sha1-algorithm was implemented by Steve Reid
│ │ │ │ │  and released as public domain. For more info, see src/sha1.cpp.
│ │ │ │ │  class hasher
│ │ │ │ │  {
│ │ │ │ │     hhaasshheerr ();
│ │ │ │ │ +   hhaasshheerr (hasher const&);
│ │ │ │ │     hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │     explicit hhaasshheerr (span data);
│ │ │ │ │     hhaasshheerr (char const* data, int len);
│ │ │ │ │ -   hhaasshheerr (hasher const&);
│ │ │ │ │ -   hasher& uuppddaattee (span data);
│ │ │ │ │     hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ +   hasher& uuppddaattee (span data);
│ │ │ │ │     sha1_hash ffiinnaall ();
│ │ │ │ │     void rreesseett ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ooppeerraattoorr==(()) hhaasshheerr(()) **********
│ │ │ │ │ +hhaasshheerr (hasher const&);
│ │ │ │ │  hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │  explicit hhaasshheerr (span data);
│ │ │ │ │  hhaasshheerr (char const* data, int len);
│ │ │ │ │ -hhaasshheerr (hasher const&);
│ │ │ │ │  this is the same as default constructing followed by a call to update(data,
│ │ │ │ │  len).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** uuppddaattee(()) **********
│ │ │ │ │ -hasher& uuppddaattee (span data);
│ │ │ │ │  hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ +hasher& uuppddaattee (span data);
│ │ │ │ │  append the following bytes to what is being hashed
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiinnaall(()) **********
│ │ │ │ │  sha1_hash ffiinnaall ();
│ │ │ │ │  returns the SHA-1 digest of the buffers previously passed to _u_p_d_a_t_e_(_) and the
│ │ │ │ │  _h_a_s_h_e_r constructor.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -189,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&);
│ │ │ │ │ -   hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │     explicit hhaasshheerr225566 (span data);
│ │ │ │ │     hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ -   hasher256& uuppddaattee (span data);
│ │ │ │ │ +   hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ +   hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │     hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │ +   hasher256& uuppddaattee (span data);
│ │ │ │ │     sha256_hash ffiinnaall ();
│ │ │ │ │     void rreesseett ();
│ │ │ │ │     ~~hhaasshheerr225566 ();
│ │ │ │ │  };
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** hhaasshheerr225566(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ -hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ -hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │  explicit hhaasshheerr225566 (span data);
│ │ │ │ │  hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ +hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ +hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │  this is the same as default constructing followed by a call to update(data,
│ │ │ │ │  len).
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** uuppddaattee(()) **********
│ │ │ │ │ -hasher256& uuppddaattee (span data);
│ │ │ │ │  hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │ +hasher256& uuppddaattee (span data);
│ │ │ │ │  append the following bytes to what is being hashed
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │  ********** ffiinnaall(()) **********
│ │ │ │ │  sha256_hash ffiinnaall ();
│ │ │ │ │  returns the SHA-1 digest of the buffers previously passed to _u_p_d_a_t_e_(_) and the
│ │ │ │ │  _h_a_s_h_e_r constructor.
│ │ │ │ │  [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -25,33 +25,33 @@
│ │ │ │  
        
│ │ │ │  
        Session
        
│ │ │ │  
        
│ │ │ │  
        session_params
        
│ │ │ │  
        session_proxy
        
│ │ │ │  
        session
        
│ │ │ │  
        session_handle
        
│ │ │ │ -
        write_session_params()
        
│ │ │ │  
        write_session_params_buf()
        
│ │ │ │ +
        write_session_params()
        
│ │ │ │  
        read_session_params()
        
│ │ │ │  
        
│ │ │ │  
        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_buffer()
        
│ │ │ │  
        make_magnet_uri()
        
│ │ │ │  
        parse_magnet_uri()
        
│ │ │ │  
        torrent_peer_equal()
        
│ │ │ │  
        truncate_files()
        
│ │ │ │  
        version()
        
│ │ │ │  
        socket_type_t
        
│ │ │ │  
        protocol_version
        
│ │ │ │ @@ -97,18 +97,18 @@
│ │ │ │  
        announce_entry
        
│ │ │ │  
        
│ │ │ │  
        Settings
        
│ │ │ │  
        
│ │ │ │  
        overview
        
│ │ │ │  
        settings_pack
        
│ │ │ │  
        generate_fingerprint()
        
│ │ │ │ -
        min_memory_usage()
        
│ │ │ │  
        high_performance_seed()
        
│ │ │ │ -
        setting_by_name()
        
│ │ │ │ +
        min_memory_usage()
        
│ │ │ │  
        name_for_setting()
        
│ │ │ │ +
        setting_by_name()
        
│ │ │ │  
        default_settings()
        
│ │ │ │  
        
│ │ │ │  
        DHT
        
│ │ │ │  
        
│ │ │ │  
        dht_state
        
│ │ │ │  
        dht_storage_counters
        
│ │ │ │  
        dht_storage_interface
        
│ │ │ │ ├── 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
│ │ │ │ │ -_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_(_)
│ │ │ │ │  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___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,18 +59,18 @@
│ │ │ │ │  _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_(_)
│ │ │ │ │ -_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_(_)
│ │ │ │ │ +_m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)
│ │ │ │ │  _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)
│ │ │ │ │ +_s_e_t_t_i_n_g___b_y___n_a_m_e_(_)
│ │ │ │ │  _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │  DHT
│ │ │ │ │  _d_h_t___s_t_a_t_e
│ │ │ │ │  _d_h_t___s_t_o_r_a_g_e___c_o_u_n_t_e_r_s
│ │ │ │ │  _d_h_t___s_t_o_r_a_g_e___i_n_t_e_r_f_a_c_e
│ │ │ │ │  _s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ │  _d_h_t___d_e_f_a_u_l_t___s_t_o_r_a_g_e___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/single-page-ref.html
│ │ │ │ @@ -55,95 +55,95 @@
│ │ │ │  
      • enum error_code_enum
        • 
│ │ │ │  
      • session_params
│ │ │ │  
        • 
│ │ │ │  
      • session_proxy
│ │ │ │  
        • 
│ │ │ │  
      • session
│ │ │ │  
        • 
│ │ │ │  
      • session_handle
│ │ │ │  
        • 
│ │ │ │ -
      • write_session_params_buf() read_session_params() write_session_params()
        • 
│ │ │ │ +
      • write_session_params() write_session_params_buf() read_session_params()
        • 
│ │ │ │  
      • web_seed_entry
│ │ │ │  
        • 
│ │ │ │  
      • load_torrent_limits
        • 
│ │ │ │  
      • torrent_info
│ │ │ │  
        • 
│ │ │ │  
      • sign_mutable_item()
        • 
│ │ │ │  
      • dht_default_storage_constructor()
        • 
│ │ │ │  
      • announce_flags_t
        • 
│ │ │ │  
      • read_resume_data()
        • 
│ │ │ │ -
      • write_resume_data_buf() write_resume_data()
        • 
│ │ │ │ -
      • write_torrent_file() write_torrent_file_buf()
        • 
│ │ │ │ +
      • write_resume_data() write_resume_data_buf()
        • 
│ │ │ │ +
      • write_torrent_file_buf() write_torrent_file()
        • 
│ │ │ │  
      • write_torrent_flags_t
        • 
│ │ │ │  
      • ed25519_create_seed()
        • 
│ │ │ │  
      • ed25519_create_keypair()
        • 
│ │ │ │  
      • ed25519_sign()
        • 
│ │ │ │  
      • ed25519_verify()
        • 
│ │ │ │  
      • ed25519_add_scalar()
        • 
│ │ │ │  
      • ed25519_key_exchange()
        • 
│ │ │ │ @@ -786,16 +786,16 @@
│ │ │ │  
        used by storage to return errors
│ │ │ │  also includes which underlying file the
│ │ │ │  error happened on
        
│ │ │ │  
        │ │ │ │  struct storage_error
│ │ │ │  {
│ │ │ │     explicit operator bool () const;
│ │ │ │ -   void file (file_index_t f);
│ │ │ │     file_index_t file () const;
│ │ │ │ +   void file (file_index_t f);
│ │ │ │  
│ │ │ │     error_code ec;
│ │ │ │     operation_t operation;
│ │ │ │  };
│ │ │ │  
        
│ │ │ │  [report issue]
        
│ │ │ │  
        bool()
        
│ │ │ │ @@ -804,16 +804,16 @@
│ │ │ │  
        
│ │ │ │  
        explicitly converts to true if this object represents an error, and
│ │ │ │  false if it does not.
        
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        file()
        
│ │ │ │  
        │ │ │ │ -void file (file_index_t f);
│ │ │ │  file_index_t file () const;
│ │ │ │ +void file (file_index_t f);
│ │ │ │  
        
│ │ │ │  
        set and query the index (in the torrent) of the file this error
│ │ │ │  occurred on. This may also have special values defined in
│ │ │ │  torrent_status.
        
│ │ │ │  [report issue]
        
│ │ │ │  
        ec
        
│ │ │ │  
        the error that occurred
        
│ │ │ │ @@ -2130,16 +2130,16 @@
│ │ │ │  
        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&& sp
│ │ │ │        , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │     session_params (settings_pack const& sp
│ │ │ │        , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │  
│ │ │ │     settings_pack settings;
│ │ │ │ @@ -2150,16 +2150,16 @@
│ │ │ │     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]
        
│ │ │ │  
        
│ │ │ │ @@ -2214,33 +2214,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 (session_proxy const&);
│ │ │ │     session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ -   session_proxy& operator= (session_proxy const&) &;
│ │ │ │     session_proxy (session_proxy&&) noexcept;
│ │ │ │ +   session_proxy ();
│ │ │ │ +   session_proxy& operator= (session_proxy const&) &;
│ │ │ │  };
│ │ │ │  
        
│ │ │ │ -
│ │ │ │ +
│ │ │ │  
│ │ │ │ -[report issue]
        
│ │ │ │ -
        ~session_proxy() operator=() session_proxy()
        
│ │ │ │ +[report issue]
        
│ │ │ │ +
        session_proxy() operator=() ~session_proxy()
        
│ │ │ │  
        │ │ │ │ -session_proxy ();
│ │ │ │  ~session_proxy ();
│ │ │ │  session_proxy (session_proxy const&);
│ │ │ │  session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ -session_proxy& operator= (session_proxy const&) &;
│ │ │ │  session_proxy (session_proxy&&) noexcept;
│ │ │ │ +session_proxy ();
│ │ │ │ +session_proxy& operator= (session_proxy const&) &;
│ │ │ │  
        
│ │ │ │  
        default constructor, does not refer to any session
│ │ │ │  implementation object.
        
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        
│ │ │ │  
        session
        
│ │ │ │ @@ -2255,49 +2255,49 @@
│ │ │ │  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&& params, session_flags_t flags);
│ │ │ │ -   explicit session (session_params&& params);
│ │ │ │ -   explicit session (session_params const& params);
│ │ │ │     session ();
│ │ │ │ +   explicit session (session_params&& params);
│ │ │ │     session (session_params const& params, session_flags_t flags);
│ │ │ │ -   session (session_params const& params, io_context& ios);
│ │ │ │ +   explicit session (session_params const& params);
│ │ │ │     session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +   session (session_params const& params, io_context& ios);
│ │ │ │     session (session_params&& params, io_context& ios);
│ │ │ │     session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │     ~session ();
│ │ │ │     session_proxy abort ();
│ │ │ │  };
│ │ │ │  
        
│ │ │ │  [report issue]
        
│ │ │ │  
        session()
        
│ │ │ │  
        │ │ │ │  session (session_params&& params, session_flags_t flags);
│ │ │ │ -explicit session (session_params&& params);
│ │ │ │ -explicit session (session_params const& params);
│ │ │ │  session ();
│ │ │ │ +explicit session (session_params&& params);
│ │ │ │  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 const& params, io_context& ios);
│ │ │ │  session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +session (session_params const& params, io_context& ios);
│ │ │ │  session (session_params&& params, io_context& ios);
│ │ │ │  session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │  
        
│ │ │ │  
        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
│ │ │ │ @@ -2354,77 +2354,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&& st);
│ │ │ │     void set_dht_state (dht::dht_state const& st);
│ │ │ │ -   torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ +   void set_dht_state (dht::dht_state&& st);
│ │ │ │     std::vector<torrent_handle> get_torrents () const;
│ │ │ │ -   void async_add_torrent (add_torrent_params&& params);
│ │ │ │ -   torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ +   torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │     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, error_code& ec);
│ │ │ │ +   torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ +   void async_add_torrent (add_torrent_params&& params);
│ │ │ │     torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ -   bool is_paused () const;
│ │ │ │ +   torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │     void resume ();
│ │ │ │ +   bool is_paused () const;
│ │ │ │     void pause ();
│ │ │ │     bool is_dht_running () const;
│ │ │ │     void set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ │     void add_dht_node (std::pair<std::string, int> const& node);
│ │ │ │     void dht_get_item (sha1_hash const& target);
│ │ │ │     void dht_get_item (std::array<char, 32> key
│ │ │ │        , std::string salt = std::string());
│ │ │ │     sha1_hash dht_put_item (entry data);
│ │ │ │     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_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_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │     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::function<std::shared_ptr<torrent_plugin>(
│ │ │ │        torrent_handle const&, client_data_t)> ext);
│ │ │ │     void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │     ip_filter get_ip_filter () const;
│ │ │ │     void set_ip_filter (ip_filter f);
│ │ │ │     void set_port_filter (port_filter const& f);
│ │ │ │ -   bool is_listening () const;
│ │ │ │ -   unsigned short listen_port () const;
│ │ │ │     unsigned short ssl_listen_port () const;
│ │ │ │ -   void set_peer_class_filter (ip_filter const& f);
│ │ │ │ +   unsigned short listen_port () const;
│ │ │ │ +   bool is_listening () const;
│ │ │ │     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 const&);
│ │ │ │     void apply_settings (settings_pack&&);
│ │ │ │     settings_pack get_settings () const;
│ │ │ │ -   alert* wait_for_alert (time_duration max_wait);
│ │ │ │ +   void apply_settings (settings_pack const&);
│ │ │ │     void set_alert_notify (std::function<void()> const& fun);
│ │ │ │     void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ -   void delete_port_mapping (port_mapping_t handle);
│ │ │ │ +   alert* wait_for_alert (time_duration max_wait);
│ │ │ │     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;
│ │ │ │ @@ -2456,24 +2456,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.
        
│ │ │ │  
        
│ │ │ │ @@ -2537,47 +2537,47 @@
│ │ │ │  void post_dht_stats ();
│ │ │ │  
        
│ │ │ │  
        This will cause a dht_stats_alert to be posted.
        
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        set_dht_state()
        
│ │ │ │  
        │ │ │ │ -void set_dht_state (dht::dht_state&& st);
│ │ │ │  void set_dht_state (dht::dht_state const& st);
│ │ │ │ +void set_dht_state (dht::dht_state&& st);
│ │ │ │  
        
│ │ │ │  
        set the DHT state for the session. This will be taken into account the
│ │ │ │  next time the DHT is started, as if it had been passed in via the
│ │ │ │  session_params on startup.
        
│ │ │ │ -
│ │ │ │ -[report issue]
        
│ │ │ │ -
        
│ │ │ │ -
        find_torrent() get_torrents()
        
│ │ │ │ +
│ │ │ │ +[report issue]
        
│ │ │ │ +
        
│ │ │ │ +
        get_torrents() find_torrent()
        
│ │ │ │  
        │ │ │ │ -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 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, error_code& ec);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ +void async_add_torrent (add_torrent_params&& params);
│ │ │ │  torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │  
        
│ │ │ │  
        You add torrents through the add_torrent() function where you give an
│ │ │ │  object with all the parameters. The add_torrent() overloads will block
│ │ │ │  until the torrent has been added (or failed to be added) and returns
│ │ │ │  an error code and a torrent_handle. In order to add torrents more
│ │ │ │  efficiently, consider using async_add_torrent() which returns
│ │ │ │  immediately, without waiting for the torrent to add. Notification of
│ │ │ │ @@ -2597,22 +2597,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() resume() is_paused()
        
│ │ │ │ +[report issue]
        
│ │ │ │ +
        
│ │ │ │ +
        is_paused() resume() 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
│ │ │ │ @@ -2721,21 +2721,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_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);
│ │ │ │ +void dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │  
        
│ │ │ │  
        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
│ │ │ │ @@ -2848,31 +2848,31 @@
│ │ │ │  anti-virus software by connecting to SMTP, FTP ports.
        
│ │ │ │  
│ │ │ │  
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        listen_port() is_listening() ssl_listen_port()
        
│ │ │ │  
        │ │ │ │ -bool is_listening () const;
│ │ │ │ -unsigned short listen_port () const;
│ │ │ │  unsigned short ssl_listen_port () const;
│ │ │ │ +unsigned short 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]
        
│ │ │ │ -
        
│ │ │ │ -
        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;
│ │ │ │ +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.
        
│ │ │ │ @@ -2945,21 +2945,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]
        
│ │ │ │ -
        
│ │ │ │ -
        get_peer_class() set_peer_class()
        
│ │ │ │ +
│ │ │ │ +[report issue]
        
│ │ │ │ +
        
│ │ │ │ +
        set_peer_class() get_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
│ │ │ │ @@ -3004,30 +3004,30 @@
│ │ │ │  advised to remove them from the back of the queue, to minimize the
│ │ │ │  shifting.
        
│ │ │ │  
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        get_settings() apply_settings()
        
│ │ │ │  
        │ │ │ │ -void apply_settings (settings_pack const&);
│ │ │ │  void apply_settings (settings_pack&&);
│ │ │ │  settings_pack get_settings () const;
│ │ │ │ +void apply_settings (settings_pack const&);
│ │ │ │  
        
│ │ │ │  
        Applies the settings specified by the settings_pack s. This is an
│ │ │ │  asynchronous operation that will return immediately and actually apply
│ │ │ │  the settings to the main thread of libtorrent some time later.
        
│ │ │ │ -
│ │ │ │  
│ │ │ │ -[report issue]
        
│ │ │ │ -
        
│ │ │ │ -
        set_alert_notify() pop_alerts() wait_for_alert()
        
│ │ │ │ +
│ │ │ │ +[report issue]
        
│ │ │ │ +
        
│ │ │ │ +
        pop_alerts() wait_for_alert() set_alert_notify()
        
│ │ │ │  
        │ │ │ │ -alert* wait_for_alert (time_duration max_wait);
│ │ │ │  void set_alert_notify (std::function<void()> const& fun);
│ │ │ │  void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ +alert* wait_for_alert (time_duration max_wait);
│ │ │ │  
        
│ │ │ │  
        Alerts is the main mechanism for libtorrent to report errors and
│ │ │ │  events. pop_alerts fills in the vector passed to it with pointers
│ │ │ │  to new alerts. The session still owns these alerts and they will stay
│ │ │ │  valid until the next time pop_alerts is called. You may not delete
│ │ │ │  the alert objects.
        
│ │ │ │  
        It is safe to call pop_alerts from multiple different threads, as
│ │ │ │ @@ -3078,16 +3078,16 @@
│ │ │ │  alert::type() but can also be queries from a concrete type via
│ │ │ │  T::alert_type, as a static constant.
        
│ │ │ │  
│ │ │ │  [report issue]
        
│ │ │ │  
        
│ │ │ │  
        delete_port_mapping() add_port_mapping()
        
│ │ │ │  
        │ │ │ │ -void delete_port_mapping (port_mapping_t handle);
│ │ │ │  std::vector<port_mapping_t> add_port_mapping (portmap_protocol t, int external_port, int local_port);
│ │ │ │ +void delete_port_mapping (port_mapping_t handle);
│ │ │ │  
        
│ │ │ │  
        add_port_mapping adds one or more port forwards on UPnP and/or NAT-PMP,
│ │ │ │  whichever is enabled. A mapping is created for each listen socket
│ │ │ │  in the session. The return values are all handles referring to the
│ │ │ │  port mappings that were just created. Pass them to delete_port_mapping()
│ │ │ │  to remove them.
        
│ │ │ │  [report issue]
        
│ │ │ │ @@ -3153,30 +3153,30 @@
│ │ │ │  [report issue]
        
│ │ │ │  
        reopen_map_ports
        
│ │ │ │  
        This option indicates if the ports are mapped using natpmp
│ │ │ │  and upnp. If mapping was already made, they are deleted and added
│ │ │ │  again. This only works if natpmp and/or upnp are configured to be
│ │ │ │  enable.
        
│ │ │ │  
        
│ │ │ │ +
│ │ │ │  
│ │ │ │ -
│ │ │ │ -[report issue]
        │ │ │ │ +[report issue]
        │ │ │ │
    │ │ │ │ -
    │ │ │ │ -

    write_session_params_buf() read_session_params() write_session_params()

    │ │ │ │ +
    │ │ │ │ +

    write_session_params() write_session_params_buf() read_session_params()

    │ │ │ │

    Declared in "libtorrent/session_params.hpp"

    │ │ │ │ 
    │ │ │ │  session_params read_session_params (bdecode_node const& e
│ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │  std::vector<char> write_session_params_buf (session_params const& sp
│ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ -session_params read_session_params (span<char const> buf
│ │ │ │ -   , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │  entry write_session_params (session_params const& sp
│ │ │ │     , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ +session_params read_session_params (span<char const> buf
│ │ │ │ +   , 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. │ │ │ │ @@ -3304,69 +3304,69 @@ │ │ │ │

    │ │ │ │

    torrent_info

    │ │ │ │

    Declared in "libtorrent/torrent_info.hpp"

    │ │ │ │

    the torrent_info class holds the information found in a .torrent file.

    │ │ │ │ 
    │ │ │ │  class torrent_info
│ │ │ │  {
│ │ │ │ -   torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +   torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │     torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -   explicit torrent_info (std::string const& filename);
│ │ │ │ +   torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │     torrent_info (char const* buffer, int size);
│ │ │ │ -   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -   explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +   torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │     torrent_info (torrent_info const& t);
│ │ │ │ -   explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -   torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │     torrent_info (std::string const& filename, error_code& ec);
│ │ │ │     torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -   torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -   torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ +   explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ +   explicit torrent_info (std::string const& filename);
│ │ │ │ +   explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +   explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │     ~torrent_info ();
│ │ │ │     file_storage const& files () const;
│ │ │ │     file_storage const& orig_files () const;
│ │ │ │     void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │     void remap_files (file_storage const& f);
│ │ │ │ -   std::vector<announce_entry> const& trackers () const;
│ │ │ │ +   void clear_trackers ();
│ │ │ │ +   void add_tracker (std::string const& url, int tier = 0);
│ │ │ │     void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ -   void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ -   void clear_trackers ();
│ │ │ │ -   std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ +   std::vector<announce_entry> const& trackers () const;
│ │ │ │     std::vector<std::string> collections () const;
│ │ │ │ -   void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +   std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ +   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());
│ │ │ │     void add_http_seed (std::string const& url
│ │ │ │        , std::string const& extern_auth = std::string()
│ │ │ │        , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ -   std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ +   void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │     std::int64_t total_size () const;
│ │ │ │ -   int num_pieces () const;
│ │ │ │     int piece_length () const;
│ │ │ │ +   int num_pieces () 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;
│ │ │ │     sha1_hash info_hash () const noexcept;
│ │ │ │     info_hash_t const& info_hashes () const;
│ │ │ │ -   bool v1 () 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;
│ │ │ │     bool is_i2p () const;
│ │ │ │     int piece_size (piece_index_t index) const;
│ │ │ │ -   sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │     char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ +   sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │     bool is_loaded () const;
│ │ │ │     const std::string& name () const;
│ │ │ │     std::time_t creation_date () const;
│ │ │ │     const std::string& creator () const;
│ │ │ │     const std::string& comment () const;
│ │ │ │     std::vector<std::pair<std::string, int>> const& nodes () const;
│ │ │ │     void add_node (std::pair<std::string, int> const& node);
│ │ │ │ @@ -3376,27 +3376,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 (char const* buffer, int size, error_code& ec);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │  torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -explicit torrent_info (std::string const& filename);
│ │ │ │ +torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │  torrent_info (char const* buffer, int size);
│ │ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │  torrent_info (torrent_info const& t);
│ │ │ │ -explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │  torrent_info (std::string const& filename, error_code& ec);
│ │ │ │  torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ +explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ +explicit torrent_info (std::string const& filename);
│ │ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │
    │ │ │ │

    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 │ │ │ │ @@ -3483,64 +3483,64 @@ │ │ │ │

    │ │ │ │

    Remaps the file storage to a new file layout. This can be used to, for │ │ │ │ instance, download all data in a torrent to a single file, or to a │ │ │ │ number of fixed size sector aligned files, regardless of the number │ │ │ │ and sizes of the files in the torrent.

    │ │ │ │

    The new specified file_storage must have the exact same size as │ │ │ │ the current one.

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

    clear_trackers() trackers() add_tracker()

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

    trackers() add_tracker() clear_trackers()

    │ │ │ │ 
    │ │ │ │ -std::vector<announce_entry> const& trackers () const;
│ │ │ │ +void clear_trackers ();
│ │ │ │ +void add_tracker (std::string const& url, int tier = 0);
│ │ │ │  void add_tracker (std::string const& url, int tier
│ │ │ │        , announce_entry::tracker_source source);
│ │ │ │ -void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ -void clear_trackers ();
│ │ │ │ +std::vector<announce_entry> const& trackers () const;
│ │ │ │
    │ │ │ │

    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<sha1_hash> similar_torrents () const;
│ │ │ │  std::vector<std::string> collections () const;
│ │ │ │ +std::vector<sha1_hash> similar_torrents () const;
│ │ │ │
    │ │ │ │

    These two functions are related to BEP 38 (mutable torrents). The │ │ │ │ vectors returned from these correspond to the "similar" and │ │ │ │ "collections" keys in the .torrent file. Both info-hashes and │ │ │ │ collections from within the info-dict and from outside of it are │ │ │ │ included.

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

    web_seeds() add_http_seed() set_web_seeds() add_url_seed()

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

    set_web_seeds() web_seeds() add_http_seed() add_url_seed()

    │ │ │ │ 
    │ │ │ │ -void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +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());
│ │ │ │  void add_http_seed (std::string const& url
│ │ │ │        , std::string const& extern_auth = std::string()
│ │ │ │        , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ -std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ +void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │
    │ │ │ │

    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 │ │ │ │ @@ -3565,16 +3565,16 @@ │ │ │ │ the total size will be larger than the sum of all (regular) file │ │ │ │ sizes.

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

    num_pieces() piece_length()

    │ │ │ │ 
    │ │ │ │ -int num_pieces () const;
│ │ │ │  int piece_length () const;
│ │ │ │ +int num_pieces () const;
│ │ │ │
    │ │ │ │

    piece_length() and num_pieces() returns the number of byte │ │ │ │ for each piece and the total number of pieces, respectively. The │ │ │ │ difference between piece_size() and piece_length() is that │ │ │ │ piece_size() takes the piece index as argument and gives you the │ │ │ │ exact size of that piece. It will always be the same as │ │ │ │ piece_length() except in the case of the last piece, which may be │ │ │ │ @@ -3583,48 +3583,48 @@ │ │ │ │

    │ │ │ │

    blocks_per_piece()

    │ │ │ │ 
    │ │ │ │  int blocks_per_piece () const;
│ │ │ │
    │ │ │ │

    returns the number of blocks there are in the typical piece. There │ │ │ │ may be fewer in the last piece)

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

    end_piece() last_piece() piece_range()

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

    last_piece() returns the index to the last piece in the torrent and │ │ │ │ end_piece() returns the index to the one-past-end piece in the │ │ │ │ torrent │ │ │ │ piece_range() returns an implementation-defined type that can be │ │ │ │ used as the container in a range-for loop. Where the values are the │ │ │ │ indices of all pieces in the file_storage.

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

    info_hash() info_hashes()

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

    info_hashes() info_hash()

    │ │ │ │ 
    │ │ │ │  sha1_hash info_hash () const noexcept;
│ │ │ │  info_hash_t const& info_hashes () const;
│ │ │ │
    │ │ │ │

    returns the info-hash of the torrent. For BitTorrent v2 support, use │ │ │ │ info_hashes() to get an object that may hold both a v1 and v2 │ │ │ │ info-hash

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

    v1() v2()

    │ │ │ │ 
    │ │ │ │ -bool v1 () const;
│ │ │ │  bool v2 () const;
│ │ │ │ +bool v1 () const;
│ │ │ │
    │ │ │ │

    returns whether this torrent has v1 and/or v2 metadata, respectively. │ │ │ │ Hybrid torrents have both. These are shortcuts for │ │ │ │ info_hashes().has_v1() and info_hashes().has_v2() calls.

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

    num_files()

    │ │ │ │ @@ -3697,21 +3697,21 @@ │ │ │ │
    │ │ │ │

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

    │ │ │ │ 
    │ │ │ │ -sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │  char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ +sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │
    │ │ │ │

    hash_for_piece() takes a piece-index and returns the 20-bytes │ │ │ │ sha1-hash for that piece and info_hash() returns the 20-bytes │ │ │ │ sha1-hash for the info-section of the torrent file. │ │ │ │ hash_for_piece_ptr() returns a pointer to the 20 byte sha1 digest │ │ │ │ for the piece. Note that the string is not 0-terminated.

    │ │ │ │ [report issue]
    │ │ │ │ @@ -4319,20 +4319,20 @@ │ │ │ │

    Note

    │ │ │ │

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

    │ │ │ │
    │ │ │ │ 
    │ │ │ │  struct info_hash_t
│ │ │ │  {
│ │ │ │ +   explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ +   explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │     info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │     info_hash_t () noexcept = default;
│ │ │ │ -   explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ -   explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ -   bool has_v1 () const;
│ │ │ │     bool has (protocol_version v) const;
│ │ │ │ +   bool has_v1 () const;
│ │ │ │     bool has_v2 () const;
│ │ │ │     sha1_hash get (protocol_version v) const;
│ │ │ │     sha1_hash get_best () const;
│ │ │ │     friend bool operator!= (info_hash_t const& lhs, info_hash_t const& rhs);
│ │ │ │     friend bool operator== (info_hash_t const& lhs, info_hash_t const& rhs) noexcept;
│ │ │ │     template <typename F> void for_each (F f) const;
│ │ │ │     bool operator< (info_hash_t const& o) const;
│ │ │ │ @@ -4341,32 +4341,32 @@
│ │ │ │     sha1_hash v1;
│ │ │ │     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 (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │  info_hash_t () noexcept = default;
│ │ │ │ -explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ -explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │
    │ │ │ │

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

    │ │ │ │

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

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

    has() has_v1() has_v2()

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

    has() has_v2() has_v1()

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

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

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

    get()

    │ │ │ │ @@ -4443,30 +4443,30 @@ │ │ │ │
    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_parsed() load_torrent_file() load_torrent_buffer()

    │ │ │ │

    Declared in "libtorrent/load_torrent.hpp"

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

    These functions load the content of a .torrent file into an │ │ │ │ add_torrent_params object. │ │ │ │ @@ -4482,17 +4482,17 @@ │ │ │ │ │ │ │ │ │ │ │ │ [report issue]

    │ │ │ │
    │ │ │ │

    make_magnet_uri()

    │ │ │ │

    Declared in "libtorrent/magnet_uri.hpp"

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

    Generates a magnet URI from the specified torrent.

    │ │ │ │

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

    │ │ │ │
    │ │ │ │ ti, info_hashes, url_seeds, dht_nodes, │ │ │ │ @@ -4512,16 +4512,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, error_code& ec);
│ │ │ │  void parse_magnet_uri (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │ +add_torrent_params parse_magnet_uri (string_view uri, error_code& ec);
│ │ │ │  add_torrent_params parse_magnet_uri (string_view uri);
│ │ │ │
    │ │ │ │

    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.

    │ │ │ │ @@ -5336,16 +5336,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);
│ │ │ │ @@ -5372,16 +5372,16 @@
│ │ │ │  to it, use weak_ptr.
    
│ │ │ │  
    If this function throws an exception, the connection will be closed.
    
│ │ │ │  
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    on_piece_failed() on_piece_pass()

    │ │ │ │ 
    │ │ │ │ -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]
    │ │ │ │
    │ │ │ │ @@ -5466,51 +5466,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_allowed_fast (piece_index_t); │ │ │ │ - virtual bool on_have (piece_index_t); │ │ │ │ virtual bool on_choke (); │ │ │ │ - virtual bool on_have_none (); │ │ │ │ + virtual bool on_not_interested (); │ │ │ │ virtual bool on_bitfield (bitfield const& /*bitfield*/); │ │ │ │ + virtual bool on_have_all (); │ │ │ │ + virtual bool on_unchoke (); │ │ │ │ + virtual bool on_have (piece_index_t); │ │ │ │ + virtual bool on_allowed_fast (piece_index_t); │ │ │ │ + virtual bool on_have_none (); │ │ │ │ virtual bool on_interested (); │ │ │ │ - virtual bool on_not_interested (); │ │ │ │ virtual bool on_dont_have (piece_index_t); │ │ │ │ - virtual bool on_have_all (); │ │ │ │ virtual bool on_request (peer_request const&); │ │ │ │ - virtual bool on_unchoke (); │ │ │ │ virtual bool on_piece (peer_request const& /*piece*/ │ │ │ │ , span<char const> /*buf*/); │ │ │ │ + virtual bool on_cancel (peer_request const&); │ │ │ │ virtual bool on_suggest (piece_index_t); │ │ │ │ virtual bool on_reject (peer_request const&); │ │ │ │ - virtual bool on_cancel (peer_request const&); │ │ │ │ virtual void sent_cancel (peer_request const&); │ │ │ │ virtual void sent_request (peer_request const&); │ │ │ │ - virtual void sent_have_none (); │ │ │ │ - virtual void sent_reject_request (peer_request const&); │ │ │ │ - virtual void sent_suggest (piece_index_t); │ │ │ │ - virtual void sent_allow_fast (piece_index_t); │ │ │ │ virtual void sent_have_all (); │ │ │ │ + virtual void sent_reject_request (peer_request const&); │ │ │ │ virtual void sent_choke (); │ │ │ │ - virtual void sent_interested (); │ │ │ │ + virtual void sent_allow_fast (piece_index_t); │ │ │ │ + virtual void sent_suggest (piece_index_t); │ │ │ │ + virtual void sent_have_none (); │ │ │ │ virtual void sent_unchoke (); │ │ │ │ virtual void sent_have (piece_index_t); │ │ │ │ - virtual void sent_piece (peer_request const&); │ │ │ │ virtual void sent_not_interested (); │ │ │ │ + virtual void sent_piece (peer_request const&); │ │ │ │ + virtual void sent_interested (); │ │ │ │ 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()

    │ │ │ │ 
    │ │ │ │ @@ -5560,39 +5560,39 @@
│ │ │ │  virtual bool on_extension_handshake (bdecode_node const&);
│ │ │ │
    │ │ │ │

    called when the extension handshake from the other end is received │ │ │ │ if this returns false, it means that this extension isn't │ │ │ │ supported by this peer. It will result in this peer_plugin │ │ │ │ being removed from the peer_connection and destructed. │ │ │ │ this is not called for web seeds

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

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

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

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

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

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

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

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

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

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

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

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

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

    called after a choke message has been sent to the peer

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

    sent_payload()

    │ │ │ │ 
    │ │ │ │  virtual void sent_payload (int /* bytes */);
│ │ │ │ @@ -5665,16 +5665,16 @@
│ │ │ │
    │ │ │ │

    this is not called for web seeds

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

    on_piece_failed() on_piece_pass()

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

    │ │ │ │ 
    │ │ │ │ @@ -5694,16 +5694,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()

    │ │ │ │ 
    │ │ │ │ @@ -5727,50 +5727,50 @@
│ │ │ │  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;
│ │ │ │ -   peer_plugin const* find_plugin (string_view type) const;
│ │ │ │     void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │ +   peer_plugin const* find_plugin (string_view type) const;
│ │ │ │     bool is_seed () const;
│ │ │ │     bool upload_only () const;
│ │ │ │ -   bool has_piece (piece_index_t i) 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;
│ │ │ │     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_connecting () const;
│ │ │ │ -   bool is_outgoing () const;
│ │ │ │ +   bool is_disconnecting () const;
│ │ │ │     void disconnect (error_code const& ec, operation_t op
│ │ │ │        , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ -   bool is_disconnecting () const;
│ │ │ │ -   bool ignore_unchoke_slots () const;
│ │ │ │ +   bool is_connecting () const;
│ │ │ │ +   bool is_outgoing () const;
│ │ │ │     bool on_local_network () const;
│ │ │ │ +   bool ignore_unchoke_slots () const;
│ │ │ │     bool failed () 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);
│ │ │ │ -   time_point time_of_last_unchoke () const;
│ │ │ │     std::time_t last_seen_complete () 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;
│ │ │ │ +   bool operator< (peer_connection_handle const& o) const;
│ │ │ │     std::shared_ptr<peer_connection> native_handle () const;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    bt_peer_connection_handle

    │ │ │ │

    Declared in "libtorrent/peer_connection_handle.hpp"

    │ │ │ │ @@ -5878,67 +5878,67 @@ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ void add_file_borrow (string_view filename │ │ │ │ , std::string const& path, std::int64_t file_size │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ + void add_file (error_code& ec, std::string const& path, std::int64_t file_size │ │ │ │ + , file_flags_t file_flags = {} │ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ + , char const* root_hash = nullptr); │ │ │ │ void add_file_borrow (error_code& ec, string_view filename │ │ │ │ , std::string const& path, std::int64_t file_size │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ - void add_file (error_code& ec, std::string const& path, std::int64_t file_size │ │ │ │ - , file_flags_t file_flags = {} │ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ - , char const* root_hash = nullptr); │ │ │ │ void 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; │ │ │ │ - void set_num_pieces (int n); │ │ │ │ int num_pieces () const; │ │ │ │ + void set_num_pieces (int n); │ │ │ │ piece_index_t end_piece () const; │ │ │ │ piece_index_t last_piece () const; │ │ │ │ index_range<piece_index_t> piece_range () const noexcept; │ │ │ │ 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; │ │ │ │ void set_name (std::string const& n); │ │ │ │ std::string const& name () const; │ │ │ │ void swap (file_storage& ti) noexcept; │ │ │ │ void canonicalize (); │ │ │ │ + sha1_hash hash (file_index_t index) const; │ │ │ │ + char const* root_ptr (file_index_t const index) const; │ │ │ │ + std::string file_path (file_index_t index, std::string const& save_path = "") const; │ │ │ │ + std::int64_t file_offset (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::time_t mtime (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 symlink (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 file_path (file_index_t index, std::string const& save_path = "") const; │ │ │ │ - sha1_hash hash (file_index_t index) const; │ │ │ │ - char const* root_ptr (file_index_t const index) 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; │ │ │ │ + int file_first_block_node (file_index_t index) const; │ │ │ │ std::uint32_t file_path_hash (file_index_t index, std::string const& save_path) const; │ │ │ │ void all_path_hashes (std::unordered_set<std::uint32_t>& table) const; │ │ │ │ file_flags_t file_flags (file_index_t index) const; │ │ │ │ bool file_absolute_path (file_index_t index) const; │ │ │ │ - file_index_t file_index_at_piece (piece_index_t piece) const; │ │ │ │ file_index_t file_index_at_offset (std::int64_t offset) const; │ │ │ │ + file_index_t file_index_at_piece (piece_index_t piece) 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; │ │ │ │ @@ -5974,23 +5974,23 @@ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ void add_file_borrow (string_view filename │ │ │ │ , std::string const& path, std::int64_t file_size │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ +void add_file (error_code& ec, std::string const& path, std::int64_t file_size │ │ │ │ + , file_flags_t file_flags = {} │ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ + , char const* root_hash = nullptr); │ │ │ │ void add_file_borrow (error_code& ec, string_view filename │ │ │ │ , std::string const& path, std::int64_t file_size │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ -void add_file (error_code& ec, std::string const& path, std::int64_t file_size │ │ │ │ - , file_flags_t file_flags = {} │ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ - , char const* root_hash = nullptr); │ │ │ │ │ │ │ │

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

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

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

    num_pieces() set_num_pieces()

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

    set and get the number of pieces in the torrent

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

    end_piece()

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

    set_piece_length() piece_length()

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

    piece_length() set_piece_length()

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

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

    │ │ │ │ [report issue]
    │ │ │ │ @@ -6165,18 +6165,18 @@ │ │ │ │
    │ │ │ │

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

    │ │ │ │ 
    │ │ │ │  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]
    │ │ │ │ @@ -6190,37 +6190,37 @@ │ │ │ │
    │ │ │ │

    canonicalize()

    │ │ │ │ 
    │ │ │ │  void canonicalize ();
│ │ │ │
    │ │ │ │

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

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

    file_num_blocks() file_piece_range() file_num_pieces()

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

    file_num_pieces() file_num_blocks() file_piece_range()

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

    │ │ │ │ 
    │ │ │ │ -int file_first_block_node (file_index_t index) const;
│ │ │ │  int file_first_piece_node (file_index_t index) const;
│ │ │ │ +int file_first_block_node (file_index_t index) const;
│ │ │ │
    │ │ │ │

    index of first piece node in the merkle tree

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

    file_path_hash()

    │ │ │ │ 
    │ │ │ │  std::uint32_t file_path_hash (file_index_t index, std::string const& save_path) const;
│ │ │ │ @@ -6304,16 +6304,16 @@
│ │ │ │  have an absolute path, i.e. is not anchored in the save path of the
│ │ │ │  torrent.
    
│ │ │ │  
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    file_index_at_piece() file_index_at_offset()

    │ │ │ │ 
    │ │ │ │ -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_at_piece (piece_index_t piece) 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;
│ │ │ │ @@ -6560,38 +6560,38 @@
│ │ │ │  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;
│ │ │ │ +   operator void* () const = delete;
│ │ │ │     client_data_t& operator= (void*) = delete;
│ │ │ │     client_data_t& operator= (void const*) = delete;
│ │ │ │     operator void const* () const = 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()

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

    construct a nullptr client data

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

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

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

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

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

    we don't allow type-unsafe operations

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

    add_torrent_params

    │ │ │ │

    Declared in "libtorrent/add_torrent_params.hpp"

    │ │ │ │ @@ -6976,16 +6976,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
│ │ │ │ @@ -6999,16 +6999,16 @@
│ │ │ │     };
│ │ │ │  };
│ │ │ │
    │ │ │ │ │ │ │ │ [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()

    │ │ │ │ @@ -7079,16 +7079,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,
│ │ │ │ @@ -7096,20 +7096,20 @@
│ │ │ │  
│ │ │ │     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()

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

    │ │ │ │
    │ │ │ │ @@ -7248,109 +7248,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, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │     void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ +   void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │     void read_piece (piece_index_t piece) const;
│ │ │ │     bool have_piece (piece_index_t piece) const;
│ │ │ │     void post_peer_info () const;
│ │ │ │     void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ -   torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │     void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +   torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │     void post_download_queue () const;
│ │ │ │ -   std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │     void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ +   std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │     void clear_piece_deadlines () const;
│ │ │ │     void reset_piece_deadline (piece_index_t index) const;
│ │ │ │     void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │     void 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 replace_trackers (std::vector<announce_entry> const&) 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;
│ │ │ │ +   void remove_http_seed (std::string const& url) const;
│ │ │ │     std::set<std::string> http_seeds () const;
│ │ │ │     void add_http_seed (std::string const& url) const;
│ │ │ │ -   void remove_http_seed (std::string const& url) const;
│ │ │ │     void add_extension (
│ │ │ │        std::function<std::shared_ptr<torrent_plugin>(torrent_handle const&, client_data_t)> const& ext
│ │ │ │        , client_data_t userdata = client_data_t{});
│ │ │ │     bool set_metadata (span<char const> metadata) const;
│ │ │ │     bool is_valid () const;
│ │ │ │ -   void pause (pause_flags_t flags = {}) const;
│ │ │ │     void resume () const;
│ │ │ │ -   void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ -   void set_flags (torrent_flags_t flags) const;
│ │ │ │ +   void pause (pause_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 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 (resume_data_flags_t flags) const;
│ │ │ │     bool need_save_resume_data () const;
│ │ │ │ -   void queue_position_up () const;
│ │ │ │ -   void queue_position_top () const;
│ │ │ │     void queue_position_bottom () const;
│ │ │ │ +   void queue_position_top () const;
│ │ │ │     void queue_position_down () const;
│ │ │ │ +   void queue_position_up () const;
│ │ │ │     queue_position_t queue_position () const;
│ │ │ │     void queue_position_set (queue_position_t p) const;
│ │ │ │     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<torrent_info> torrent_file_with_hashes () const;
│ │ │ │     std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │     std::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │ -   void post_piece_availability () const;
│ │ │ │     void piece_availability (std::vector<int>& avail) const;
│ │ │ │ -   download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ +   void post_piece_availability () const;
│ │ │ │     void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ +   download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │     void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │     std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │     void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ -   std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │     void file_priority (file_index_t index, download_priority_t priority) 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 force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ -   void force_lsd_announce () const;
│ │ │ │     void force_dht_announce () const;
│ │ │ │ +   void force_lsd_announce () const;
│ │ │ │ +   void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │     void scrape_tracker (int idx = -1) const;
│ │ │ │ +   void set_upload_limit (int limit) const;
│ │ │ │ +   void set_download_limit (int limit) const;
│ │ │ │     int upload_limit () const;
│ │ │ │     int download_limit () const;
│ │ │ │ -   void set_download_limit (int limit) const;
│ │ │ │ -   void set_upload_limit (int limit) const;
│ │ │ │     void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │        , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │     void clear_peers ();
│ │ │ │ -   int max_uploads () const;
│ │ │ │     void set_max_uploads (int max_uploads) const;
│ │ │ │ +   int max_uploads () const;
│ │ │ │     int max_connections () const;
│ │ │ │     void set_max_connections (int max_connections) const;
│ │ │ │     void move_storage (std::string const& save_path
│ │ │ │        , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │        ) const;
│ │ │ │     void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │     info_hash_t info_hashes () const;
│ │ │ │     sha1_hash info_hash () const;
│ │ │ │ -   bool operator== (const torrent_handle& h) const;
│ │ │ │     bool operator< (const torrent_handle& h) const;
│ │ │ │ +   bool operator== (const torrent_handle& h) const;
│ │ │ │     bool operator!= (const torrent_handle& h) const;
│ │ │ │     std::uint32_t id () const;
│ │ │ │     std::shared_ptr<torrent> native_handle () const;
│ │ │ │     client_data_t userdata () const;
│ │ │ │     bool in_session () const;
│ │ │ │  
│ │ │ │     static constexpr add_piece_flags_t overwrite_existing  = 0_bit;
│ │ │ │ @@ -7383,16 +7383,16 @@
│ │ │ │
    │ │ │ │

    constructs a torrent handle that does not refer to a torrent. │ │ │ │ i.e. is_valid() will return false.

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

    add_piece()

    │ │ │ │ 
    │ │ │ │ -void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │  void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ +void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │
    │ │ │ │

    This function will write data to the storage as piece piece, │ │ │ │ as if it had been downloaded from a peer.

    │ │ │ │

    By default, data that's already been downloaded is not overwritten by │ │ │ │ this buffer. If you trust this data to be correct (and pass the piece │ │ │ │ hash check) you may pass the overwrite_existing flag. This will │ │ │ │ instruct libtorrent to overwrite any data that may already have been │ │ │ │ @@ -7452,16 +7452,16 @@ │ │ │ │ the vector contains information about that particular peer. See │ │ │ │ peer_info.

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

    post_status() status()

    │ │ │ │ 
    │ │ │ │ -torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │  void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │
    │ │ │ │

    status() will return a structure with information about the status │ │ │ │ of this torrent. If the torrent_handle is invalid, it will throw │ │ │ │ system_error exception. See torrent_status. The flags │ │ │ │ argument filters what information is returned in the torrent_status. │ │ │ │ Some information in there is relatively expensive to calculate, and if │ │ │ │ you're not interested in it (and see performance issues), you can │ │ │ │ @@ -7477,28 +7477,28 @@ │ │ │ │ what to include are defined in this class.

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

    post_download_queue() get_download_queue()

    │ │ │ │ 
    │ │ │ │  void post_download_queue () const;
│ │ │ │ -std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │  void get_download_queue (std::vector<partial_piece_info>& 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]
    │ │ │ │ -
    │ │ │ │ -

    reset_piece_deadline() clear_piece_deadlines() set_piece_deadline()

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

    set_piece_deadline() reset_piece_deadline() clear_piece_deadlines()

    │ │ │ │ 
    │ │ │ │  void clear_piece_deadlines () const;
│ │ │ │  void reset_piece_deadline (piece_index_t index) const;
│ │ │ │  void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │
    │ │ │ │

    This function sets or resets the deadline associated with a specific │ │ │ │ piece index (index). libtorrent will attempt to download this │ │ │ │ @@ -7558,24 +7558,24 @@ │ │ │ │

    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() post_trackers() add_tracker() replace_trackers()

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

    trackers() add_tracker() post_trackers() 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 replace_trackers (std::vector<announce_entry> const&) 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 │ │ │ │ @@ -7607,22 +7607,22 @@ │ │ │ │ pieces from it, unless it's paused, queued, checking or seeding. │ │ │ │ remove_url_seed() removes the given url if it exists already. │ │ │ │ url_seeds() return a set of the url seeds currently in this │ │ │ │ torrent. Note that URLs that fails may be removed automatically from │ │ │ │ the list.

    │ │ │ │

    See http seeding for more information.

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

    http_seeds() remove_http_seed() add_http_seed()

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

    http_seeds() add_http_seed() remove_http_seed()

    │ │ │ │ 
    │ │ │ │ +void remove_http_seed (std::string const& url) const;
│ │ │ │  std::set<std::string> http_seeds () const;
│ │ │ │  void add_http_seed (std::string const& url) const;
│ │ │ │ -void remove_http_seed (std::string const& url) const;
│ │ │ │
    │ │ │ │

    These functions are identical as the *_url_seed() variants, but │ │ │ │ they operate on BEP 17 web seeds instead of BEP 19.

    │ │ │ │

    See http seeding for more information.

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

    add_extension()

    │ │ │ │ @@ -7664,21 +7664,21 @@ │ │ │ │ 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;
│ │ │ │ +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.

    │ │ │ │ @@ -7689,24 +7689,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]
    │ │ │ │ -
    │ │ │ │ -

    unset_flags() set_flags() flags()

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

    flags() unset_flags() set_flags()

    │ │ │ │ 
    │ │ │ │ -void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ -void set_flags (torrent_flags_t flags) const;
│ │ │ │  void unset_flags (torrent_flags_t flags) const;
│ │ │ │  torrent_flags_t flags () const;
│ │ │ │ +void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ +void 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 │ │ │ │ @@ -7862,26 +7862,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_up() queue_position_top() queue_position() queue_position_bottom() queue_position_down()

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

    queue_position() queue_position_top() queue_position_bottom() queue_position_up() queue_position_down()

    │ │ │ │ 
    │ │ │ │ -void queue_position_up () const;
│ │ │ │ -void queue_position_top () const;
│ │ │ │  void queue_position_bottom () const;
│ │ │ │ +void queue_position_top () const;
│ │ │ │  void queue_position_down () const;
│ │ │ │ +void queue_position_up () const;
│ │ │ │  queue_position_t queue_position () const;
│ │ │ │
    │ │ │ │

    Every torrent that is added is assigned a queue position exactly one │ │ │ │ greater than the greatest queue position of all existing torrents. │ │ │ │ Torrents that are being seeded have -1 as their queue position, since │ │ │ │ they're no longer in line to be downloaded.

    │ │ │ │

    When a torrent is removed or turns into a seed, all torrents with │ │ │ │ @@ -7982,39 +7982,39 @@ │ │ │ │ 

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

    prioritize_pieces() piece_priority() get_piece_priorities()

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

    piece_priority() prioritize_pieces() get_piece_priorities()

    │ │ │ │ 
    │ │ │ │ -download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │  void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ +download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │  void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │  std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │  void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │
    │ │ │ │

    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. │ │ │ │ @@ -8039,23 +8039,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]
    │ │ │ │ -
    │ │ │ │ -

    get_file_priorities() prioritize_files() file_priority()

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

    file_priority() prioritize_files() get_file_priorities()

    │ │ │ │ 
    │ │ │ │ -std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │  void file_priority (file_index_t index, download_priority_t priority) 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;
│ │ │ │
    │ │ │ │

    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 │ │ │ │ @@ -8079,23 +8079,23 @@ │ │ │ │ file_prio_alert.

    │ │ │ │

    When combining file- and piece priorities, the resume file will record │ │ │ │ both. When loading the resume data, the file priorities will be applied │ │ │ │ first, then the piece priorities.

    │ │ │ │

    Moving data from a file into the part file is currently not │ │ │ │ supported. If a file has its priority set to 0 after it has already │ │ │ │ been created, it will not be moved into the partfile.

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

    force_reannounce() force_dht_announce() force_lsd_announce()

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

    force_dht_announce() force_reannounce() force_lsd_announce()

    │ │ │ │ 
    │ │ │ │ -void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ -void force_lsd_announce () const;
│ │ │ │  void force_dht_announce () const;
│ │ │ │ +void force_lsd_announce () const;
│ │ │ │ +void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) 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 │ │ │ │ @@ -8120,24 +8120,24 @@ │ │ │ │

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

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

    upload_limit() download_limit() set_download_limit() set_upload_limit()

    │ │ │ │ 
    │ │ │ │ +void set_upload_limit (int limit) const;
│ │ │ │ +void set_download_limit (int limit) const;
│ │ │ │  int upload_limit () const;
│ │ │ │  int download_limit () const;
│ │ │ │ -void set_download_limit (int limit) const;
│ │ │ │ -void set_upload_limit (int limit) const;
│ │ │ │
    │ │ │ │

    set_upload_limit will limit the upload bandwidth used by this │ │ │ │ particular torrent to the limit you set. It is given as the number of │ │ │ │ bytes per second the torrent is allowed to upload. │ │ │ │ set_download_limit works the same way but for download bandwidth │ │ │ │ instead of upload bandwidth. Note that setting a higher limit on a │ │ │ │ torrent then the global limit │ │ │ │ @@ -8174,27 +8174,27 @@ │ │ │ │ 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()

    │ │ │ │ 
    │ │ │ │ -int max_uploads () const;
│ │ │ │  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]
    │ │ │ │ -
    │ │ │ │ -

    max_connections() set_max_connections()

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

    set_max_connections() 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 │ │ │ │ @@ -8260,36 +8260,36 @@ │ │ │ │

    rename_file()

    │ │ │ │ 
    │ │ │ │  void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │
    │ │ │ │

    Renames the file with the given index asynchronously. The rename │ │ │ │ operation is complete when either a file_renamed_alert or │ │ │ │ file_rename_failed_alert is posted.

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

    info_hash() info_hashes()

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

    info_hashes() info_hash()

    │ │ │ │ 
    │ │ │ │  info_hash_t info_hashes () const;
│ │ │ │  sha1_hash info_hash () const;
│ │ │ │
    │ │ │ │

    returns the info-hash(es) of the torrent. If this handle is to a │ │ │ │ torrent that hasn't loaded yet (for instance by being added) by a │ │ │ │ URL, the returned value is undefined. │ │ │ │ The info_hash() returns the SHA-1 info-hash for v1 torrents and a │ │ │ │ truncated hash for v2 torrents. For the full v2 info-hash, use │ │ │ │ info_hashes() instead.

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

    operator<() operator!=() operator==()

    │ │ │ │ +

    operator==() operator<() operator!=()

    │ │ │ │ 
    │ │ │ │ -bool operator== (const torrent_handle& h) const;
│ │ │ │  bool operator< (const torrent_handle& h) const;
│ │ │ │ +bool operator== (const torrent_handle& h) const;
│ │ │ │  bool operator!= (const torrent_handle& h) const;
│ │ │ │
    │ │ │ │

    comparison operators. The order of the torrents is unspecified │ │ │ │ but stable.

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

    id()

    │ │ │ │ @@ -8933,18 +8933,18 @@ │ │ │ │

    The disk buffer holder acts like a unique_ptr that frees a disk buffer │ │ │ │ when it's destructed

    │ │ │ │

    If this buffer holder is moved-from, default constructed or reset, │ │ │ │ data() will return nullptr.

    │ │ │ │ 
    │ │ │ │  struct disk_buffer_holder
│ │ │ │  {
│ │ │ │ -   disk_buffer_holder& operator= (disk_buffer_holder&&) & noexcept;
│ │ │ │     disk_buffer_holder (disk_buffer_holder&&) noexcept;
│ │ │ │ -   disk_buffer_holder (disk_buffer_holder const&) = delete;
│ │ │ │ +   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 (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;
│ │ │ │ @@ -9019,17 +9019,17 @@
│ │ │ │  
    settings_interface
    
│ │ │ │  
    Declared in "libtorrent/settings_pack.hpp"
    
│ │ │ │  
    the common interface to settings_pack and the internal representation of
│ │ │ │  settings.
    
│ │ │ │  
    │ │ │ │  struct settings_interface
│ │ │ │  {
│ │ │ │ -   virtual void set_int (int name, int val) = 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 bool has_val (int name) const = 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]
    │ │ │ │ @@ -9386,27 +9386,27 @@ │ │ │ │

    Declared in "libtorrent/alert_types.hpp"

    │ │ │ │

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

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

    new_name() old_name()

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

    returns the new and previous file name, respectively.

    │ │ │ │ [report issue]
    │ │ │ │
    index
    │ │ │ │
    refers to the index of the file that was renamed,
    │ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │ @@ -10135,17 +10135,17 @@ │ │ │ │ std::string message () const override; │ │ │ │ char const* storage_path () const; │ │ │ │ char const* old_path () const; │ │ │ │ │ │ │ │ static constexpr alert_category_t static_category = alert_category::storage; │ │ │ │ }; │ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]
    │ │ │ │ -

    storage_path() old_path()

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

    old_path() storage_path()

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

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

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

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

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

    nodes() num_nodes()

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

    num_nodes() nodes()

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

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

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

    Declared in "libtorrent/alert_types.hpp"

    │ │ │ │

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

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

    samples() num_samples()

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

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

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

    num_nodes()

    │ │ │ │ @@ -11921,16 +11921,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
    │ │ │ │ @@ -12529,26 +12529,26 @@ │ │ │ │

    Declared in "libtorrent/performance_counters.hpp"

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

    inc_stats_counter() operator[]()

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

    returns the new value

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

    stats_metric

    │ │ │ │

    Declared in "libtorrent/session_stats.hpp"

    │ │ │ │ @@ -12631,20 +12631,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&&);
│ │ │ │ -   ip_filter& operator= (ip_filter const&);
│ │ │ │ -   ip_filter (ip_filter const&);
│ │ │ │     ip_filter& operator= (ip_filter&&);
│ │ │ │ -   ip_filter ();
│ │ │ │     ~ip_filter ();
│ │ │ │ +   ip_filter ();
│ │ │ │ +   ip_filter (ip_filter const&);
│ │ │ │ +   ip_filter (ip_filter&&);
│ │ │ │ +   ip_filter& operator= (ip_filter const&);
│ │ │ │     bool empty () const;
│ │ │ │     void add_rule (address const& first, address const& last, std::uint32_t flags);
│ │ │ │     std::uint32_t access (address const& addr) const;
│ │ │ │     filter_tuple_t export_filter () const;
│ │ │ │  
│ │ │ │     enum access_flags
│ │ │ │     {
│ │ │ │ @@ -12728,20 +12728,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 (port_filter&&);
│ │ │ │ +   port_filter& operator= (port_filter&&);
│ │ │ │ +   port_filter (port_filter const&);
│ │ │ │ +   port_filter ();
│ │ │ │     ~port_filter ();
│ │ │ │     port_filter& operator= (port_filter const&);
│ │ │ │ -   port_filter ();
│ │ │ │ -   port_filter (port_filter const&);
│ │ │ │ -   port_filter& operator= (port_filter&&);
│ │ │ │ -   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,
│ │ │ │     };
│ │ │ │ @@ -12809,46 +12809,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 (preformatted_type);
│ │ │ │ -   entry (list_type);
│ │ │ │     entry (span<char const>);
│ │ │ │ -   entry (integer_type);
│ │ │ │     entry (dictionary_type);
│ │ │ │ +   entry (integer_type);
│ │ │ │ +   entry (preformatted_type);
│ │ │ │ +   entry (list_type);
│ │ │ │     entry (U v);
│ │ │ │     entry (data_type t);
│ │ │ │     entry (bdecode_node const& n);
│ │ │ │     entry& operator= (list_type) &;
│ │ │ │ +   entry& operator= (dictionary_type) &;
│ │ │ │ +   entry& operator= (integer_type) &;
│ │ │ │ +   entry& operator= (entry&&) & noexcept;
│ │ │ │ +   entry& operator= (preformatted_type) &;
│ │ │ │ +   entry& operator= (bdecode_node const&) &;
│ │ │ │     entry& operator= (entry const&) &;
│ │ │ │     entry& operator= (span<char const>) &;
│ │ │ │ -   entry& operator= (bdecode_node const&) &;
│ │ │ │ -   entry& operator= (preformatted_type) &;
│ │ │ │ -   entry& operator= (entry&&) & noexcept;
│ │ │ │ -   entry& operator= (integer_type) &;
│ │ │ │ -   entry& operator= (dictionary_type) &;
│ │ │ │     entry& operator= (U v) &;
│ │ │ │ -   integer_type const& integer () const;
│ │ │ │     integer_type& integer ();
│ │ │ │ +   list_type const& list () const;
│ │ │ │ +   preformatted_type const& preformatted () const;
│ │ │ │     list_type& list ();
│ │ │ │     dictionary_type& dict ();
│ │ │ │ -   preformatted_type& preformatted ();
│ │ │ │     string_type& string ();
│ │ │ │ -   preformatted_type const& preformatted () const;
│ │ │ │     string_type const& string () const;
│ │ │ │     dictionary_type const& dict () const;
│ │ │ │ -   list_type const& list () const;
│ │ │ │ +   preformatted_type& preformatted ();
│ │ │ │ +   integer_type const& integer () const;
│ │ │ │     void swap (entry& e);
│ │ │ │     entry& operator[] (string_view key);
│ │ │ │     entry const& operator[] (string_view key) const;
│ │ │ │ -   entry* find_key (string_view key);
│ │ │ │     entry const* find_key (string_view key) const;
│ │ │ │ +   entry* find_key (string_view key);
│ │ │ │     std::string to_string (bool single_line = false) const;
│ │ │ │  
│ │ │ │     enum data_type
│ │ │ │     {
│ │ │ │        int_t,
│ │ │ │        string_t,
│ │ │ │        list_t,
│ │ │ │ @@ -12864,19 +12864,19 @@
│ │ │ │  data_type type () const;
│ │ │ │  
    
│ │ │ │  
    returns the concrete type of the entry
    
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    entry()

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

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

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

    entry()

    │ │ │ │ @@ -12893,42 +12893,42 @@ │ │ │ │ │ │ │ │

    construct from bdecode_node parsed form (see bdecode())

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

    operator=()

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

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

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

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

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

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

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

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

    │ │ │ │

    If you want to create an entry you give it the type you want it to │ │ │ │ @@ -12988,16 +12988,16 @@ │ │ │ │

    The const version of operator[] will only return a reference to an │ │ │ │ existing element at the given key. If the key is not found, it will │ │ │ │ throw system_error.

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

    find_key()

    │ │ │ │ 
    │ │ │ │ -entry* find_key (string_view key);
│ │ │ │  entry const* find_key (string_view key) const;
│ │ │ │ +entry* find_key (string_view key);
│ │ │ │
    │ │ │ │

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

    │ │ │ │

    They will look for an element at the given key in the dictionary, if │ │ │ │ the element cannot be found, they will return nullptr. If an element │ │ │ │ with the given key is found, the return a pointer to it.

    │ │ │ │ [report issue]
    │ │ │ │ @@ -13127,61 +13127,61 @@ │ │ │ │

    This class holds state for creating a torrent. After having added │ │ │ │ all information to it, call create_torrent::generate() to generate │ │ │ │ the torrent. The entry that's returned can then be bencoded into a │ │ │ │ .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 = {});
│ │ │ │ +   explicit create_torrent (torrent_info const& ti);
│ │ │ │     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;
│ │ │ │ -   bool is_v2_only () 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;
│ │ │ │     index_range<piece_index_t::diff_type> file_piece_range (file_index_t f);
│ │ │ │     std::int64_t total_size () const;
│ │ │ │ -   int piece_size (piece_index_t i) const;
│ │ │ │     int piece_length () const;
│ │ │ │ -   void add_similar_torrent (sha1_hash ih);
│ │ │ │ +   int piece_size (piece_index_t i) const;
│ │ │ │     void add_collection (string_view c);
│ │ │ │ +   void add_similar_torrent (sha1_hash ih);
│ │ │ │  
│ │ │ │     static constexpr create_flags_t modification_time  = 2_bit;
│ │ │ │     static constexpr create_flags_t symlinks  = 3_bit;
│ │ │ │     static constexpr create_flags_t v2_only  = 5_bit;
│ │ │ │     static constexpr create_flags_t v1_only  = 6_bit;
│ │ │ │     static constexpr create_flags_t canonical_files  = 7_bit;
│ │ │ │     static constexpr create_flags_t no_attributes  = 8_bit;
│ │ │ │     static constexpr create_flags_t canonical_files_no_tail_padding  = 9_bit;
│ │ │ │  };
│ │ │ │
    │ │ │ │ [report issue]
    │ │ │ │

    create_torrent()

    │ │ │ │ 
    │ │ │ │ -explicit create_torrent (torrent_info const& ti);
│ │ │ │  explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ │        , create_flags_t flags = {});
│ │ │ │ +explicit create_torrent (torrent_info const& ti);
│ │ │ │
    │ │ │ │

    The piece_size is the size of each piece in bytes. It must be a │ │ │ │ power of 2 and a minimum of 16 kiB. If a piece size of 0 is │ │ │ │ specified, a piece_size will be set automatically.

    │ │ │ │

    The flags arguments specifies options for the torrent creation. It can │ │ │ │ be any combination of the flags defined by create_flags_t.

    │ │ │ │

    The file_storage (fs) parameter defines the files, sizes and │ │ │ │ @@ -13345,16 +13345,16 @@ │ │ │ │

    The string is not the path to the cert, it's the actual content of the │ │ │ │ certificate.

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

    set_priv() 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]
    │ │ │ │
    │ │ │ │ @@ -13394,27 +13394,27 @@ │ │ │ │ │ │ │ │

    the total number of bytes of all files and pad files

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

    piece_size() piece_length()

    │ │ │ │ 
    │ │ │ │ -int piece_size (piece_index_t i) const;
│ │ │ │  int piece_length () const;
│ │ │ │ +int piece_size (piece_index_t i) 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()

    │ │ │ │ 
    │ │ │ │ -void add_similar_torrent (sha1_hash ih);
│ │ │ │  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 │ │ │ │ to share files with this torrent. A torrent may have more than one │ │ │ │ collection and more than one similar torrents. For more information, │ │ │ │ see BEP 38.

    │ │ │ │ @@ -13479,17 +13479,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:

    │ │ │ │ 
    │ │ │ │ @@ -13502,29 +13502,29 @@
│ │ │ │  
    The flags argument should be the same as the flags passed to the create_torrent
│ │ │ │  constructor.
    
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    set_piece_hashes()

    │ │ │ │

    Declared in "libtorrent/create_torrent.hpp"

    │ │ │ │ 
    │ │ │ │ -void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ -void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , settings_interface const& settings
│ │ │ │ -   , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ +   , std::function<void(piece_index_t)> const& f);
│ │ │ │  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);
│ │ │ │ +void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ +   , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p, error_code& ec);
│ │ │ │  inline void set_piece_hashes (create_torrent& t, std::string const& p);
│ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ -   , 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);
│ │ │ │
    │ │ │ │

    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);
│ │ │ │ @@ -13538,49 +13538,49 @@
│ │ │ │  
    bitfield
    
│ │ │ │  
    Declared in "libtorrent/bitfield.hpp"
    
│ │ │ │  
    The bitfield type stores any number of bits as a bitfield
│ │ │ │  in a heap allocated array.
    
│ │ │ │  
    │ │ │ │  struct bitfield
│ │ │ │  {
│ │ │ │ -   bitfield () noexcept = default;
│ │ │ │ -   bitfield (int bits, bool val);
│ │ │ │ -   bitfield (bitfield const& rhs);
│ │ │ │ -   bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │     bitfield (char const* b, int bits);
│ │ │ │ +   bitfield (bitfield const& rhs);
│ │ │ │ +   bitfield (int bits, bool val);
│ │ │ │ +   bitfield () noexcept = default;
│ │ │ │     explicit bitfield (int bits);
│ │ │ │ +   bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │     void assign (char const* b, int const bits);
│ │ │ │ -   bool operator[] (int index) const noexcept;
│ │ │ │     bool get_bit (int index) const noexcept;
│ │ │ │ +   bool operator[] (int index) const noexcept;
│ │ │ │     void set_bit (int index) noexcept;
│ │ │ │     void clear_bit (int index) noexcept;
│ │ │ │     bool all_set () const noexcept;
│ │ │ │     bool none_set () const noexcept;
│ │ │ │     int size () const noexcept;
│ │ │ │     int num_words () const noexcept;
│ │ │ │     int num_bytes () const noexcept;
│ │ │ │     bool empty () const noexcept;
│ │ │ │ -   char const* data () const noexcept;
│ │ │ │     char* data () noexcept;
│ │ │ │ +   char const* data () const noexcept;
│ │ │ │     void swap (bitfield& rhs) noexcept;
│ │ │ │     int count () const noexcept;
│ │ │ │     int find_first_set () const noexcept;
│ │ │ │     int find_last_clear () const noexcept;
│ │ │ │     bool operator== (lt::bitfield const& rhs) const;
│ │ │ │  };
│ │ │ │  
    
│ │ │ │  [report issue]
    
│ │ │ │  
    bitfield()
    
│ │ │ │  
    │ │ │ │ -bitfield () noexcept = default;
│ │ │ │ -bitfield (int bits, bool val);
│ │ │ │ -bitfield (bitfield const& rhs);
│ │ │ │ -bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │  bitfield (char const* b, int bits);
│ │ │ │ +bitfield (bitfield const& rhs);
│ │ │ │ +bitfield (int bits, bool val);
│ │ │ │ +bitfield () noexcept = default;
│ │ │ │  explicit bitfield (int bits);
│ │ │ │ +bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │  
    
│ │ │ │  
    constructs a new bitfield. The default constructor creates an empty
│ │ │ │  bitfield. bits is the size of the bitfield (specified in bits).
│ │ │ │  val is the value to initialize the bits to. If not specified
│ │ │ │  all bits are initialized to 0.
    
│ │ │ │  
    The constructor taking a pointer b and bits copies a bitfield
│ │ │ │  from the specified buffer, and bits number of bits (rounded up to
│ │ │ │ @@ -13589,21 +13589,21 @@
│ │ │ │  
    
│ │ │ │  
    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]
    
│ │ │ │ -
    
│ │ │ │ -
    operator[]() get_bit()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    
│ │ │ │ +
    get_bit() operator[]()
    
│ │ │ │  
    │ │ │ │ -bool operator[] (int index) const noexcept;
│ │ │ │  bool get_bit (int index) const noexcept;
│ │ │ │ +bool operator[] (int index) const noexcept;
│ │ │ │  
    
│ │ │ │  
    query bit at index. Returns true if bit is 1, otherwise false.
    
│ │ │ │  
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    clear_bit() set_bit()
    
│ │ │ │  
    │ │ │ │ @@ -13655,16 +13655,16 @@
│ │ │ │  bool empty () const noexcept;
│ │ │ │  
    
│ │ │ │  
    returns true if the bitfield has zero size.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    data()
    
│ │ │ │  
    │ │ │ │ -char const* data () const noexcept;
│ │ │ │  char* data () noexcept;
│ │ │ │ +char const* data () const noexcept;
│ │ │ │  
    
│ │ │ │  
    returns a pointer to the internal buffer of the bitfield, or
│ │ │ │  nullptr if it's empty.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    swap()
    
│ │ │ │  
    │ │ │ │ @@ -13710,32 +13710,32 @@
│ │ │ │  
    The built-in software version of sha1-algorithm was implemented
│ │ │ │  by Steve Reid and released as public domain.
│ │ │ │  For more info, see src/sha1.cpp.
    
│ │ │ │  
    │ │ │ │  class hasher
│ │ │ │  {
│ │ │ │     hasher ();
│ │ │ │ -   explicit hasher (span<char const> data);
│ │ │ │ -   hasher& operator= (hasher const&) &;
│ │ │ │     hasher (char const* data, int len);
│ │ │ │     hasher (hasher const&);
│ │ │ │ +   explicit hasher (span<char const> data);
│ │ │ │ +   hasher& operator= (hasher const&) &;
│ │ │ │     hasher& update (span<char const> data);
│ │ │ │     hasher& update (char const* data, int len);
│ │ │ │     sha1_hash final ();
│ │ │ │     void reset ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    hasher() operator=()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    operator=() hasher()
    
│ │ │ │  
    │ │ │ │ -explicit hasher (span<char const> data);
│ │ │ │ -hasher& operator= (hasher const&) &;
│ │ │ │  hasher (char const* data, int len);
│ │ │ │  hasher (hasher const&);
│ │ │ │ +explicit hasher (span<char const> data);
│ │ │ │ +hasher& operator= (hasher const&) &;
│ │ │ │  
    
│ │ │ │  
    this is the same as default constructing followed by a call to
│ │ │ │  update(data, len).
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    update()
    
│ │ │ │  
    │ │ │ │ @@ -13765,41 +13765,41 @@
│ │ │ │  
    hasher256
    
│ │ │ │  
    Declared in "libtorrent/hasher.hpp"
    
│ │ │ │  
    │ │ │ │  class hasher256
│ │ │ │  {
│ │ │ │     hasher256 ();
│ │ │ │     hasher256 (hasher256 const&);
│ │ │ │ -   hasher256 (char const* data, int len);
│ │ │ │ -   hasher256& operator= (hasher256 const&) &;
│ │ │ │     explicit hasher256 (span<char const> data);
│ │ │ │ -   hasher256& update (span<char const> data);
│ │ │ │ +   hasher256& operator= (hasher256 const&) &;
│ │ │ │ +   hasher256 (char const* data, int len);
│ │ │ │     hasher256& update (char const* data, int len);
│ │ │ │ +   hasher256& update (span<char const> data);
│ │ │ │     sha256_hash final ();
│ │ │ │     void reset ();
│ │ │ │     ~hasher256 ();
│ │ │ │  };
│ │ │ │  
    
│ │ │ │ -
│ │ │ │ -[report issue]
    
│ │ │ │ -
    operator=() hasher256()
    
│ │ │ │ +
│ │ │ │ +[report issue]
    
│ │ │ │ +
    hasher256() operator=()
    
│ │ │ │  
    │ │ │ │  hasher256 (hasher256 const&);
│ │ │ │ -hasher256 (char const* data, int len);
│ │ │ │ -hasher256& operator= (hasher256 const&) &;
│ │ │ │  explicit hasher256 (span<char const> data);
│ │ │ │ +hasher256& operator= (hasher256 const&) &;
│ │ │ │ +hasher256 (char const* data, int len);
│ │ │ │  
    
│ │ │ │  
    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 ();
│ │ │ │ @@ -14483,19 +14483,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&) &;
│ │ │ │     explicit announce_entry (string_view u);
│ │ │ │ +   announce_entry (announce_entry const&);
│ │ │ │     ~announce_entry ();
│ │ │ │     announce_entry ();
│ │ │ │ -   announce_entry (announce_entry const&);
│ │ │ │ +   announce_entry& operator= (announce_entry const&) &;
│ │ │ │  
│ │ │ │     enum tracker_source
│ │ │ │     {
│ │ │ │        source_torrent,
│ │ │ │        source_client,
│ │ │ │        source_magnet_link,
│ │ │ │        source_tex,
│ │ │ │ @@ -14507,23 +14507,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& operator= (announce_entry const&) &;
│ │ │ │  explicit announce_entry (string_view u);
│ │ │ │ +announce_entry (announce_entry const&);
│ │ │ │  ~announce_entry ();
│ │ │ │  announce_entry ();
│ │ │ │ -announce_entry (announce_entry const&);
│ │ │ │ +announce_entry& operator= (announce_entry const&) &;
│ │ │ │  
    
│ │ │ │  
    constructs a tracker announce entry with u as the URL.
    
│ │ │ │  [report issue]
    
│ │ │ │  
    
│ │ │ │  
    enum tracker_source
    
│ │ │ │  
    Declared in "libtorrent/announce_entry.hpp"
    
│ │ │ │
    │ │ │ │ @@ -19098,24 +19098,24 @@ │ │ │ │ i2p_port).

    │ │ │ │ 
    │ │ │ │  struct settings_pack final : settings_interface
│ │ │ │  {
│ │ │ │     friend  void apply_pack_impl (settings_pack const*
│ │ │ │        , aux::session_settings_single_thread&
│ │ │ │        , std::vector<void(aux::session_impl::*)()>*);
│ │ │ │ -   void set_int (int name, int val) override;
│ │ │ │     void set_str (int name, std::string val) override;
│ │ │ │ -   void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │     void set_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;
│ │ │ │     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,
│ │ │ │ @@ -19185,23 +19185,23 @@
│ │ │ │        socks5,
│ │ │ │        socks5_pw,
│ │ │ │        http,
│ │ │ │        http_pw,
│ │ │ │     };
│ │ │ │  };
│ │ │ │
    │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]
    │ │ │ │ -

    set_int() set_bool() set_str()

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

    set_str() set_bool() set_int()

    │ │ │ │ 
    │ │ │ │ -void set_int (int name, int val) override;
│ │ │ │  void set_str (int name, std::string val) override;
│ │ │ │ -void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │  void set_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;
│ │ │ │
    │ │ │ │

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

    │ │ │ │ @@ -19227,17 +19227,17 @@ │ │ │ │

    clear a specific setting from the pack

    │ │ │ │ │ │ │ │ │ │ │ │ [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]
    │ │ │ │ @@ -19683,18 +19683,18 @@ │ │ │ │ pieces, instead of reading it all into memory before hashing.

    │ │ │ │

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

    │ │ │ │

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

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

    setting_by_name() name_for_setting()

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

    name_for_setting() setting_by_name()

    │ │ │ │

    Declared in "libtorrent/settings_pack.hpp"

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

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

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

    │ │ │ │

    There are 5 different types of nodes, see type_t.

    │ │ │ │ 
    │ │ │ │  struct bdecode_node
│ │ │ │  {
│ │ │ │     bdecode_node () = default;
│ │ │ │ +   bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ +   bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │     bdecode_node (bdecode_node const&);
│ │ │ │     bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ -   bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │ -   bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │     type_t type () const noexcept;
│ │ │ │     explicit operator bool () const noexcept;
│ │ │ │     bdecode_node non_owning () const;
│ │ │ │ -   span<char const> data_section () const noexcept;
│ │ │ │     std::ptrdiff_t data_offset () const noexcept;
│ │ │ │ +   span<char const> data_section () const noexcept;
│ │ │ │ +   bdecode_node list_at (int i) const;
│ │ │ │     std::int64_t list_int_value_at (int i
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ -   bdecode_node list_at (int i) const;
│ │ │ │     int list_size () const;
│ │ │ │     string_view list_string_value_at (int i
│ │ │ │        , string_view default_val = string_view()) const;
│ │ │ │ -   bdecode_node dict_find_int (string_view key) const;
│ │ │ │ -   int dict_size () const;
│ │ │ │ -   bdecode_node dict_find_list (string_view key) const;
│ │ │ │ -   bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -   bdecode_node dict_find_string (string_view key) 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_view key) const;
│ │ │ │ +   std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ +   int dict_size () const;
│ │ │ │ +   bdecode_node dict_find_int (string_view key) const;
│ │ │ │ +   bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +   bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ +   bdecode_node dict_find_list (string_view key) const;
│ │ │ │     string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) const;
│ │ │ │ -   std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ -   std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │     std::int64_t int_value () const;
│ │ │ │ -   std::ptrdiff_t string_offset () const;
│ │ │ │     string_view string_value () const;
│ │ │ │ -   int string_length () const;
│ │ │ │ +   std::ptrdiff_t string_offset () const;
│ │ │ │     char const* string_ptr () 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
│ │ │ │ @@ -19768,23 +19768,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&) &;
│ │ │ │ -bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │
    │ │ │ │

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

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

    type()

    │ │ │ │ 
    │ │ │ │ @@ -19807,66 +19807,66 @@
│ │ │ │  
    return a non-owning reference to this node. This is useful to refer to
│ │ │ │  the root node without copying it in assignments.
    
│ │ │ │  
│ │ │ │  [report issue]
    │ │ │ │
    │ │ │ │

    data_section() data_offset()

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

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

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

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

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

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

    │ │ │ │ 
    │ │ │ │ +bdecode_node list_at (int i) const;
│ │ │ │  std::int64_t list_int_value_at (int i
│ │ │ │        , std::int64_t default_val = 0) const;
│ │ │ │ -bdecode_node list_at (int i) const;
│ │ │ │  int list_size () 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_find_dict() dict_at() dict_find_int() dict_size() dict_at_node() dict_find_int_value() dict_find() dict_find_list() dict_find_string_value() dict_find_string()

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

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

    │ │ │ │ 
    │ │ │ │ -bdecode_node dict_find_int (string_view key) const;
│ │ │ │ -int dict_size () const;
│ │ │ │ -bdecode_node dict_find_list (string_view key) const;
│ │ │ │ -bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -bdecode_node dict_find_string (string_view key) 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_view key) const;
│ │ │ │ +std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ +int dict_size () const;
│ │ │ │ +bdecode_node dict_find_int (string_view key) const;
│ │ │ │ +bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ +bdecode_node dict_find_list (string_view key) const;
│ │ │ │  string_view dict_find_string_value (string_view key
│ │ │ │        , string_view default_value = string_view()) const;
│ │ │ │ -std::pair<string_view, bdecode_node> dict_at (int i) 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.

    │ │ │ │ @@ -19881,25 +19881,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_length() string_ptr() string_offset() string_value()

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

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

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

    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 │ │ │ │ @@ -20360,33 +20360,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);
│ │ │ │
    │ │ │ │

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

    │ │ │ │ + │ │ │ │ +[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);
│ │ │ │  entry write_torrent_file (add_torrent_params const& atp, write_torrent_flags_t flags);
│ │ │ │ +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);
│ │ │ │
    │ │ │ │

    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 │ │ │ │ @@ -20460,18 +20460,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_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _s_e_s_s_i_o_n___p_r_o_x_y_(_) │ │ │ │ │ + o _s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _~_s_e_s_s_i_o_n___p_r_o_x_y_(_) │ │ │ │ │ * _s_e_s_s_i_o_n │ │ │ │ │ o _s_e_s_s_i_o_n_(_) │ │ │ │ │ o _s_e_s_s_i_o_n_(_) │ │ │ │ │ o _~_s_e_s_s_i_o_n_(_) │ │ │ │ │ o _a_b_o_r_t_(_) │ │ │ │ │ * _s_e_s_s_i_o_n___h_a_n_d_l_e │ │ │ │ │ o _i_s___v_a_l_i_d_(_) │ │ │ │ │ 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_(_)_ _r_e_s_u_m_e_(_)_ _i_s___p_a_u_s_e_d_(_) │ │ │ │ │ + o _i_s___p_a_u_s_e_d_(_)_ _r_e_s_u_m_e_(_)_ _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 _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 _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 _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 _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 _s_e_t___p_e_e_r___c_l_a_s_s_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s_(_) │ │ │ │ │ o _r_e_m_o_v_e___t_o_r_r_e_n_t_(_) │ │ │ │ │ o _g_e_t___s_e_t_t_i_n_g_s_(_)_ _a_p_p_l_y___s_e_t_t_i_n_g_s_(_) │ │ │ │ │ - o _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _p_o_p___a_l_e_r_t_s_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_) │ │ │ │ │ + o _p_o_p___a_l_e_r_t_s_(_)_ _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_(_) │ │ │ │ │ o _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_)_ _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_) │ │ │ │ │ o _r_e_o_p_e_n___n_e_t_w_o_r_k___s_o_c_k_e_t_s_(_) │ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_) │ │ │ │ │ - * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) │ │ │ │ │ + * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) │ │ │ │ │ * _w_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 _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 _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 _w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_) │ │ │ │ │ + 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 _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)_ _c_o_l_l_e_c_t_i_o_n_s_(_) │ │ │ │ │ + o _s_e_t___w_e_b___s_e_e_d_s_(_)_ _w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_) │ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_) │ │ │ │ │ o _n_u_m___p_i_e_c_e_s_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_) │ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_) │ │ │ │ │ - o _e_n_d___p_i_e_c_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)_ _p_i_e_c_e___r_a_n_g_e_(_) │ │ │ │ │ - o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_) │ │ │ │ │ + o _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_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_(_)_ _h_a_s___v_1_(_)_ _h_a_s___v_2_(_) │ │ │ │ │ + o _h_a_s_(_)_ _h_a_s___v_2_(_)_ _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___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___f_i_l_e_(_)_ _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 │ │ │ │ │ @@ -164,20 +164,20 @@ │ │ │ │ │ * _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___n_o_n_e_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _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___h_a_v_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___h_a_v_e___a_l_l_(_) │ │ │ │ │ - _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___u_n_c_h_o_k_e_(_)_ _o_n___c_h_o_k_e_(_) │ │ │ │ │ + o _o_n___c_h_o_k_e_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___h_a_v_e___a_l_l_(_) │ │ │ │ │ + _o_n___u_n_c_h_o_k_e_(_)_ _o_n___h_a_v_e_(_)_ _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___d_o_n_t___h_a_v_e_(_) │ │ │ │ │ + _o_n___r_e_q_u_e_s_t_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _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___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___p_i_e_c_e_(_)_ _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_i_e_c_e_(_)_ _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___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___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_(_) │ │ │ │ │ @@ -200,25 +200,25 @@ │ │ │ │ │ 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 _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 _r_o_o_t_(_)_ _r_o_o_t___p_t_r_(_)_ _f_i_l_e___n_a_m_e_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _s_y_m_l_i_n_k_(_)_ _f_i_l_e___p_a_t_h_(_) │ │ │ │ │ - _f_i_l_e___o_f_f_s_e_t_(_)_ _f_i_l_e___s_i_z_e_(_)_ _h_a_s_h_(_)_ _m_t_i_m_e_(_) │ │ │ │ │ - o _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)_ _f_i_l_e___n_u_m___p_i_e_c_e_s_(_) │ │ │ │ │ + o _f_i_l_e___o_f_f_s_e_t_(_)_ _s_y_m_l_i_n_k_(_)_ _r_o_o_t_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _h_a_s_h_(_)_ _r_o_o_t___p_t_r_(_) │ │ │ │ │ + _f_i_l_e___p_a_t_h_(_)_ _m_t_i_m_e_(_)_ _f_i_l_e___s_i_z_e_(_)_ _f_i_l_e___n_a_m_e_(_) │ │ │ │ │ + o _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_) │ │ │ │ │ o _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_) │ │ │ │ │ o _f_i_l_e___p_a_t_h___h_a_s_h_(_) │ │ │ │ │ o _a_l_l___p_a_t_h___h_a_s_h_e_s_(_) │ │ │ │ │ o _f_i_l_e___f_l_a_g_s_(_) │ │ │ │ │ o _f_i_l_e___a_b_s_o_l_u_t_e___p_a_t_h_(_) │ │ │ │ │ o _f_i_l_e___i_n_d_e_x___a_t___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_(_) │ │ │ │ │ @@ -231,71 +231,71 @@ │ │ │ │ │ * _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 _c_o_n_s_t_*_(_)_ _v_o_i_d_*_(_)_ _o_p_e_r_a_t_o_r_=_(_) │ │ │ │ │ + o _v_o_i_d_*_(_)_ _c_o_n_s_t_*_(_)_ _o_p_e_r_a_t_o_r_=_(_) │ │ │ │ │ * _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s │ │ │ │ │ * _p_e_e_r___c_l_a_s_s___i_n_f_o │ │ │ │ │ * _p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r │ │ │ │ │ o _r_e_m_o_v_e_(_)_ _a_d_d_(_) │ │ │ │ │ o _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 │ │ │ │ │ * _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 _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 _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_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_(_)_ _p_o_s_t___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 _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_) │ │ │ │ │ o _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 _h_t_t_p___s_e_e_d_s_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _a_d_d___h_t_t_p___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 _u_n_s_e_t___f_l_a_g_s_(_)_ _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_(_)_ _u_n_s_e_t___f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_) │ │ │ │ │ o _f_l_u_s_h___c_a_c_h_e_(_) │ │ │ │ │ o _f_o_r_c_e___r_e_c_h_e_c_k_(_) │ │ │ │ │ o _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) │ │ │ │ │ o _n_e_e_d___s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) │ │ │ │ │ - o _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n_(_) │ │ │ │ │ - _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_) │ │ │ │ │ + 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___b_o_t_t_o_m_(_) │ │ │ │ │ + _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___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_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_) │ │ │ │ │ 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_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_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 _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_) │ │ │ │ │ + o _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_i_e_c_e___p_r_i_o_r_i_t_y_(_)_ _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)_ _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_) │ │ │ │ │ + o _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _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___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_) │ │ │ │ │ o _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_(_)_ _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_) │ │ │ │ │ - _d_o_w_n_l_o_a_d___l_i_m_i_t_(_) │ │ │ │ │ + o _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_(_) │ │ │ │ │ + _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_) │ │ │ │ │ o _c_o_n_n_e_c_t___p_e_e_r_(_) │ │ │ │ │ o _c_l_e_a_r___p_e_e_r_s_(_) │ │ │ │ │ o _m_a_x___u_p_l_o_a_d_s_(_)_ _s_e_t___m_a_x___u_p_l_o_a_d_s_(_) │ │ │ │ │ - o _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_) │ │ │ │ │ + o _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_) │ │ │ │ │ o _m_o_v_e___s_t_o_r_a_g_e_(_) │ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_) │ │ │ │ │ - o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_) │ │ │ │ │ - o _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_=_=_(_) │ │ │ │ │ + o _i_n_f_o___h_a_s_h_e_s_(_)_ _i_n_f_o___h_a_s_h_(_) │ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_!_=_(_) │ │ │ │ │ o _i_d_(_) │ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_) │ │ │ │ │ o _u_s_e_r_d_a_t_a_(_) │ │ │ │ │ o _i_n___s_e_s_s_i_o_n_(_) │ │ │ │ │ * _h_a_s_h___v_a_l_u_e_(_) │ │ │ │ │ * _o_p_e_n___f_i_l_e___s_t_a_t_e │ │ │ │ │ * _d_i_s_k___i_n_t_e_r_f_a_c_e │ │ │ │ │ @@ -376,15 +376,15 @@ │ │ │ │ │ * _p_i_e_c_e___f_i_n_i_s_h_e_d___a_l_e_r_t │ │ │ │ │ * _r_e_q_u_e_s_t___d_r_o_p_p_e_d___a_l_e_r_t │ │ │ │ │ * _b_l_o_c_k___t_i_m_e_o_u_t___a_l_e_r_t │ │ │ │ │ * _b_l_o_c_k___f_i_n_i_s_h_e_d___a_l_e_r_t │ │ │ │ │ * _b_l_o_c_k___d_o_w_n_l_o_a_d_i_n_g___a_l_e_r_t │ │ │ │ │ * _u_n_w_a_n_t_e_d___b_l_o_c_k___a_l_e_r_t │ │ │ │ │ * _s_t_o_r_a_g_e___m_o_v_e_d___a_l_e_r_t │ │ │ │ │ - o _s_t_o_r_a_g_e___p_a_t_h_(_)_ _o_l_d___p_a_t_h_(_) │ │ │ │ │ + o _o_l_d___p_a_t_h_(_)_ _s_t_o_r_a_g_e___p_a_t_h_(_) │ │ │ │ │ * _s_t_o_r_a_g_e___m_o_v_e_d___f_a_i_l_e_d___a_l_e_r_t │ │ │ │ │ o _f_i_l_e___p_a_t_h_(_) │ │ │ │ │ * _t_o_r_r_e_n_t___d_e_l_e_t_e_d___a_l_e_r_t │ │ │ │ │ * _t_o_r_r_e_n_t___d_e_l_e_t_e___f_a_i_l_e_d___a_l_e_r_t │ │ │ │ │ * _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t │ │ │ │ │ * _s_a_v_e___r_e_s_u_m_e___d_a_t_a___f_a_i_l_e_d___a_l_e_r_t │ │ │ │ │ * _t_o_r_r_e_n_t___p_a_u_s_e_d___a_l_e_r_t │ │ │ │ │ @@ -449,15 +449,15 @@ │ │ │ │ │ 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_o_d_e_s_(_)_ _n_u_m___n_o_d_e_s_(_) │ │ │ │ │ + o _n_u_m___n_o_d_e_s_(_)_ _n_o_d_e_s_(_) │ │ │ │ │ * _s_e_s_s_i_o_n___s_t_a_t_s___h_e_a_d_e_r___a_l_e_r_t │ │ │ │ │ * _d_h_t___s_a_m_p_l_e___i_n_f_o_h_a_s_h_e_s___a_l_e_r_t │ │ │ │ │ o _s_a_m_p_l_e_s_(_)_ _n_u_m___s_a_m_p_l_e_s_(_) │ │ │ │ │ o _n_u_m___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 │ │ │ │ │ @@ -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 _s_t_r_i_n_g_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _l_i_s_t_(_)_ _d_i_c_t_(_)_ _i_n_t_e_g_e_r_(_) │ │ │ │ │ + o _d_i_c_t_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _s_t_r_i_n_g_(_)_ _l_i_s_t_(_)_ _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_(_) │ │ │ │ │ @@ -527,47 +527,47 @@ │ │ │ │ │ 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_(_) │ │ │ │ │ * _a_d_d___f_i_l_e_s_(_) │ │ │ │ │ * _s_e_t___p_i_e_c_e___h_a_s_h_e_s_(_) │ │ │ │ │ * _b_i_t_f_i_e_l_d │ │ │ │ │ o _b_i_t_f_i_e_l_d_(_) │ │ │ │ │ o _a_s_s_i_g_n_(_) │ │ │ │ │ - o _o_p_e_r_a_t_o_r_[_]_(_)_ _g_e_t___b_i_t_(_) │ │ │ │ │ + o _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 _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_(_) │ │ │ │ │ o _s_w_a_p_(_) │ │ │ │ │ o _c_o_u_n_t_(_) │ │ │ │ │ o _f_i_n_d___f_i_r_s_t___s_e_t_(_) │ │ │ │ │ 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 _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 _o_p_e_r_a_t_o_r_=_(_)_ _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 _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___i_n_t_(_)_ _s_e_t___b_o_o_l_(_)_ _s_e_t___s_t_r_(_) │ │ │ │ │ + o _s_e_t___s_t_r_(_)_ _s_e_t___b_o_o_l_(_)_ _s_e_t___i_n_t_(_) │ │ │ │ │ o _h_a_s___v_a_l_(_) │ │ │ │ │ o _c_l_e_a_r_(_) │ │ │ │ │ o _c_l_e_a_r_(_) │ │ │ │ │ o _g_e_t___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 │ │ │ │ │ @@ -576,29 +576,29 @@ │ │ │ │ │ o _e_n_u_m_ _i_o___b_u_f_f_e_r___m_o_d_e___t │ │ │ │ │ o _e_n_u_m_ _b_a_n_d_w_i_d_t_h___m_i_x_e_d___a_l_g_o___t │ │ │ │ │ o _e_n_u_m_ _e_n_c___p_o_l_i_c_y │ │ │ │ │ o _e_n_u_m_ _e_n_c___l_e_v_e_l │ │ │ │ │ o _e_n_u_m_ _p_r_o_x_y___t_y_p_e___t │ │ │ │ │ * _g_e_n_e_r_a_t_e___f_i_n_g_e_r_p_r_i_n_t_(_) │ │ │ │ │ * _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)_ _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_) │ │ │ │ │ - * _s_e_t_t_i_n_g___b_y___n_a_m_e_(_)_ _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_) │ │ │ │ │ + * _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)_ _s_e_t_t_i_n_g___b_y___n_a_m_e_(_) │ │ │ │ │ * _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_) │ │ │ │ │ * _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___s_e_c_t_i_o_n_(_)_ _d_a_t_a___o_f_f_s_e_t_(_) │ │ │ │ │ - o _l_i_s_t___a_t_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)_ _l_i_s_t___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___d_i_c_t_(_)_ _d_i_c_t___a_t_(_)_ _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___s_i_z_e_(_)_ _d_i_c_t___a_t___n_o_d_e │ │ │ │ │ - _(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_) │ │ │ │ │ - _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_) │ │ │ │ │ + o _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___a_t_(_)_ _l_i_s_t___s_i_z_e_(_) │ │ │ │ │ + o _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___a_t │ │ │ │ │ + _(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)_ _d_i_c_t___f_i_n_d___d_i_c_t_(_) │ │ │ │ │ + _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___s_i_z_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___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_) │ │ │ │ │ + o _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_) │ │ │ │ │ o _c_l_e_a_r_(_) │ │ │ │ │ o _s_w_a_p_(_) │ │ │ │ │ o _r_e_s_e_r_v_e_(_) │ │ │ │ │ o _s_w_i_t_c_h___u_n_d_e_r_l_y_i_n_g___b_u_f_f_e_r_(_) │ │ │ │ │ o _h_a_s___s_o_f_t___e_r_r_o_r_(_) │ │ │ │ │ o _e_n_u_m_ _t_y_p_e___t │ │ │ │ │ * _p_r_i_n_t___e_n_t_r_y_(_) │ │ │ │ │ @@ -618,16 +618,16 @@ │ │ │ │ │ o _g_e_t___i_n_f_o_h_a_s_h_e_s___s_a_m_p_l_e_(_) │ │ │ │ │ o _t_i_c_k_(_) │ │ │ │ │ o _c_o_u_n_t_e_r_s_(_) │ │ │ │ │ * _s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_) │ │ │ │ │ * _d_h_t___d_e_f_a_u_l_t___s_t_o_r_a_g_e___c_o_n_s_t_r_u_c_t_o_r_(_) │ │ │ │ │ * _a_n_n_o_u_n_c_e___f_l_a_g_s___t │ │ │ │ │ * _r_e_a_d___r_e_s_u_m_e___d_a_t_a_(_) │ │ │ │ │ - * _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a___b_u_f_(_)_ _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_) │ │ │ │ │ - * _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_) │ │ │ │ │ + * _w_r_i_t_e___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 │ │ │ │ │ * _e_d_2_5_5_1_9___c_r_e_a_t_e___s_e_e_d_(_) │ │ │ │ │ * _e_d_2_5_5_1_9___c_r_e_a_t_e___k_e_y_p_a_i_r_(_) │ │ │ │ │ * _e_d_2_5_5_1_9___s_i_g_n_(_) │ │ │ │ │ * _e_d_2_5_5_1_9___v_e_r_i_f_y_(_) │ │ │ │ │ * _e_d_2_5_5_1_9___a_d_d___s_c_a_l_a_r_(_) │ │ │ │ │ * _e_d_2_5_5_1_9___k_e_y___e_x_c_h_a_n_g_e_(_) │ │ │ │ │ @@ -635,29 +635,29 @@ │ │ │ │ │ ************ ssttoorraaggee__eerrrroorr ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p" │ │ │ │ │ used by storage to return errors also includes which underlying file the error │ │ │ │ │ happened on │ │ │ │ │ struct storage_error │ │ │ │ │ { │ │ │ │ │ explicit operator bbooooll () const; │ │ │ │ │ - void ffiillee (file_index_t f); │ │ │ │ │ file_index_t ffiillee () const; │ │ │ │ │ + void ffiillee (file_index_t f); │ │ │ │ │ │ │ │ │ │ error_code ec; │ │ │ │ │ operation_t operation; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** bbooooll(()) ********** │ │ │ │ │ explicit operator bbooooll () const; │ │ │ │ │ explicitly converts to true if this object represents an error, and false if it │ │ │ │ │ does not. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ffiillee(()) ********** │ │ │ │ │ -void ffiillee (file_index_t f); │ │ │ │ │ file_index_t ffiillee () const; │ │ │ │ │ +void ffiillee (file_index_t f); │ │ │ │ │ set and query the index (in the torrent) of the file this error occurred on. │ │ │ │ │ This may also have special values defined in _t_o_r_r_e_n_t___s_t_a_t_u_s. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ec │ │ │ │ │ the error that occurred │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ operation │ │ │ │ │ @@ -1236,16 +1236,16 @@ │ │ │ │ │ [_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&& sp │ │ │ │ │ , std::vector> exts); │ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack const& sp │ │ │ │ │ , std::vector> exts); │ │ │ │ │ │ │ │ │ │ settings_pack settings; │ │ │ │ │ @@ -1254,16 +1254,16 @@ │ │ │ │ │ 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&& sp │ │ │ │ │ @@ -1304,29 +1304,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 (); │ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&); │ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept; │ │ │ │ │ - session_proxy& ooppeerraattoorr== (session_proxy const&) &; │ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept; │ │ │ │ │ + sseessssiioonn__pprrooxxyy (); │ │ │ │ │ + session_proxy& ooppeerraattoorr== (session_proxy const&) &; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ~~sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) sseessssiioonn__pprrooxxyy(()) ********** │ │ │ │ │ -sseessssiioonn__pprrooxxyy (); │ │ │ │ │ +********** sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) ~~sseessssiioonn__pprrooxxyy(()) ********** │ │ │ │ │ ~~sseessssiioonn__pprrooxxyy (); │ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&); │ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept; │ │ │ │ │ -session_proxy& ooppeerraattoorr== (session_proxy const&) &; │ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept; │ │ │ │ │ +sseessssiioonn__pprrooxxyy (); │ │ │ │ │ +session_proxy& ooppeerraattoorr== (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 │ │ │ │ │ @@ -1335,44 +1335,44 @@ │ │ │ │ │ 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&& params, session_flags_t flags); │ │ │ │ │ - explicit sseessssiioonn (session_params&& params); │ │ │ │ │ - explicit sseessssiioonn (session_params const& params); │ │ │ │ │ sseessssiioonn (); │ │ │ │ │ + explicit sseessssiioonn (session_params&& params); │ │ │ │ │ sseessssiioonn (session_params const& params, session_flags_t flags); │ │ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ + explicit sseessssiioonn (session_params const& params); │ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ + sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios, session_flags_t); │ │ │ │ │ ~~sseessssiioonn (); │ │ │ │ │ session_proxy aabboorrtt (); │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseessssiioonn(()) ********** │ │ │ │ │ sseessssiioonn (session_params&& params, session_flags_t flags); │ │ │ │ │ -explicit sseessssiioonn (session_params&& params); │ │ │ │ │ -explicit sseessssiioonn (session_params const& params); │ │ │ │ │ sseessssiioonn (); │ │ │ │ │ +explicit sseessssiioonn (session_params&& params); │ │ │ │ │ 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 const& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ │ +sseessssiioonn (session_params const& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios); │ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios, session_flags_t); │ │ │ │ │ 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. │ │ │ │ │ @@ -1414,82 +1414,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&& st); │ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state const& st); │ │ │ │ │ - torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const; │ │ │ │ │ + void sseett__ddhhtt__ssttaattee (dht::dht_state&& st); │ │ │ │ │ std::vector ggeett__ttoorrrreennttss () const; │ │ │ │ │ - void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ + torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const; │ │ │ │ │ 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, error_code& ec); │ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ + void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ - bool iiss__ppaauusseedd () const; │ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec); │ │ │ │ │ void rreessuummee (); │ │ │ │ │ + bool iiss__ppaauusseedd () const; │ │ │ │ │ void ppaauussee (); │ │ │ │ │ bool iiss__ddhhtt__rruunnnniinngg () const; │ │ │ │ │ void sseett__ddhhtt__ssttoorraaggee (dht::dht_storage_constructor_type sc); │ │ │ │ │ void aadddd__ddhhtt__nnooddee (std::pair const& node); │ │ │ │ │ void ddhhtt__ggeett__iitteemm (sha1_hash const& target); │ │ │ │ │ void ddhhtt__ggeett__iitteemm (std::array key │ │ │ │ │ , std::string salt = std::string()); │ │ │ │ │ sha1_hash ddhhtt__ppuutt__iitteemm (entry data); │ │ │ │ │ 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::function( │ │ │ │ │ torrent_handle const&, client_data_t)> ext); │ │ │ │ │ void aadddd__eexxtteennssiioonn (std::shared_ptr ext); │ │ │ │ │ ip_filter ggeett__iipp__ffiilltteerr () const; │ │ │ │ │ void sseett__iipp__ffiilltteerr (ip_filter f); │ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f); │ │ │ │ │ - bool iiss__lliisstteenniinngg () const; │ │ │ │ │ - unsigned short lliisstteenn__ppoorrtt () const; │ │ │ │ │ unsigned short ssssll__lliisstteenn__ppoorrtt () const; │ │ │ │ │ - void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f); │ │ │ │ │ + unsigned short lliisstteenn__ppoorrtt () const; │ │ │ │ │ + bool iiss__lliisstteenniinngg () const; │ │ │ │ │ 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 const&); │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&); │ │ │ │ │ settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ - alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ + void aappppllyy__sseettttiinnggss (settings_pack const&); │ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun); │ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts); │ │ │ │ │ - void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle); │ │ │ │ │ + alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ 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; │ │ │ │ │ @@ -1515,20 +1515,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(()) ********** │ │ │ │ │ +********** 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; │ │ │ │ │ -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 │ │ │ │ │ @@ -1573,37 +1573,37 @@ │ │ │ │ │ For more information, see the _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ppoosstt__ddhhtt__ssttaattss(()) ********** │ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss (); │ │ │ │ │ This will cause a _d_h_t___s_t_a_t_s___a_l_e_r_t to be posted. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sseett__ddhhtt__ssttaattee(()) ********** │ │ │ │ │ -void sseett__ddhhtt__ssttaattee (dht::dht_state&& st); │ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state const& st); │ │ │ │ │ +void sseett__ddhhtt__ssttaattee (dht::dht_state&& st); │ │ │ │ │ set the DHT state for the _s_e_s_s_i_o_n. This will be taken into account the next │ │ │ │ │ time the DHT is started, as if it had been passed in via the _s_e_s_s_i_o_n___p_a_r_a_m_s on │ │ │ │ │ startup. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ffiinndd__ttoorrrreenntt(()) ggeett__ttoorrrreennttss(()) ********** │ │ │ │ │ -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 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, error_code& ec); │ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params); │ │ │ │ │ +void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params); │ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec); │ │ │ │ │ You add torrents through the _a_d_d___t_o_r_r_e_n_t_(_) function where you give an object │ │ │ │ │ with all the parameters. The _a_d_d___t_o_r_r_e_n_t_(_) overloads will block until the │ │ │ │ │ torrent has been added (or failed to be added) and returns an error code and a │ │ │ │ │ _t_o_r_r_e_n_t___h_a_n_d_l_e. In order to add torrents more efficiently, consider using │ │ │ │ │ _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) which returns immediately, without waiting for the torrent │ │ │ │ │ to add. Notification of the torrent being added is sent as _a_d_d___t_o_r_r_e_n_t___a_l_e_r_t. │ │ │ │ │ The overload that does not take an error_code throws an exception on error and │ │ │ │ │ @@ -1620,17 +1620,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(()) rreessuummee(()) iiss__ppaauusseedd(()) ********** │ │ │ │ │ -bool iiss__ppaauusseedd () const; │ │ │ │ │ +********** iiss__ppaauusseedd(()) rreessuummee(()) 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] │ │ │ │ │ @@ -1707,18 +1707,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__aannnnoouunnccee(()) ddhhtt__ggeett__ppeeeerrss(()) ********** │ │ │ │ │ +********** ddhhtt__ggeett__ppeeeerrss(()) ddhhtt__aannnnoouunnccee(()) ********** │ │ │ │ │ +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); │ │ │ │ │ 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). │ │ │ │ │ @@ -1793,26 +1793,26 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ -bool iiss__lliisstteenniinngg () const; │ │ │ │ │ -unsigned short lliisstteenn__ppoorrtt () const; │ │ │ │ │ unsigned short ssssll__lliisstteenn__ppoorrtt () const; │ │ │ │ │ +unsigned short 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] │ │ │ │ │ -********** sseett__ppeeeerr__ccllaassss__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) ********** │ │ │ │ │ -void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f); │ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) sseett__ppeeeerr__ccllaassss__ffiilltteerr(()) ********** │ │ │ │ │ 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. │ │ │ │ │ @@ -1867,17 +1867,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] │ │ │ │ │ -********** ggeett__ppeeeerr__ccllaassss(()) sseett__ppeeeerr__ccllaassss(()) ********** │ │ │ │ │ -void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci); │ │ │ │ │ +********** sseett__ppeeeerr__ccllaassss(()) ggeett__ppeeeerr__ccllaassss(()) ********** │ │ │ │ │ peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const; │ │ │ │ │ +void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci); │ │ │ │ │ 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 │ │ │ │ │ @@ -1908,25 +1908,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] │ │ │ │ │ ********** ggeett__sseettttiinnggss(()) aappppllyy__sseettttiinnggss(()) ********** │ │ │ │ │ -void aappppllyy__sseettttiinnggss (settings_pack const&); │ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&); │ │ │ │ │ settings_pack ggeett__sseettttiinnggss () const; │ │ │ │ │ +void aappppllyy__sseettttiinnggss (settings_pack const&); │ │ │ │ │ Applies the settings specified by the _s_e_t_t_i_n_g_s___p_a_c_k s. This is an asynchronous │ │ │ │ │ operation that will return immediately and actually apply the settings to the │ │ │ │ │ main thread of libtorrent some time later. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseett__aalleerrtt__nnoottiiffyy(()) ppoopp__aalleerrttss(()) wwaaiitt__ffoorr__aalleerrtt(()) ********** │ │ │ │ │ -alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ +********** ppoopp__aalleerrttss(()) wwaaiitt__ffoorr__aalleerrtt(()) sseett__aalleerrtt__nnoottiiffyy(()) ********** │ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun); │ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts); │ │ │ │ │ +alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait); │ │ │ │ │ Alerts is the main mechanism for libtorrent to report errors and events. │ │ │ │ │ pop_alerts fills in the vector passed to it with pointers to new alerts. The │ │ │ │ │ _s_e_s_s_i_o_n still owns these alerts and they will stay valid until the next time │ │ │ │ │ pop_alerts is called. You may not delete the _a_l_e_r_t objects. │ │ │ │ │ It is safe to call pop_alerts from multiple different threads, as long as the │ │ │ │ │ alerts themselves are not accessed once another thread calls pop_alerts. Doing │ │ │ │ │ this requires manual synchronization between the popping threads. │ │ │ │ │ @@ -1966,17 +1966,17 @@ │ │ │ │ │ block. It should not perform any expensive work. It really should just notify │ │ │ │ │ the main application thread. │ │ │ │ │ The type of an _a_l_e_r_t is returned by the polymorphic function alert::type() but │ │ │ │ │ can also be queries from a concrete type via T::alert_type, as a static │ │ │ │ │ constant. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ddeelleettee__ppoorrtt__mmaappppiinngg(()) aadddd__ppoorrtt__mmaappppiinngg(()) ********** │ │ │ │ │ -void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle); │ │ │ │ │ std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int │ │ │ │ │ external_port, int local_port); │ │ │ │ │ +void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle); │ │ │ │ │ add_port_mapping adds one or more port forwards on UPnP and/or NAT-PMP, │ │ │ │ │ whichever is enabled. A mapping is created for each listen socket in the │ │ │ │ │ _s_e_s_s_i_o_n. The return values are all handles referring to the port mappings that │ │ │ │ │ were just created. Pass them to _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_) to remove them. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** rreeooppeenn__nneettwwoorrkk__ssoocckkeettss(()) ********** │ │ │ │ │ void rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options = │ │ │ │ │ @@ -2022,25 +2022,25 @@ │ │ │ │ │ protocols used by _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ reopen_map_ports │ │ │ │ │ This option indicates if the ports are mapped using natpmp and upnp. If │ │ │ │ │ mapping was already made, they are deleted and added again. This only │ │ │ │ │ works if natpmp and/or upnp are configured to be enable. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -************ wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) rreeaadd__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss(()) │ │ │ │ │ +************ wwrriittee__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) rreeaadd__sseessssiioonn__ppaarraammss(()) │ │ │ │ │ ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p" │ │ │ │ │ session_params rreeaadd__sseessssiioonn__ppaarraammss (bdecode_node const& e │ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (session_params const& sp │ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ -session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf │ │ │ │ │ - , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp │ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ │ +session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf │ │ │ │ │ + , 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 │ │ │ │ │ @@ -2122,74 +2122,74 @@ │ │ │ │ │ the max number of bdecode tokens │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ttoorrrreenntt__iinnffoo ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___i_n_f_o_._h_p_p" │ │ │ │ │ the _t_o_r_r_e_n_t___i_n_f_o class holds the information found in a .torrent file. │ │ │ │ │ class torrent_info │ │ │ │ │ { │ │ │ │ │ - ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ + ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec); │ │ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const& │ │ │ │ │ +cfg); │ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg, │ │ │ │ │ from_span_t); │ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (std::string const& filename); │ │ │ │ │ + ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size); │ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file); │ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash); │ │ │ │ │ + ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t); │ │ │ │ │ ttoorrrreenntt__iinnffoo (torrent_info const& t); │ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t); │ │ │ │ │ - ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec); │ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec); │ │ │ │ │ ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec); │ │ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const& │ │ │ │ │ -cfg); │ │ │ │ │ - ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t); │ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t); │ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (std::string const& filename); │ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file); │ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash); │ │ │ │ │ ~~ttoorrrreenntt__iinnffoo (); │ │ │ │ │ file_storage const& ffiilleess () const; │ │ │ │ │ file_storage const& oorriigg__ffiilleess () const; │ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename); │ │ │ │ │ void rreemmaapp__ffiilleess (file_storage const& f); │ │ │ │ │ - std::vector const& ttrraacckkeerrss () const; │ │ │ │ │ + void cclleeaarr__ttrraacckkeerrss (); │ │ │ │ │ + void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0); │ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier │ │ │ │ │ , announce_entry::tracker_source source); │ │ │ │ │ - void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0); │ │ │ │ │ - void cclleeaarr__ttrraacckkeerrss (); │ │ │ │ │ - std::vector ssiimmiillaarr__ttoorrrreennttss () const; │ │ │ │ │ + std::vector const& ttrraacckkeerrss () const; │ │ │ │ │ std::vector ccoolllleeccttiioonnss () const; │ │ │ │ │ - void sseett__wweebb__sseeeeddss (std::vector seeds); │ │ │ │ │ + std::vector ssiimmiillaarr__ttoorrrreennttss () const; │ │ │ │ │ + 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()); │ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url │ │ │ │ │ , std::string const& extern_auth = std::string() │ │ │ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry:: │ │ │ │ │ headers_t()); │ │ │ │ │ - std::vector const& wweebb__sseeeeddss () const; │ │ │ │ │ + void sseett__wweebb__sseeeeddss (std::vector seeds); │ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const; │ │ │ │ │ - int nnuumm__ppiieecceess () const; │ │ │ │ │ int ppiieeccee__lleennggtthh () const; │ │ │ │ │ + int nnuumm__ppiieecceess () const; │ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const; │ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const; │ │ │ │ │ index_range ppiieeccee__rraannggee () const; │ │ │ │ │ piece_index_t eenndd__ppiieeccee () const; │ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const noexcept; │ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const; │ │ │ │ │ - bool vv11 () 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; │ │ │ │ │ bool pprriivv () const; │ │ │ │ │ bool iiss__ii22pp () const; │ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const; │ │ │ │ │ - sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const; │ │ │ │ │ char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const; │ │ │ │ │ + sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const; │ │ │ │ │ bool iiss__llooaaddeedd () const; │ │ │ │ │ const std::string& nnaammee () const; │ │ │ │ │ std::time_t ccrreeaattiioonn__ddaattee () const; │ │ │ │ │ const std::string& ccrreeaattoorr () const; │ │ │ │ │ const std::string& ccoommmmeenntt () const; │ │ │ │ │ std::vector> const& nnooddeess () const; │ │ │ │ │ void aadddd__nnooddee (std::pair const& node); │ │ │ │ │ @@ -2198,29 +2198,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 (char const* buffer, int size, error_code& ec); │ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const& │ │ │ │ │ +cfg); │ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg, │ │ │ │ │ from_span_t); │ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (std::string const& filename); │ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size); │ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file); │ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash); │ │ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t); │ │ │ │ │ ttoorrrreenntt__iinnffoo (torrent_info const& t); │ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t); │ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec); │ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec); │ │ │ │ │ ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec); │ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const& │ │ │ │ │ -cfg); │ │ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t); │ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t); │ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (std::string const& filename); │ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file); │ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash); │ │ │ │ │ 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 │ │ │ │ │ @@ -2286,49 +2286,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(()) ********** │ │ │ │ │ -std::vector const& ttrraacckkeerrss () const; │ │ │ │ │ +********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) cclleeaarr__ttrraacckkeerrss(()) ********** │ │ │ │ │ +void cclleeaarr__ttrraacckkeerrss (); │ │ │ │ │ +void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0); │ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier │ │ │ │ │ , announce_entry::tracker_source source); │ │ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0); │ │ │ │ │ -void cclleeaarr__ttrraacckkeerrss (); │ │ │ │ │ +std::vector const& ttrraacckkeerrss () const; │ │ │ │ │ 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 ssiimmiillaarr__ttoorrrreennttss () const; │ │ │ │ │ +********** ssiimmiillaarr__ttoorrrreennttss(()) ccoolllleeccttiioonnss(()) ********** │ │ │ │ │ std::vector ccoolllleeccttiioonnss () const; │ │ │ │ │ +std::vector ssiimmiillaarr__ttoorrrreennttss () const; │ │ │ │ │ These two functions are related to _B_E_P_ _3_8 (mutable torrents). The vectors │ │ │ │ │ returned from these correspond to the "similar" and "collections" keys in the │ │ │ │ │ .torrent file. Both info-hashes and collections from within the info-dict and │ │ │ │ │ from outside of it are included. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) sseett__wweebb__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) ********** │ │ │ │ │ -void sseett__wweebb__sseeeeddss (std::vector seeds); │ │ │ │ │ +********** sseett__wweebb__sseeeeddss(()) wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) ********** │ │ │ │ │ +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()); │ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url │ │ │ │ │ , std::string const& extern_auth = std::string() │ │ │ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry:: │ │ │ │ │ headers_t()); │ │ │ │ │ -std::vector const& wweebb__sseeeeddss () const; │ │ │ │ │ +void sseett__wweebb__sseeeeddss (std::vector seeds); │ │ │ │ │ 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 │ │ │ │ │ @@ -2342,46 +2342,46 @@ │ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const; │ │ │ │ │ total_size() returns the total number of bytes the torrent-file represents. │ │ │ │ │ Note that this is the number of pieces times the piece size (modulo the last │ │ │ │ │ piece possibly being smaller). With pad files, the total size will be larger │ │ │ │ │ than the sum of all (regular) file sizes. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** nnuumm__ppiieecceess(()) ppiieeccee__lleennggtthh(()) ********** │ │ │ │ │ -int nnuumm__ppiieecceess () const; │ │ │ │ │ int ppiieeccee__lleennggtthh () const; │ │ │ │ │ +int nnuumm__ppiieecceess () const; │ │ │ │ │ piece_length() and num_pieces() returns the number of byte for each piece and │ │ │ │ │ the total number of pieces, respectively. The difference between piece_size() │ │ │ │ │ and piece_length() is that piece_size() takes the piece index as argument and │ │ │ │ │ gives you the exact size of that piece. It will always be the same as │ │ │ │ │ piece_length() except in the case of the last piece, which may be smaller. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** bblloocckkss__ppeerr__ppiieeccee(()) ********** │ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const; │ │ │ │ │ returns the number of blocks there are in the typical piece. There may be fewer │ │ │ │ │ in the last piece) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** eenndd__ppiieeccee(()) llaasstt__ppiieeccee(()) ppiieeccee__rraannggee(()) ********** │ │ │ │ │ +********** llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) ppiieeccee__rraannggee(()) ********** │ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const; │ │ │ │ │ index_range ppiieeccee__rraannggee () const; │ │ │ │ │ piece_index_t eenndd__ppiieeccee () const; │ │ │ │ │ last_piece() returns the index to the last piece in the torrent and end_piece() │ │ │ │ │ returns the index to the one-past-end piece in the torrent piece_range() │ │ │ │ │ returns an implementation-defined type that can be used as the container in a │ │ │ │ │ range-for loop. Where the values are the indices of all pieces in the │ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) ********** │ │ │ │ │ +********** 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 vv11 () const; │ │ │ │ │ bool vv22 () const; │ │ │ │ │ +bool vv11 () const; │ │ │ │ │ returns whether this torrent has v1 and/or v2 metadata, respectively. Hybrid │ │ │ │ │ torrents have both. These are shortcuts for info_hashes().has_v1() and │ │ │ │ │ info_hashes().has_v2() calls. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** nnuumm__ffiilleess(()) ********** │ │ │ │ │ int nnuumm__ffiilleess () const; │ │ │ │ │ If you need index-access to files you can use the num_files() along with the │ │ │ │ │ @@ -2429,17 +2429,17 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ -sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const; │ │ │ │ │ +********** 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] │ │ │ │ │ ********** nnaammee(()) ********** │ │ │ │ │ const std::string& nnaammee () const; │ │ │ │ │ @@ -2889,20 +2889,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 │ │ │ │ │ { │ │ │ │ │ + explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept; │ │ │ │ │ + explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ │ iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ - explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ - explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept; │ │ │ │ │ - bool hhaass__vv11 () const; │ │ │ │ │ bool hhaass (protocol_version v) const; │ │ │ │ │ + bool hhaass__vv11 () const; │ │ │ │ │ bool hhaass__vv22 () const; │ │ │ │ │ sha1_hash ggeett (protocol_version v) const; │ │ │ │ │ sha1_hash ggeett__bbeesstt () const; │ │ │ │ │ friend bool ooppeerraattoorr!!== (info_hash_t const& lhs, info_hash_t const& rhs); │ │ │ │ │ friend bool ooppeerraattoorr==== (info_hash_t const& lhs, info_hash_t const& rhs) │ │ │ │ │ noexcept; │ │ │ │ │ template void ffoorr__eeaacchh (F f) const; │ │ │ │ │ @@ -2910,26 +2910,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(()) ********** │ │ │ │ │ +explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept; │ │ │ │ │ +explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ │ iinnffoo__hhaasshh__tt () noexcept = default; │ │ │ │ │ -explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept; │ │ │ │ │ -explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept; │ │ │ │ │ The default constructor creates an object that has neither a v1 or v2 hash. │ │ │ │ │ For backwards compatibility, make it possible to construct directly from a v1 │ │ │ │ │ hash. This constructor allows iimmpplliicciitt conversion from a v1 hash, but the │ │ │ │ │ implicitness is deprecated. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** hhaass(()) hhaass__vv11(()) hhaass__vv22(()) ********** │ │ │ │ │ -bool hhaass__vv11 () const; │ │ │ │ │ +********** hhaass(()) hhaass__vv22(()) hhaass__vv11(()) ********** │ │ │ │ │ bool hhaass (protocol_version v) const; │ │ │ │ │ +bool hhaass__vv11 () const; │ │ │ │ │ bool hhaass__vv22 () const; │ │ │ │ │ returns true if the corresponding info hash is present in this object. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ggeett(()) ********** │ │ │ │ │ sha1_hash ggeett (protocol_version v) const; │ │ │ │ │ returns the has for the specified protocol version │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ @@ -2982,41 +2982,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__ppaarrsseedd(()) llooaadd__ttoorrrreenntt__ffiillee(()) 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__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__ppaarrsseedd ( │ │ │ │ │ bdecode_node const& torrent_file); │ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr ( │ │ │ │ │ + span buffer, load_torrent_limits const& cfg); │ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ffiillee ( │ │ │ │ │ std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd ( │ │ │ │ │ + bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ffiillee ( │ │ │ │ │ std::string const& filename); │ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr ( │ │ │ │ │ span buffer); │ │ │ │ │ These functions load the content of a .torrent file into an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s │ │ │ │ │ object. The immutable part of a torrent file (the info-dictionary) is stored in │ │ │ │ │ the ti field in the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object (as a _t_o_r_r_e_n_t___i_n_f_o object). The │ │ │ │ │ returned object is suitable to be: │ │ │ │ │ * added to a _s_e_s_s_i_o_n via _a_d_d___t_o_r_r_e_n_t_(_) or _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) │ │ │ │ │ * saved as a .torrent_file via _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_) │ │ │ │ │ * turned into a magnet link via _m_a_k_e___m_a_g_n_e_t___u_r_i_(_) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ mmaakkee__mmaaggnneett__uurrii(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p" │ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle); │ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp); │ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info); │ │ │ │ │ -std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle); │ │ │ │ │ Generates a magnet URI from the specified torrent. │ │ │ │ │ Several fields from the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s objects are recorded in the magnet │ │ │ │ │ link. In order to not include them, they have to be cleared before calling │ │ │ │ │ _m_a_k_e___m_a_g_n_e_t___u_r_i_(_). These fields are used: │ │ │ │ │ ti, info_hashes, url_seeds, dht_nodes, file_priorities, trackers, │ │ │ │ │ name, peers. │ │ │ │ │ Depending on what the use case for the resulting magnet link is, clearing peers │ │ │ │ │ @@ -3031,16 +3031,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, error_code& ec); │ │ │ │ │ void ppaarrssee__mmaaggnneett__uurrii (string_view uri, add_torrent_params& p, error_code& ec); │ │ │ │ │ +add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri, error_code& ec); │ │ │ │ │ add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri); │ │ │ │ │ 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] │ │ │ │ │ @@ -3542,16 +3542,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); │ │ │ │ │ @@ -3572,16 +3572,16 @@ │ │ │ │ │ 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); │ │ │ │ │ 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 (); │ │ │ │ │ @@ -3640,51 +3640,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__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ - virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ virtual bool oonn__cchhookkee (); │ │ │ │ │ - virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ + virtual bool oonn__nnoott__iinntteerreesstteedd (); │ │ │ │ │ virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ + virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ + virtual bool oonn__uunncchhookkee (); │ │ │ │ │ + virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ + virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ + virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ - virtual bool oonn__nnoott__iinntteerreesstteedd (); │ │ │ │ │ virtual bool oonn__ddoonntt__hhaavvee (piece_index_t); │ │ │ │ │ - virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ - virtual bool oonn__uunncchhookkee (); │ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**// │ │ │ │ │ , span //**bbuuff**//); │ │ │ │ │ + virtual bool oonn__ccaanncceell (peer_request const&); │ │ │ │ │ virtual bool oonn__ssuuggggeesstt (piece_index_t); │ │ │ │ │ virtual bool oonn__rreejjeecctt (peer_request const&); │ │ │ │ │ - virtual bool oonn__ccaanncceell (peer_request const&); │ │ │ │ │ virtual void sseenntt__ccaanncceell (peer_request const&); │ │ │ │ │ virtual void sseenntt__rreeqquueesstt (peer_request const&); │ │ │ │ │ - virtual void sseenntt__hhaavvee__nnoonnee (); │ │ │ │ │ - virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&); │ │ │ │ │ - virtual void sseenntt__ssuuggggeesstt (piece_index_t); │ │ │ │ │ - virtual void sseenntt__aallllooww__ffaasstt (piece_index_t); │ │ │ │ │ virtual void sseenntt__hhaavvee__aallll (); │ │ │ │ │ + virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&); │ │ │ │ │ virtual void sseenntt__cchhookkee (); │ │ │ │ │ - virtual void sseenntt__iinntteerreesstteedd (); │ │ │ │ │ + virtual void sseenntt__aallllooww__ffaasstt (piece_index_t); │ │ │ │ │ + virtual void sseenntt__ssuuggggeesstt (piece_index_t); │ │ │ │ │ + virtual void sseenntt__hhaavvee__nnoonnee (); │ │ │ │ │ virtual void sseenntt__uunncchhookkee (); │ │ │ │ │ virtual void sseenntt__hhaavvee (piece_index_t); │ │ │ │ │ - virtual void sseenntt__ppiieeccee (peer_request const&); │ │ │ │ │ virtual void sseenntt__nnoott__iinntteerreesstteedd (); │ │ │ │ │ + virtual void sseenntt__ppiieeccee (peer_request const&); │ │ │ │ │ + virtual void sseenntt__iinntteerreesstteedd (); │ │ │ │ │ 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. │ │ │ │ │ @@ -3712,48 +3712,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__nnoonnee(()) oonn__bbiittffiieelldd(()) oonn__ddoonntt__hhaavvee(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee(()) │ │ │ │ │ -oonn__aalllloowweedd__ffaasstt(()) oonn__rreeqquueesstt(()) oonn__hhaavvee__aallll(()) oonn__iinntteerreesstteedd(()) oonn__uunncchhookkee(()) │ │ │ │ │ -oonn__cchhookkee(()) ********** │ │ │ │ │ -virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ -virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ +********** oonn__cchhookkee(()) oonn__hhaavvee__nnoonnee(()) oonn__aalllloowweedd__ffaasstt(()) oonn__hhaavvee__aallll(()) oonn__uunncchhookkee(()) │ │ │ │ │ +oonn__hhaavvee(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__ddoonntt__hhaavvee(()) oonn__rreeqquueesstt(()) oonn__bbiittffiieelldd(()) │ │ │ │ │ +oonn__iinntteerreesstteedd(()) ********** │ │ │ │ │ virtual bool oonn__cchhookkee (); │ │ │ │ │ -virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ +virtual bool oonn__nnoott__iinntteerreesstteedd (); │ │ │ │ │ virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//); │ │ │ │ │ +virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ +virtual bool oonn__uunncchhookkee (); │ │ │ │ │ +virtual bool oonn__hhaavvee (piece_index_t); │ │ │ │ │ +virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t); │ │ │ │ │ +virtual bool oonn__hhaavvee__nnoonnee (); │ │ │ │ │ virtual bool oonn__iinntteerreesstteedd (); │ │ │ │ │ -virtual bool oonn__nnoott__iinntteerreesstteedd (); │ │ │ │ │ virtual bool oonn__ddoonntt__hhaavvee (piece_index_t); │ │ │ │ │ -virtual bool oonn__hhaavvee__aallll (); │ │ │ │ │ virtual bool oonn__rreeqquueesstt (peer_request const&); │ │ │ │ │ -virtual bool oonn__uunncchhookkee (); │ │ │ │ │ returning true from any of the message handlers indicates that the _p_l_u_g_i_n has │ │ │ │ │ handled the message. it will break the _p_l_u_g_i_n chain traversing and not let │ │ │ │ │ anyone else handle the message, including the default handler. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** oonn__ppiieeccee(()) ********** │ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**// │ │ │ │ │ , span //**bbuuff**//); │ │ │ │ │ This function is called when the peer connection is receiving a piece. buf │ │ │ │ │ points (non-owning pointer) to the data in an internal immutable disk buffer. │ │ │ │ │ The length of the data is specified in the length member of the piece │ │ │ │ │ parameter. returns true to indicate that the piece is handled and the rest of │ │ │ │ │ the logic should be ignored. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseenntt__iinntteerreesstteedd(()) sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__ppiieeccee(()) sseenntt__uunncchhookkee(()) │ │ │ │ │ -sseenntt__hhaavvee(()) ********** │ │ │ │ │ -virtual void sseenntt__iinntteerreesstteedd (); │ │ │ │ │ +********** sseenntt__ppiieeccee(()) sseenntt__hhaavvee(()) sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__iinntteerreesstteedd(()) │ │ │ │ │ +sseenntt__uunncchhookkee(()) ********** │ │ │ │ │ virtual void sseenntt__uunncchhookkee (); │ │ │ │ │ virtual void sseenntt__hhaavvee (piece_index_t); │ │ │ │ │ -virtual void sseenntt__ppiieeccee (peer_request const&); │ │ │ │ │ virtual void sseenntt__nnoott__iinntteerreesstteedd (); │ │ │ │ │ +virtual void sseenntt__ppiieeccee (peer_request const&); │ │ │ │ │ +virtual void sseenntt__iinntteerreesstteedd (); │ │ │ │ │ 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] │ │ │ │ │ @@ -3777,16 +3777,16 @@ │ │ │ │ │ [_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); │ │ │ │ │ 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] │ │ │ │ │ @@ -3796,16 +3796,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**//) = │ │ │ │ │ @@ -3824,51 +3824,51 @@ │ │ │ │ │ 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; │ │ │ │ │ - peer_plugin const* ffiinndd__pplluuggiinn (string_view type) const; │ │ │ │ │ void aadddd__eexxtteennssiioonn (std::shared_ptr); │ │ │ │ │ + peer_plugin const* ffiinndd__pplluuggiinn (string_view type) const; │ │ │ │ │ bool iiss__sseeeedd () const; │ │ │ │ │ bool uuppllooaadd__oonnllyy () const; │ │ │ │ │ - bool hhaass__ppiieeccee (piece_index_t i) 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; │ │ │ │ │ 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__ccoonnnneeccttiinngg () const; │ │ │ │ │ - bool iiss__oouuttggooiinngg () const; │ │ │ │ │ + bool iiss__ddiissccoonnnneeccttiinngg () const; │ │ │ │ │ void ddiissccoonnnneecctt (error_code const& ec, operation_t op │ │ │ │ │ , disconnect_severity_t = peer_connection_interface::normal); │ │ │ │ │ - bool iiss__ddiissccoonnnneeccttiinngg () const; │ │ │ │ │ - bool iiggnnoorree__uunncchhookkee__sslloottss () const; │ │ │ │ │ + bool iiss__ccoonnnneeccttiinngg () const; │ │ │ │ │ + bool iiss__oouuttggooiinngg () const; │ │ │ │ │ bool oonn__llooccaall__nneettwwoorrkk () const; │ │ │ │ │ + bool iiggnnoorree__uunncchhookkee__sslloottss () const; │ │ │ │ │ bool ffaaiilleedd () 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); │ │ │ │ │ - time_point ttiimmee__ooff__llaasstt__uunncchhookkee () const; │ │ │ │ │ std::time_t llaasstt__sseeeenn__ccoommpplleettee () 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; │ │ │ │ │ + bool ooppeerraattoorr<< (peer_connection_handle const& o) const; │ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e_._h_p_p" │ │ │ │ │ The _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e provides a handle to the internal bittorrent peer │ │ │ │ │ connection object to plugins. It's low level and may not be a stable API across │ │ │ │ │ @@ -3954,71 +3954,71 @@ │ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ │ void aadddd__ffiillee__bboorrrrooww (string_view filename │ │ │ │ │ , std::string const& path, std::int64_t file_size │ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr │ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ │ - void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename │ │ │ │ │ - , std::string const& path, std::int64_t file_size │ │ │ │ │ - , file_flags_t file_flags = {}, char const* filehash = nullptr │ │ │ │ │ - , std::int64_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ │ - , char const* root_hash = nullptr); │ │ │ │ │ void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t │ │ │ │ │ file_size │ │ │ │ │ , file_flags_t file_flags = {} │ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ │ + void aadddd__ffiillee__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 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; │ │ │ │ │ - void sseett__nnuumm__ppiieecceess (int n); │ │ │ │ │ int nnuumm__ppiieecceess () const; │ │ │ │ │ + void sseett__nnuumm__ppiieecceess (int n); │ │ │ │ │ piece_index_t eenndd__ppiieeccee () const; │ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const; │ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept; │ │ │ │ │ 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; │ │ │ │ │ void sseett__nnaammee (std::string const& n); │ │ │ │ │ std::string const& nnaammee () const; │ │ │ │ │ void sswwaapp (file_storage& ti) noexcept; │ │ │ │ │ void ccaannoonniiccaalliizzee (); │ │ │ │ │ + sha1_hash hhaasshh (file_index_t index) const; │ │ │ │ │ + char const* rroooott__ppttrr (file_index_t const index) const; │ │ │ │ │ + std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = │ │ │ │ │ +"") const; │ │ │ │ │ + std::int64_t ffiillee__ooffffsseett (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::time_t mmttiimmee (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 ssyymmlliinnkk (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 ffiillee__ppaatthh (file_index_t index, std::string const& save_path = │ │ │ │ │ -"") const; │ │ │ │ │ - sha1_hash hhaasshh (file_index_t index) const; │ │ │ │ │ - char const* rroooott__ppttrr (file_index_t const index) 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; │ │ │ │ │ + int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const; │ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const& │ │ │ │ │ save_path) const; │ │ │ │ │ void aallll__ppaatthh__hhaasshheess (std::unordered_set& table) const; │ │ │ │ │ file_flags_t ffiillee__ffllaaggss (file_index_t index) const; │ │ │ │ │ bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const; │ │ │ │ │ - file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const; │ │ │ │ │ file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const; │ │ │ │ │ + file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) 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; │ │ │ │ │ @@ -4044,23 +4044,23 @@ │ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ │ void aadddd__ffiillee__bboorrrrooww (string_view filename │ │ │ │ │ , std::string const& path, std::int64_t file_size │ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr │ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ │ +void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size │ │ │ │ │ + , file_flags_t file_flags = {} │ │ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ │ + , char const* root_hash = nullptr); │ │ │ │ │ void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename │ │ │ │ │ , std::string const& path, std::int64_t file_size │ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr │ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ │ , char const* root_hash = nullptr); │ │ │ │ │ -void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size │ │ │ │ │ - , file_flags_t file_flags = {} │ │ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view() │ │ │ │ │ - , char const* root_hash = nullptr); │ │ │ │ │ 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. │ │ │ │ │ @@ -4130,16 +4130,16 @@ │ │ │ │ │ _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(()) ********** │ │ │ │ │ -void sseett__nnuumm__ppiieecceess (int n); │ │ │ │ │ int nnuumm__ppiieecceess () const; │ │ │ │ │ +void sseett__nnuumm__ppiieecceess (int n); │ │ │ │ │ set and get the number of pieces in the torrent │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eenndd__ppiieeccee(()) ********** │ │ │ │ │ piece_index_t eenndd__ppiieeccee () const; │ │ │ │ │ returns the index of the one-past-end piece in the file storage │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** llaasstt__ppiieeccee(()) ********** │ │ │ │ │ @@ -4150,15 +4150,15 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ppiieeccee__rraannggee(()) ********** │ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept; │ │ │ │ │ returns an implementation-defined type that can be used as the container in a │ │ │ │ │ range-for loop. Where the values are the indices of all pieces in the │ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseett__ppiieeccee__lleennggtthh(()) ppiieeccee__lleennggtthh(()) ********** │ │ │ │ │ +********** ppiieeccee__lleennggtthh(()) sseett__ppiieeccee__lleennggtthh(()) ********** │ │ │ │ │ void sseett__ppiieeccee__lleennggtthh (int l); │ │ │ │ │ int ppiieeccee__lleennggtthh () const; │ │ │ │ │ set and get the size of each piece in this torrent. It must be a power of two │ │ │ │ │ and at least 16 kiB. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ppiieeccee__ssiizzee(()) ********** │ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const; │ │ │ │ │ @@ -4177,41 +4177,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] │ │ │ │ │ -********** sseett__nnaammee(()) nnaammee(()) ********** │ │ │ │ │ +********** 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] │ │ │ │ │ -********** rroooott(()) rroooott__ppttrr(()) ffiillee__nnaammee(()) ppaadd__ffiillee__aatt(()) ssyymmlliinnkk(()) ffiillee__ppaatthh(()) │ │ │ │ │ -ffiillee__ooffffsseett(()) ffiillee__ssiizzee(()) hhaasshh(()) mmttiimmee(()) ********** │ │ │ │ │ +********** ffiillee__ooffffsseett(()) ssyymmlliinnkk(()) rroooott(()) ppaadd__ffiillee__aatt(()) hhaasshh(()) rroooott__ppttrr(()) ffiillee__ppaatthh │ │ │ │ │ +(()) mmttiimmee(()) ffiillee__ssiizzee(()) ffiillee__nnaammee(()) ********** │ │ │ │ │ +sha1_hash hhaasshh (file_index_t index) const; │ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const; │ │ │ │ │ +std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "") │ │ │ │ │ +const; │ │ │ │ │ +std::int64_t ffiillee__ooffffsseett (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::time_t mmttiimmee (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 ssyymmlliinnkk (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 ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "") │ │ │ │ │ -const; │ │ │ │ │ -sha1_hash hhaasshh (file_index_t index) const; │ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const 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 │ │ │ │ │ @@ -4224,26 +4224,26 @@ │ │ │ │ │ file_size() returns the size of a file. │ │ │ │ │ pad_file_at() returns true if the file at the given index is a pad-file. │ │ │ │ │ file_name() returns jjuusstt the name of the file, whereas file_path() returns the │ │ │ │ │ path (inside the torrent file) with the filename appended. │ │ │ │ │ file_offset() returns the byte offset within the torrent file where this file │ │ │ │ │ starts. It can be used to map the file to a piece index (given the piece size). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ffiillee__nnuumm__bblloocckkss(()) ffiillee__ppiieeccee__rraannggee(()) ffiillee__nnuumm__ppiieecceess(()) ********** │ │ │ │ │ +********** ffiillee__nnuumm__ppiieecceess(()) ffiillee__nnuumm__bblloocckkss(()) ffiillee__ppiieeccee__rraannggee(()) ********** │ │ │ │ │ +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(()) ********** │ │ │ │ │ -int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const; │ │ │ │ │ int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const; │ │ │ │ │ +int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const; │ │ │ │ │ index of first piece node in the merkle tree │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ffiillee__ppaatthh__hhaasshh(()) ********** │ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const& save_path) │ │ │ │ │ const; │ │ │ │ │ returns the crc32 hash of file_path(index) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ @@ -4261,16 +4261,16 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ffiillee__aabbssoolluuttee__ppaatthh(()) ********** │ │ │ │ │ bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const; │ │ │ │ │ returns true if the file at the specified index has been renamed to have an │ │ │ │ │ absolute path, i.e. is not anchored in the save path of the torrent. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ffiillee__iinnddeexx__aatt__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; │ │ │ │ │ +file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) 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] │ │ │ │ │ @@ -4410,32 +4410,32 @@ │ │ │ │ │ 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; │ │ │ │ │ + operator vvooiidd** () const = delete; │ │ │ │ │ client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ client_data_t& ooppeerraattoorr== (void const*) = delete; │ │ │ │ │ operator void ccoonnsstt** () const = 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**(()) vvooiidd**(()) ooppeerraattoorr==(()) ********** │ │ │ │ │ +********** vvooiidd**(()) ccoonnsstt**(()) ooppeerraattoorr==(()) ********** │ │ │ │ │ +operator vvooiidd** () const = delete; │ │ │ │ │ client_data_t& ooppeerraattoorr== (void*) = delete; │ │ │ │ │ client_data_t& ooppeerraattoorr== (void const*) = delete; │ │ │ │ │ operator void ccoonnsstt** () const = 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: │ │ │ │ │ @@ -4739,16 +4739,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 │ │ │ │ │ @@ -4759,16 +4759,16 @@ │ │ │ │ │ ssl_utp_socket, │ │ │ │ │ i2p_socket, │ │ │ │ │ num_socket_types, │ │ │ │ │ }; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** rreemmoovvee(()) aadddd(()) ********** │ │ │ │ │ -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); │ │ │ │ │ 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 │ │ │ │ │ @@ -4795,16 +4795,16 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ bblloocckk__iinnffoo ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p" │ │ │ │ │ holds the state of a block in a piece. Who we requested it from and how far │ │ │ │ │ along we are at downloading it. │ │ │ │ │ struct block_info │ │ │ │ │ { │ │ │ │ │ - _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const; │ │ │ │ │ void sseett__ppeeeerr (tcp::endpoint const& ep); │ │ │ │ │ + _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const; │ │ │ │ │ │ │ │ │ │ enum block_state_t │ │ │ │ │ { │ │ │ │ │ none, │ │ │ │ │ requested, │ │ │ │ │ writing, │ │ │ │ │ finished, │ │ │ │ │ @@ -4812,17 +4812,17 @@ │ │ │ │ │ │ │ │ │ │ unsigned bytes_progress:15; │ │ │ │ │ unsigned block_size:15; │ │ │ │ │ unsigned state:2; │ │ │ │ │ unsigned num_peers:14; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ppeeeerr(()) sseett__ppeeeerr(()) ********** │ │ │ │ │ -_t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const; │ │ │ │ │ +********** 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" │ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ │ │ │ │ │ |_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 | │ │ │ │ │ @@ -4910,119 +4910,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, std::vector data, │ │ │ │ │ -add_piece_flags_t flags = {}) const; │ │ │ │ │ void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t │ │ │ │ │ flags = {}) const; │ │ │ │ │ + void aadddd__ppiieeccee (piece_index_t piece, std::vector data, │ │ │ │ │ +add_piece_flags_t flags = {}) const; │ │ │ │ │ void rreeaadd__ppiieeccee (piece_index_t piece) const; │ │ │ │ │ bool hhaavvee__ppiieeccee (piece_index_t piece) const; │ │ │ │ │ void ppoosstt__ppeeeerr__iinnffoo () const; │ │ │ │ │ void ggeett__ppeeeerr__iinnffoo (std::vector& v) const; │ │ │ │ │ - torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const; │ │ │ │ │ void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const; │ │ │ │ │ + torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const; │ │ │ │ │ void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const; │ │ │ │ │ - std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const; │ │ │ │ │ void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const; │ │ │ │ │ + std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const; │ │ │ │ │ void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const; │ │ │ │ │ void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const; │ │ │ │ │ void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t │ │ │ │ │ flags = {}) const; │ │ │ │ │ void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const; │ │ │ │ │ std::vector 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 rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const; │ │ │ │ │ std::set uurrll__sseeeeddss () const; │ │ │ │ │ void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const; │ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url) const; │ │ │ │ │ + void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const; │ │ │ │ │ std::set hhttttpp__sseeeeddss () const; │ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url) const; │ │ │ │ │ - void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const; │ │ │ │ │ void aadddd__eexxtteennssiioonn ( │ │ │ │ │ std::function(torrent_handle const&, │ │ │ │ │ client_data_t)> const& ext │ │ │ │ │ , client_data_t userdata = client_data_t{}); │ │ │ │ │ bool sseett__mmeettaaddaattaa (span metadata) const; │ │ │ │ │ bool iiss__vvaalliidd () const; │ │ │ │ │ - void ppaauussee (pause_flags_t flags = {}) const; │ │ │ │ │ void rreessuummee () const; │ │ │ │ │ - void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const; │ │ │ │ │ - void sseett__ffllaaggss (torrent_flags_t flags) const; │ │ │ │ │ + void ppaauussee (pause_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 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 (resume_data_flags_t flags) const; │ │ │ │ │ bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const; │ │ │ │ │ - void qquueeuuee__ppoossiittiioonn__uupp () const; │ │ │ │ │ - void qquueeuuee__ppoossiittiioonn__ttoopp () const; │ │ │ │ │ void qquueeuuee__ppoossiittiioonn__bboottttoomm () const; │ │ │ │ │ + void qquueeuuee__ppoossiittiioonn__ttoopp () const; │ │ │ │ │ void qquueeuuee__ppoossiittiioonn__ddoowwnn () const; │ │ │ │ │ + void qquueeuuee__ppoossiittiioonn__uupp () const; │ │ │ │ │ queue_position_t qquueeuuee__ppoossiittiioonn () const; │ │ │ │ │ void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const; │ │ │ │ │ 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__wwiitthh__hhaasshheess () const; │ │ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee () const; │ │ │ │ │ std::vector> ppiieeccee__llaayyeerrss () const; │ │ │ │ │ - void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const; │ │ │ │ │ void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const; │ │ │ │ │ - download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const; │ │ │ │ │ + void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const; │ │ │ │ │ void ppiieeccee__pprriioorriittyy (piece_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__ppiieeccee__pprriioorriittiieess () const; │ │ │ │ │ void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) │ │ │ │ │ const; │ │ │ │ │ - std::vector ggeett__ffiillee__pprriioorriittiieess () const; │ │ │ │ │ void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) 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 ffoorrccee__ddhhtt__aannnnoouunnccee () const; │ │ │ │ │ + void ffoorrccee__llssdd__aannnnoouunnccee () const; │ │ │ │ │ void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t = │ │ │ │ │ {}) const; │ │ │ │ │ - void ffoorrccee__llssdd__aannnnoouunnccee () const; │ │ │ │ │ - void ffoorrccee__ddhhtt__aannnnoouunnccee () const; │ │ │ │ │ void ssccrraappee__ttrraacckkeerr (int idx = -1) const; │ │ │ │ │ + void sseett__uuppllooaadd__lliimmiitt (int limit) const; │ │ │ │ │ + void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const; │ │ │ │ │ int uuppllooaadd__lliimmiitt () const; │ │ │ │ │ int ddoowwnnllooaadd__lliimmiitt () const; │ │ │ │ │ - void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const; │ │ │ │ │ - void sseett__uuppllooaadd__lliimmiitt (int limit) const; │ │ │ │ │ void ccoonnnneecctt__ppeeeerr (tcp::endpoint const& adr, peer_source_flags_t source = {} │ │ │ │ │ , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const; │ │ │ │ │ void cclleeaarr__ppeeeerrss (); │ │ │ │ │ - int mmaaxx__uuppllooaaddss () const; │ │ │ │ │ void sseett__mmaaxx__uuppllooaaddss (int max_uploads) const; │ │ │ │ │ + int mmaaxx__uuppllooaaddss () const; │ │ │ │ │ int mmaaxx__ccoonnnneeccttiioonnss () const; │ │ │ │ │ void sseett__mmaaxx__ccoonnnneeccttiioonnss (int max_connections) const; │ │ │ │ │ void mmoovvee__ssttoorraaggee (std::string const& save_path │ │ │ │ │ , move_flags_t flags = move_flags_t::always_replace_files │ │ │ │ │ ) const; │ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_name) const; │ │ │ │ │ info_hash_t iinnffoo__hhaasshheess () const; │ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const; │ │ │ │ │ - bool ooppeerraattoorr==== (const torrent_handle& h) const; │ │ │ │ │ bool ooppeerraattoorr<< (const torrent_handle& h) const; │ │ │ │ │ + bool ooppeerraattoorr==== (const torrent_handle& h) const; │ │ │ │ │ bool ooppeerraattoorr!!== (const torrent_handle& h) const; │ │ │ │ │ std::uint32_t iidd () const; │ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const; │ │ │ │ │ client_data_t uusseerrddaattaa () const; │ │ │ │ │ bool iinn__sseessssiioonn () const; │ │ │ │ │ │ │ │ │ │ static constexpr add_piece_flags_t oovveerrwwrriittee__eexxiissttiinngg = 0_bit; │ │ │ │ │ @@ -5050,18 +5050,18 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ttoorrrreenntt__hhaannddllee(()) ********** │ │ │ │ │ ttoorrrreenntt__hhaannddllee () noexcept = default; │ │ │ │ │ constructs a torrent handle that does not refer to a torrent. i.e. _i_s___v_a_l_i_d_(_) │ │ │ │ │ will return false. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** aadddd__ppiieeccee(()) ********** │ │ │ │ │ -void aadddd__ppiieeccee (piece_index_t piece, std::vector data, add_piece_flags_t │ │ │ │ │ -flags = {}) const; │ │ │ │ │ void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t flags │ │ │ │ │ = {}) const; │ │ │ │ │ +void aadddd__ppiieeccee (piece_index_t piece, std::vector data, add_piece_flags_t │ │ │ │ │ +flags = {}) const; │ │ │ │ │ This function will write data to the storage as piece piece, as if it had been │ │ │ │ │ downloaded from a peer. │ │ │ │ │ By default, data that's already been downloaded is not overwritten by this │ │ │ │ │ buffer. If you trust this data to be correct (and pass the piece hash check) │ │ │ │ │ you may pass the overwrite_existing flag. This will instruct libtorrent to │ │ │ │ │ overwrite any data that may already have been downloaded with this data. │ │ │ │ │ Since the data is written asynchronously, you may know that is passed or failed │ │ │ │ │ @@ -5103,16 +5103,16 @@ │ │ │ │ │ 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; │ │ │ │ │ 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 │ │ │ │ │ @@ -5122,23 +5122,23 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const; │ │ │ │ │ -std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const; │ │ │ │ │ void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) 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] │ │ │ │ │ -********** rreesseett__ppiieeccee__ddeeaaddlliinnee(()) cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) sseett__ppiieeccee__ddeeaaddlliinnee(()) ********** │ │ │ │ │ +********** sseett__ppiieeccee__ddeeaaddlliinnee(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) ********** │ │ │ │ │ void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const; │ │ │ │ │ void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const; │ │ │ │ │ void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t │ │ │ │ │ flags = {}) const; │ │ │ │ │ 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 │ │ │ │ │ @@ -5184,19 +5184,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(()) ppoosstt__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) rreeppllaaccee__ttrraacckkeerrss(()) ********** │ │ │ │ │ -void aadddd__ttrraacckkeerr (announce_entry const&) const; │ │ │ │ │ -void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const; │ │ │ │ │ +********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) ppoosstt__ttrraacckkeerrss(()) rreeppllaaccee__ttrraacckkeerrss(()) ********** │ │ │ │ │ void ppoosstt__ttrraacckkeerrss () const; │ │ │ │ │ std::vector ttrraacckkeerrss () const; │ │ │ │ │ +void aadddd__ttrraacckkeerr (announce_entry const&) const; │ │ │ │ │ +void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) 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. │ │ │ │ │ @@ -5217,18 +5217,18 @@ │ │ │ │ │ given url already exists in that list, the call has no effect. The torrent will │ │ │ │ │ connect to the server and try to download pieces from it, unless it's paused, │ │ │ │ │ queued, checking or seeding. remove_url_seed() removes the given url if it │ │ │ │ │ exists already. url_seeds() return a set of the url seeds currently in this │ │ │ │ │ torrent. Note that URLs that fails may be removed automatically from the list. │ │ │ │ │ See _h_t_t_p_ _s_e_e_d_i_n_g for more information. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** hhttttpp__sseeeeddss(()) rreemmoovvee__hhttttpp__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) ********** │ │ │ │ │ +********** hhttttpp__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) rreemmoovvee__hhttttpp__sseeeedd(()) ********** │ │ │ │ │ +void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const; │ │ │ │ │ std::set hhttttpp__sseeeeddss () const; │ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url) const; │ │ │ │ │ -void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const; │ │ │ │ │ These functions are identical as the *_url_seed() variants, but they operate on │ │ │ │ │ _B_E_P_ _1_7 web seeds instead of _B_E_P_ _1_9. │ │ │ │ │ See _h_t_t_p_ _s_e_e_d_i_n_g for more information. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** aadddd__eexxtteennssiioonn(()) ********** │ │ │ │ │ void aadddd__eexxtteennssiioonn ( │ │ │ │ │ std::function(torrent_handle const&, │ │ │ │ │ @@ -5259,36 +5259,36 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ -void ppaauussee (pause_flags_t flags = {}) const; │ │ │ │ │ +********** rreessuummee(()) ppaauussee(()) ********** │ │ │ │ │ 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 │ │ │ │ │ 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] │ │ │ │ │ -********** uunnsseett__ffllaaggss(()) sseett__ffllaaggss(()) ffllaaggss(()) ********** │ │ │ │ │ -void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const; │ │ │ │ │ -void sseett__ffllaaggss (torrent_flags_t flags) const; │ │ │ │ │ +********** ffllaaggss(()) uunnsseett__ffllaaggss(()) sseett__ffllaaggss(()) ********** │ │ │ │ │ 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 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 │ │ │ │ │ @@ -5412,20 +5412,20 @@ │ │ │ │ │ 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__ttoopp(()) qquueeuuee__ppoossiittiioonn(()) │ │ │ │ │ -qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) ********** │ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__uupp () const; │ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__ttoopp () const; │ │ │ │ │ +********** qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__bboottttoomm(()) │ │ │ │ │ +qquueeuuee__ppoossiittiioonn__uupp(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) ********** │ │ │ │ │ void qquueeuuee__ppoossiittiioonn__bboottttoomm () const; │ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__ttoopp () const; │ │ │ │ │ void qquueeuuee__ppoossiittiioonn__ddoowwnn () const; │ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__uupp () const; │ │ │ │ │ queue_position_t qquueeuuee__ppoossiittiioonn () const; │ │ │ │ │ Every torrent that is added is assigned a queue position exactly one greater │ │ │ │ │ than the greatest queue position of all existing torrents. Torrents that are │ │ │ │ │ being seeded have -1 as their queue position, since they're no longer in line │ │ │ │ │ to be downloaded. │ │ │ │ │ When a torrent is removed or turns into a seed, all torrents with greater queue │ │ │ │ │ positions have their positions decreased to fill in the space in the sequence. │ │ │ │ │ @@ -5505,29 +5505,29 @@ │ │ │ │ │ [_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] │ │ │ │ │ -********** pprriioorriittiizzee__ppiieecceess(()) ppiieeccee__pprriioorriittyy(()) ggeett__ppiieeccee__pprriioorriittiieess(()) ********** │ │ │ │ │ -download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const; │ │ │ │ │ +********** ppiieeccee__pprriioorriittyy(()) pprriioorriittiizzee__ppiieecceess(()) ggeett__ppiieeccee__pprriioorriittiieess(()) ********** │ │ │ │ │ void ppiieeccee__pprriioorriittyy (piece_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__ppiieeccee__pprriioorriittiieess () 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 │ │ │ │ │ @@ -5551,18 +5551,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] │ │ │ │ │ -********** ggeett__ffiillee__pprriioorriittiieess(()) pprriioorriittiizzee__ffiilleess(()) ffiillee__pprriioorriittyy(()) ********** │ │ │ │ │ -std::vector ggeett__ffiillee__pprriioorriittiieess () const; │ │ │ │ │ +********** ffiillee__pprriioorriittyy(()) pprriioorriittiizzee__ffiilleess(()) ggeett__ffiillee__pprriioorriittiieess(()) ********** │ │ │ │ │ void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) 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; │ │ │ │ │ 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. │ │ │ │ │ @@ -5582,19 +5582,19 @@ │ │ │ │ │ When combining file- and piece priorities, the resume file will record both. │ │ │ │ │ When loading the resume data, the file priorities will be applied first, then │ │ │ │ │ the piece priorities. │ │ │ │ │ Moving data from a file into the part file is currently not supported. If a │ │ │ │ │ file has its priority set to 0 aafftteerr it has already been created, it will not │ │ │ │ │ be moved into the partfile. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ffoorrccee__rreeaannnnoouunnccee(()) ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__llssdd__aannnnoouunnccee(()) ********** │ │ │ │ │ +********** ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) ffoorrccee__llssdd__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__llssdd__aannnnoouunnccee () const; │ │ │ │ │ -void ffoorrccee__ddhhtt__aannnnoouunnccee () const; │ │ │ │ │ force_reannounce() will force this torrent to do another tracker request, to │ │ │ │ │ receive new peers. The seconds argument specifies how many seconds from now to │ │ │ │ │ issue the tracker announces. │ │ │ │ │ If the tracker's min_interval has not passed since the last announce, the │ │ │ │ │ forced announce will be scheduled to happen immediately as the min_interval │ │ │ │ │ expires. This is to honor trackers minimum re-announce interval settings. │ │ │ │ │ The tracker_index argument specifies which tracker to re-announce. If set to - │ │ │ │ │ @@ -5612,20 +5612,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(()) sseett__ddoowwnnllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) │ │ │ │ │ +********** uuppllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(()) │ │ │ │ │ ********** │ │ │ │ │ +void sseett__uuppllooaadd__lliimmiitt (int limit) const; │ │ │ │ │ +void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const; │ │ │ │ │ int uuppllooaadd__lliimmiitt () const; │ │ │ │ │ int ddoowwnnllooaadd__lliimmiitt () const; │ │ │ │ │ -void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const; │ │ │ │ │ -void sseett__uuppllooaadd__lliimmiitt (int limit) const; │ │ │ │ │ set_upload_limit will limit the upload bandwidth used by this particular │ │ │ │ │ torrent to the limit you set. It is given as the number of bytes per second the │ │ │ │ │ torrent is allowed to upload. set_download_limit works the same way but for │ │ │ │ │ download bandwidth instead of upload bandwidth. Note that setting a higher │ │ │ │ │ limit on a torrent then the global limit (settings_pack::upload_rate_limit) │ │ │ │ │ will not override the global rate limit. The torrent can never upload more than │ │ │ │ │ the global rate limit. │ │ │ │ │ @@ -5649,23 +5649,23 @@ │ │ │ │ │ ********** 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(()) ********** │ │ │ │ │ -int mmaaxx__uuppllooaaddss () const; │ │ │ │ │ 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(()) ********** │ │ │ │ │ +********** sseett__mmaaxx__ccoonnnneeccttiioonnss(()) 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 │ │ │ │ │ @@ -5717,26 +5717,26 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** rreennaammee__ffiillee(()) ********** │ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_name) const; │ │ │ │ │ Renames the file with the given index asynchronously. The rename operation is │ │ │ │ │ complete when either a _f_i_l_e___r_e_n_a_m_e_d___a_l_e_r_t or _f_i_l_e___r_e_n_a_m_e___f_a_i_l_e_d___a_l_e_r_t is │ │ │ │ │ posted. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) ********** │ │ │ │ │ +********** iinnffoo__hhaasshheess(()) iinnffoo__hhaasshh(()) ********** │ │ │ │ │ info_hash_t iinnffoo__hhaasshheess () const; │ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const; │ │ │ │ │ returns the info-hash(es) of the torrent. If this handle is to a torrent that │ │ │ │ │ hasn't loaded yet (for instance by being added) by a URL, the returned value is │ │ │ │ │ undefined. The info_hash() returns the SHA-1 info-hash for v1 torrents and a │ │ │ │ │ truncated hash for v2 torrents. For the full v2 info-hash, use info_hashes() │ │ │ │ │ instead. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ooppeerraattoorr<<(()) ooppeerraattoorr!!==(()) ooppeerraattoorr====(()) ********** │ │ │ │ │ -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. │ │ │ │ │ @@ -6239,18 +6239,18 @@ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r_._h_p_p" │ │ │ │ │ The disk buffer holder acts like a unique_ptr that frees a disk buffer when │ │ │ │ │ it's destructed │ │ │ │ │ If this buffer holder is moved-from, default constructed or reset, data() will │ │ │ │ │ return nullptr. │ │ │ │ │ struct disk_buffer_holder │ │ │ │ │ { │ │ │ │ │ - disk_buffer_holder& ooppeerraattoorr== (disk_buffer_holder&&) & noexcept; │ │ │ │ │ ddiisskk__bbuuffffeerr__hhoollddeerr (disk_buffer_holder&&) noexcept; │ │ │ │ │ - ddiisskk__bbuuffffeerr__hhoollddeerr (disk_buffer_holder const&) = delete; │ │ │ │ │ + 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; │ │ │ │ │ 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; │ │ │ │ │ @@ -6296,17 +6296,17 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ sseettttiinnggss__iinntteerrffaaccee ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p" │ │ │ │ │ the common interface to _s_e_t_t_i_n_g_s___p_a_c_k and the internal representation of │ │ │ │ │ settings. │ │ │ │ │ struct settings_interface │ │ │ │ │ { │ │ │ │ │ - virtual void sseett__iinntt (int name, int val) = 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 bool hhaass__vvaall (int name) const = 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 ************ │ │ │ │ │ @@ -6583,25 +6583,25 @@ │ │ │ │ │ ************ ffiillee__rreennaammeedd__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ This is posted as a response to a _t_o_r_r_e_n_t___h_a_n_d_l_e_:_:_r_e_n_a_m_e___f_i_l_e_(_) call, if the │ │ │ │ │ rename operation succeeds. │ │ │ │ │ struct file_renamed_alert final : torrent_alert │ │ │ │ │ { │ │ │ │ │ std::string mmeessssaaggee () const override; │ │ │ │ │ - char const* oolldd__nnaammee () const; │ │ │ │ │ char const* nneeww__nnaammee () const; │ │ │ │ │ + char const* oolldd__nnaammee () const; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category:: │ │ │ │ │ storage; │ │ │ │ │ file_index_t const index; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** nneeww__nnaammee(()) oolldd__nnaammee(()) ********** │ │ │ │ │ -char const* oolldd__nnaammee () const; │ │ │ │ │ char const* nneeww__nnaammee () const; │ │ │ │ │ +char const* oolldd__nnaammee () const; │ │ │ │ │ returns the new and previous file name, respectively. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ index │ │ │ │ │ refers to the index of the file that was renamed, │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ffiillee__rreennaammee__ffaaiilleedd__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ @@ -7225,15 +7225,15 @@ │ │ │ │ │ char const* ssttoorraaggee__ppaatthh () const; │ │ │ │ │ char const* oolldd__ppaatthh () const; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category:: │ │ │ │ │ storage; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ssttoorraaggee__ppaatthh(()) oolldd__ppaatthh(()) ********** │ │ │ │ │ +********** oolldd__ppaatthh(()) ssttoorraaggee__ppaatthh(()) ********** │ │ │ │ │ char const* ssttoorraaggee__ppaatthh () const; │ │ │ │ │ char const* oolldd__ppaatthh () const; │ │ │ │ │ the path the torrent was moved to and from, respectively. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ssttoorraaggee__mmoovveedd__ffaaiilleedd__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ The storage_moved_failed_alert is generated when an attempt to move the │ │ │ │ │ @@ -8471,24 +8471,24 @@ │ │ │ │ │ ************ ddhhtt__lliivvee__nnooddeess__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ posted in response to a call to session::dht_live_nodes(). It contains the live │ │ │ │ │ nodes from the DHT routing table of one of the DHT nodes running locally. │ │ │ │ │ struct dht_live_nodes_alert final : alert │ │ │ │ │ { │ │ │ │ │ std::string mmeessssaaggee () const override; │ │ │ │ │ - int nnuumm__nnooddeess () const; │ │ │ │ │ std::vector> nnooddeess () const; │ │ │ │ │ + int nnuumm__nnooddeess () const; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category::dht; │ │ │ │ │ sha1_hash node_id; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** nnooddeess(()) nnuumm__nnooddeess(()) ********** │ │ │ │ │ -int nnuumm__nnooddeess () const; │ │ │ │ │ +********** nnuumm__nnooddeess(()) 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] │ │ │ │ │ ************ 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" │ │ │ │ │ @@ -8509,30 +8509,30 @@ │ │ │ │ │ ************ ddhhtt__ssaammppllee__iinnffoohhaasshheess__aalleerrtt ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p" │ │ │ │ │ posted as a response to a call to session::dht_sample_infohashes() with the │ │ │ │ │ information from the DHT response message. │ │ │ │ │ struct dht_sample_infohashes_alert final : alert │ │ │ │ │ { │ │ │ │ │ std::string mmeessssaaggee () const override; │ │ │ │ │ - std::vector ssaammpplleess () const; │ │ │ │ │ int nnuumm__ssaammpplleess () const; │ │ │ │ │ + std::vector ssaammpplleess () const; │ │ │ │ │ int nnuumm__nnooddeess () const; │ │ │ │ │ std::vector> nnooddeess () const; │ │ │ │ │ │ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category:: │ │ │ │ │ dht_operation; │ │ │ │ │ sha1_hash node_id; │ │ │ │ │ aux::noexcept_movable endpoint; │ │ │ │ │ time_duration const interval; │ │ │ │ │ int const num_infohashes; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ssaammpplleess(()) nnuumm__ssaammpplleess(()) ********** │ │ │ │ │ -std::vector ssaammpplleess () const; │ │ │ │ │ int nnuumm__ssaammpplleess () const; │ │ │ │ │ +std::vector ssaammpplleess () const; │ │ │ │ │ returns the number of info-hashes returned by the node, as well as the actual │ │ │ │ │ info-hashes. num_samples() is more efficient than samples().size(). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** nnuumm__nnooddeess(()) ********** │ │ │ │ │ int nnuumm__nnooddeess () const; │ │ │ │ │ The total number of nodes returned by nodes(). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ @@ -8577,17 +8577,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 │ │ │ │ │ @@ -8924,23 +8924,23 @@ │ │ │ │ │ ************ ccoouunntteerrss ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_r_f_o_r_m_a_n_c_e___c_o_u_n_t_e_r_s_._h_p_p" │ │ │ │ │ struct counters │ │ │ │ │ { │ │ │ │ │ ccoouunntteerrss () ; │ │ │ │ │ counters& ooppeerraattoorr== (counters const&) & ; │ │ │ │ │ ccoouunntteerrss (counters const&) ; │ │ │ │ │ - std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ; │ │ │ │ │ std::int64_t ooppeerraattoorr[[]] (int i) const ; │ │ │ │ │ + std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ; │ │ │ │ │ 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] │ │ │ │ │ ********** iinncc__ssttaattss__ccoouunntteerr(()) ooppeerraattoorr[[]](()) ********** │ │ │ │ │ -std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ; │ │ │ │ │ std::int64_t ooppeerraattoorr[[]] (int i) const ; │ │ │ │ │ +std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ; │ │ │ │ │ returns the new value │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ssttaattss__mmeettrriicc ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___s_t_a_t_s_._h_p_p" │ │ │ │ │ describes one statistics metric from the _s_e_s_s_i_o_n. For more information, see the │ │ │ │ │ _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section. │ │ │ │ │ struct stats_metric │ │ │ │ │ @@ -8986,20 +8986,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&&); │ │ │ │ │ - ip_filter& ooppeerraattoorr== (ip_filter const&); │ │ │ │ │ - iipp__ffiilltteerr (ip_filter const&); │ │ │ │ │ ip_filter& ooppeerraattoorr== (ip_filter&&); │ │ │ │ │ - iipp__ffiilltteerr (); │ │ │ │ │ ~~iipp__ffiilltteerr (); │ │ │ │ │ + iipp__ffiilltteerr (); │ │ │ │ │ + iipp__ffiilltteerr (ip_filter const&); │ │ │ │ │ + iipp__ffiilltteerr (ip_filter&&); │ │ │ │ │ + ip_filter& ooppeerraattoorr== (ip_filter const&); │ │ │ │ │ bool eemmppttyy () const; │ │ │ │ │ void aadddd__rruullee (address const& first, address const& last, std::uint32_t │ │ │ │ │ flags); │ │ │ │ │ std::uint32_t aacccceessss (address const& addr) const; │ │ │ │ │ filter_tuple_t eexxppoorrtt__ffiilltteerr () const; │ │ │ │ │ │ │ │ │ │ enum access_flags │ │ │ │ │ @@ -9048,20 +9048,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 │ │ │ │ │ { │ │ │ │ │ + ppoorrtt__ffiilltteerr (port_filter&&); │ │ │ │ │ + port_filter& ooppeerraattoorr== (port_filter&&); │ │ │ │ │ + ppoorrtt__ffiilltteerr (port_filter const&); │ │ │ │ │ + ppoorrtt__ffiilltteerr (); │ │ │ │ │ ~~ppoorrtt__ffiilltteerr (); │ │ │ │ │ port_filter& ooppeerraattoorr== (port_filter const&); │ │ │ │ │ - ppoorrtt__ffiilltteerr (); │ │ │ │ │ - ppoorrtt__ffiilltteerr (port_filter const&); │ │ │ │ │ - port_filter& ooppeerraattoorr== (port_filter&&); │ │ │ │ │ - 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, │ │ │ │ │ @@ -9103,46 +9103,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 (preformatted_type); │ │ │ │ │ - eennttrryy (list_type); │ │ │ │ │ eennttrryy (span); │ │ │ │ │ - eennttrryy (integer_type); │ │ │ │ │ eennttrryy (dictionary_type); │ │ │ │ │ + eennttrryy (integer_type); │ │ │ │ │ + eennttrryy (preformatted_type); │ │ │ │ │ + eennttrryy (list_type); │ │ │ │ │ eennttrryy (U v); │ │ │ │ │ eennttrryy (data_type t); │ │ │ │ │ eennttrryy (bdecode_node const& n); │ │ │ │ │ entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ + entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ + entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (span) &; │ │ │ │ │ - entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ - entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ - entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ - entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ - entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ entry& ooppeerraattoorr== (U v) &; │ │ │ │ │ - integer_type const& iinntteeggeerr () const; │ │ │ │ │ integer_type& iinntteeggeerr (); │ │ │ │ │ + list_type const& lliisstt () const; │ │ │ │ │ + preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ list_type& lliisstt (); │ │ │ │ │ dictionary_type& ddiicctt (); │ │ │ │ │ - preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ string_type& ssttrriinngg (); │ │ │ │ │ - preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ string_type const& ssttrriinngg () const; │ │ │ │ │ dictionary_type const& ddiicctt () const; │ │ │ │ │ - list_type const& lliisstt () const; │ │ │ │ │ + preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ + integer_type const& iinntteeggeerr () const; │ │ │ │ │ void sswwaapp (entry& e); │ │ │ │ │ entry& ooppeerraattoorr[[]] (string_view key); │ │ │ │ │ entry const& ooppeerraattoorr[[]] (string_view key) const; │ │ │ │ │ - entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ entry const* ffiinndd__kkeeyy (string_view key) const; │ │ │ │ │ + entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ std::string ttoo__ssttrriinngg (bool single_line = false) const; │ │ │ │ │ │ │ │ │ │ enum data_type │ │ │ │ │ { │ │ │ │ │ int_t, │ │ │ │ │ string_t, │ │ │ │ │ list_t, │ │ │ │ │ @@ -9153,52 +9153,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 (preformatted_type); │ │ │ │ │ -eennttrryy (list_type); │ │ │ │ │ eennttrryy (span); │ │ │ │ │ -eennttrryy (integer_type); │ │ │ │ │ eennttrryy (dictionary_type); │ │ │ │ │ +eennttrryy (integer_type); │ │ │ │ │ +eennttrryy (preformatted_type); │ │ │ │ │ +eennttrryy (list_type); │ │ │ │ │ constructors directly from a specific type. The content of the argument is │ │ │ │ │ copied into the newly constructed _e_n_t_r_y │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eennttrryy(()) ********** │ │ │ │ │ eennttrryy (data_type t); │ │ │ │ │ construct an empty _e_n_t_r_y of the specified type. see _d_a_t_a___t_y_p_e enum. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eennttrryy(()) ********** │ │ │ │ │ eennttrryy (bdecode_node const& n); │ │ │ │ │ construct from _b_d_e_c_o_d_e___n_o_d_e parsed form (see _b_d_e_c_o_d_e_(_)) │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ooppeerraattoorr==(()) ********** │ │ │ │ │ entry& ooppeerraattoorr== (list_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (dictionary_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ +entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ +entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (entry const&) &; │ │ │ │ │ entry& ooppeerraattoorr== (span) &; │ │ │ │ │ -entry& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ -entry& ooppeerraattoorr== (preformatted_type) &; │ │ │ │ │ -entry& ooppeerraattoorr== (entry&&) & noexcept; │ │ │ │ │ -entry& ooppeerraattoorr== (integer_type) &; │ │ │ │ │ -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] │ │ │ │ │ -********** ssttrriinngg(()) pprreeffoorrmmaatttteedd(()) lliisstt(()) ddiicctt(()) iinntteeggeerr(()) ********** │ │ │ │ │ -integer_type const& iinntteeggeerr () const; │ │ │ │ │ +********** ddiicctt(()) pprreeffoorrmmaatttteedd(()) ssttrriinngg(()) lliisstt(()) iinntteeggeerr(()) ********** │ │ │ │ │ integer_type& iinntteeggeerr (); │ │ │ │ │ +list_type const& lliisstt () const; │ │ │ │ │ +preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ list_type& lliisstt (); │ │ │ │ │ dictionary_type& ddiicctt (); │ │ │ │ │ -preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ string_type& ssttrriinngg (); │ │ │ │ │ -preformatted_type const& pprreeffoorrmmaatttteedd () const; │ │ │ │ │ string_type const& ssttrriinngg () const; │ │ │ │ │ dictionary_type const& ddiicctt () const; │ │ │ │ │ -list_type const& lliisstt () const; │ │ │ │ │ +preformatted_type& pprreeffoorrmmaatttteedd (); │ │ │ │ │ +integer_type const& iinntteeggeerr () const; │ │ │ │ │ The integer(), string(), list() and dict() functions are accessors that return │ │ │ │ │ the respective type. If the entry object isn't of the type you request, the │ │ │ │ │ accessor will throw system_error. You can ask an entry for its type through the │ │ │ │ │ type() function. │ │ │ │ │ If you want to create an entry you give it the type you want it to have in its │ │ │ │ │ constructor, and then use one of the non-const accessors to get a reference │ │ │ │ │ which you then can assign the value you want it to have. │ │ │ │ │ @@ -9240,16 +9240,16 @@ │ │ │ │ │ The non-const versions of the operator[] will return a reference to either the │ │ │ │ │ existing element at the given key or, if there is no element with the given │ │ │ │ │ key, a reference to a newly inserted element at that key. │ │ │ │ │ The const version of operator[] will only return a reference to an existing │ │ │ │ │ element at the given key. If the key is not found, it will throw system_error. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ffiinndd__kkeeyy(()) ********** │ │ │ │ │ -entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ entry const* ffiinndd__kkeeyy (string_view key) const; │ │ │ │ │ +entry* ffiinndd__kkeeyy (string_view key); │ │ │ │ │ These functions requires the _e_n_t_r_y to be a dictionary, if it isn't they will │ │ │ │ │ throw system_error. │ │ │ │ │ They will look for an element at the given key in the dictionary, if the │ │ │ │ │ element cannot be found, they will return nullptr. If an element with the given │ │ │ │ │ key is found, the return a pointer to it. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ttoo__ssttrriinngg(()) ********** │ │ │ │ │ @@ -9325,60 +9325,60 @@ │ │ │ │ │ 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" │ │ │ │ │ This class holds state for creating a torrent. After having added all │ │ │ │ │ information to it, call _c_r_e_a_t_e___t_o_r_r_e_n_t_:_:_g_e_n_e_r_a_t_e_(_) to generate the torrent. The │ │ │ │ │ _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 = {}); │ │ │ │ │ + explicit ccrreeaattee__ttoorrrreenntt (torrent_info const& ti); │ │ │ │ │ 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; │ │ │ │ │ - bool iiss__vv22__oonnllyy () 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; │ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t f); │ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const; │ │ │ │ │ - int ppiieeccee__ssiizzee (piece_index_t i) const; │ │ │ │ │ int ppiieeccee__lleennggtthh () const; │ │ │ │ │ - void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih); │ │ │ │ │ + int ppiieeccee__ssiizzee (piece_index_t i) const; │ │ │ │ │ void aadddd__ccoolllleeccttiioonn (string_view c); │ │ │ │ │ + void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih); │ │ │ │ │ │ │ │ │ │ static constexpr create_flags_t mmooddiiffiiccaattiioonn__ttiimmee = 2_bit; │ │ │ │ │ static constexpr create_flags_t ssyymmlliinnkkss = 3_bit; │ │ │ │ │ static constexpr create_flags_t vv22__oonnllyy = 5_bit; │ │ │ │ │ static constexpr create_flags_t vv11__oonnllyy = 6_bit; │ │ │ │ │ static constexpr create_flags_t ccaannoonniiccaall__ffiilleess = 7_bit; │ │ │ │ │ static constexpr create_flags_t nnoo__aattttrriibbuutteess = 8_bit; │ │ │ │ │ static constexpr create_flags_t ccaannoonniiccaall__ffiilleess__nnoo__ttaaiill__ppaaddddiinngg = 9_bit; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ccrreeaattee__ttoorrrreenntt(()) ********** │ │ │ │ │ -explicit ccrreeaattee__ttoorrrreenntt (torrent_info const& ti); │ │ │ │ │ explicit ccrreeaattee__ttoorrrreenntt (file_storage& fs, int piece_size = 0 │ │ │ │ │ , create_flags_t flags = {}); │ │ │ │ │ +explicit ccrreeaattee__ttoorrrreenntt (torrent_info const& ti); │ │ │ │ │ The piece_size is the size of each piece in bytes. It must be a power of 2 and │ │ │ │ │ a minimum of 16 kiB. If a piece size of 0 is specified, a piece_size will be │ │ │ │ │ set automatically. │ │ │ │ │ The flags arguments specifies options for the torrent creation. It can be any │ │ │ │ │ combination of the flags defined by create_flags_t. │ │ │ │ │ The _f_i_l_e___s_t_o_r_a_g_e (fs) parameter defines the files, sizes and their properties │ │ │ │ │ for the torrent to be created. Set this up first, before passing it to the │ │ │ │ │ @@ -9494,16 +9494,16 @@ │ │ │ │ │ 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); │ │ │ │ │ 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. │ │ │ │ │ @@ -9522,23 +9522,23 @@ │ │ │ │ │ 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(()) ********** │ │ │ │ │ -int ppiieeccee__ssiizzee (piece_index_t i) const; │ │ │ │ │ int ppiieeccee__lleennggtthh () const; │ │ │ │ │ +int ppiieeccee__ssiizzee (piece_index_t i) 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(()) ********** │ │ │ │ │ -void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih); │ │ │ │ │ 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. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ modification_time │ │ │ │ │ @@ -9588,17 +9588,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 │ │ │ │ │ @@ -9606,30 +9606,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, disk_io_constructor_type disk_io │ │ │ │ │ , std::function const& f, error_code& ec); │ │ │ │ │ -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, error_code& ec); │ │ │ │ │ + , std::function const& f); │ │ │ │ │ void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p │ │ │ │ │ - , settings_interface const& settings, disk_io_constructor_type disk_io │ │ │ │ │ , std::function const& f, error_code& ec); │ │ │ │ │ inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p, │ │ │ │ │ error_code& ec); │ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p │ │ │ │ │ - , settings_interface const& settings │ │ │ │ │ - , std::function const& f); │ │ │ │ │ inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p); │ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p │ │ │ │ │ - , 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); │ │ │ │ │ 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. │ │ │ │ │ @@ -9639,62 +9639,62 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ bbiittffiieelldd ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_b_i_t_f_i_e_l_d_._h_p_p" │ │ │ │ │ The _b_i_t_f_i_e_l_d type stores any number of bits as a _b_i_t_f_i_e_l_d in a heap allocated │ │ │ │ │ array. │ │ │ │ │ struct bitfield │ │ │ │ │ { │ │ │ │ │ - bbiittffiieelldd () noexcept = default; │ │ │ │ │ - bbiittffiieelldd (int bits, bool val); │ │ │ │ │ - bbiittffiieelldd (bitfield const& rhs); │ │ │ │ │ - bbiittffiieelldd (bitfield&& rhs) noexcept = default; │ │ │ │ │ bbiittffiieelldd (char const* b, int bits); │ │ │ │ │ + bbiittffiieelldd (bitfield const& rhs); │ │ │ │ │ + bbiittffiieelldd (int bits, bool val); │ │ │ │ │ + bbiittffiieelldd () noexcept = default; │ │ │ │ │ explicit bbiittffiieelldd (int bits); │ │ │ │ │ + bbiittffiieelldd (bitfield&& rhs) noexcept = default; │ │ │ │ │ void aassssiiggnn (char const* b, int const bits); │ │ │ │ │ - bool ooppeerraattoorr[[]] (int index) const noexcept; │ │ │ │ │ bool ggeett__bbiitt (int index) const noexcept; │ │ │ │ │ + bool ooppeerraattoorr[[]] (int index) const noexcept; │ │ │ │ │ void sseett__bbiitt (int index) noexcept; │ │ │ │ │ void cclleeaarr__bbiitt (int index) noexcept; │ │ │ │ │ bool aallll__sseett () const noexcept; │ │ │ │ │ bool nnoonnee__sseett () const noexcept; │ │ │ │ │ int ssiizzee () const noexcept; │ │ │ │ │ int nnuumm__wwoorrddss () const noexcept; │ │ │ │ │ int nnuumm__bbyytteess () const noexcept; │ │ │ │ │ bool eemmppttyy () const noexcept; │ │ │ │ │ - char const* ddaattaa () const noexcept; │ │ │ │ │ char* ddaattaa () noexcept; │ │ │ │ │ + char const* ddaattaa () const noexcept; │ │ │ │ │ void sswwaapp (bitfield& rhs) noexcept; │ │ │ │ │ int ccoouunntt () const noexcept; │ │ │ │ │ int ffiinndd__ffiirrsstt__sseett () const noexcept; │ │ │ │ │ int ffiinndd__llaasstt__cclleeaarr () const noexcept; │ │ │ │ │ bool ooppeerraattoorr==== (lt::bitfield const& rhs) const; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** bbiittffiieelldd(()) ********** │ │ │ │ │ -bbiittffiieelldd () noexcept = default; │ │ │ │ │ -bbiittffiieelldd (int bits, bool val); │ │ │ │ │ -bbiittffiieelldd (bitfield const& rhs); │ │ │ │ │ -bbiittffiieelldd (bitfield&& rhs) noexcept = default; │ │ │ │ │ bbiittffiieelldd (char const* b, int bits); │ │ │ │ │ +bbiittffiieelldd (bitfield const& rhs); │ │ │ │ │ +bbiittffiieelldd (int bits, bool val); │ │ │ │ │ +bbiittffiieelldd () noexcept = default; │ │ │ │ │ explicit bbiittffiieelldd (int bits); │ │ │ │ │ +bbiittffiieelldd (bitfield&& rhs) noexcept = default; │ │ │ │ │ constructs a new _b_i_t_f_i_e_l_d. The default constructor creates an empty _b_i_t_f_i_e_l_d. │ │ │ │ │ bits is the size of the _b_i_t_f_i_e_l_d (specified in bits). val is the value to │ │ │ │ │ initialize the bits to. If not specified all bits are initialized to 0. │ │ │ │ │ The constructor taking a pointer b and bits copies a _b_i_t_f_i_e_l_d from the │ │ │ │ │ specified buffer, and bits number of bits (rounded up to the nearest byte │ │ │ │ │ boundary). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** aassssiiggnn(()) ********** │ │ │ │ │ void aassssiiggnn (char const* b, int const bits); │ │ │ │ │ copy _b_i_t_f_i_e_l_d from buffer b of bits number of bits, rounded up to the nearest │ │ │ │ │ byte boundary. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** ooppeerraattoorr[[]](()) ggeett__bbiitt(()) ********** │ │ │ │ │ -bool ooppeerraattoorr[[]] (int index) const noexcept; │ │ │ │ │ +********** ggeett__bbiitt(()) ooppeerraattoorr[[]](()) ********** │ │ │ │ │ bool ggeett__bbiitt (int index) const noexcept; │ │ │ │ │ +bool ooppeerraattoorr[[]] (int index) const noexcept; │ │ │ │ │ query bit at index. Returns true if bit is 1, otherwise false. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** cclleeaarr__bbiitt(()) sseett__bbiitt(()) ********** │ │ │ │ │ void sseett__bbiitt (int index) noexcept; │ │ │ │ │ void cclleeaarr__bbiitt (int index) noexcept; │ │ │ │ │ set bit at index to 0 (clear_bit) or 1 (set_bit). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ @@ -9720,16 +9720,16 @@ │ │ │ │ │ returns the number of bytes needed to represent all bits in this _b_i_t_f_i_e_l_d │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eemmppttyy(()) ********** │ │ │ │ │ bool eemmppttyy () const noexcept; │ │ │ │ │ returns true if the _b_i_t_f_i_e_l_d has zero size. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ddaattaa(()) ********** │ │ │ │ │ -char const* ddaattaa () const noexcept; │ │ │ │ │ char* ddaattaa () noexcept; │ │ │ │ │ +char const* ddaattaa () const noexcept; │ │ │ │ │ returns a pointer to the internal buffer of the _b_i_t_f_i_e_l_d, or nullptr if it's │ │ │ │ │ empty. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** sswwaapp(()) ********** │ │ │ │ │ void sswwaapp (bitfield& rhs) noexcept; │ │ │ │ │ swaps the bit-fields two variables refer to │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ @@ -9758,29 +9758,29 @@ │ │ │ │ │ If you want to reuse the _h_a_s_h_e_r object once you have created a hash, you have │ │ │ │ │ to call reset() to reinitialize it. │ │ │ │ │ The built-in software version of sha1-algorithm was implemented by Steve Reid │ │ │ │ │ and released as public domain. For more info, see src/sha1.cpp. │ │ │ │ │ class hasher │ │ │ │ │ { │ │ │ │ │ hhaasshheerr (); │ │ │ │ │ - explicit hhaasshheerr (span data); │ │ │ │ │ - hasher& ooppeerraattoorr== (hasher const&) &; │ │ │ │ │ hhaasshheerr (char const* data, int len); │ │ │ │ │ hhaasshheerr (hasher const&); │ │ │ │ │ + explicit hhaasshheerr (span data); │ │ │ │ │ + hasher& ooppeerraattoorr== (hasher const&) &; │ │ │ │ │ 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] │ │ │ │ │ -********** hhaasshheerr(()) ooppeerraattoorr==(()) ********** │ │ │ │ │ -explicit hhaasshheerr (span data); │ │ │ │ │ -hasher& ooppeerraattoorr== (hasher const&) &; │ │ │ │ │ +********** ooppeerraattoorr==(()) hhaasshheerr(()) ********** │ │ │ │ │ hhaasshheerr (char const* data, int len); │ │ │ │ │ hhaasshheerr (hasher const&); │ │ │ │ │ +explicit hhaasshheerr (span data); │ │ │ │ │ +hasher& ooppeerraattoorr== (hasher const&) &; │ │ │ │ │ this is the same as default constructing followed by a call to update(data, │ │ │ │ │ len). │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** uuppddaattee(()) ********** │ │ │ │ │ hasher& uuppddaattee (span data); │ │ │ │ │ hasher& uuppddaattee (char const* data, int len); │ │ │ │ │ append the following bytes to what is being hashed │ │ │ │ │ @@ -9797,35 +9797,35 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ hhaasshheerr225566 ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_h_a_s_h_e_r_._h_p_p" │ │ │ │ │ class hasher256 │ │ │ │ │ { │ │ │ │ │ hhaasshheerr225566 (); │ │ │ │ │ hhaasshheerr225566 (hasher256 const&); │ │ │ │ │ - hhaasshheerr225566 (char const* data, int len); │ │ │ │ │ - hasher256& ooppeerraattoorr== (hasher256 const&) &; │ │ │ │ │ explicit hhaasshheerr225566 (span data); │ │ │ │ │ - hasher256& uuppddaattee (span data); │ │ │ │ │ + hasher256& ooppeerraattoorr== (hasher256 const&) &; │ │ │ │ │ + hhaasshheerr225566 (char const* data, int len); │ │ │ │ │ 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] │ │ │ │ │ -********** ooppeerraattoorr==(()) hhaasshheerr225566(()) ********** │ │ │ │ │ +********** hhaasshheerr225566(()) ooppeerraattoorr==(()) ********** │ │ │ │ │ hhaasshheerr225566 (hasher256 const&); │ │ │ │ │ -hhaasshheerr225566 (char const* data, int len); │ │ │ │ │ -hasher256& ooppeerraattoorr== (hasher256 const&) &; │ │ │ │ │ explicit hhaasshheerr225566 (span data); │ │ │ │ │ +hasher256& ooppeerraattoorr== (hasher256 const&) &; │ │ │ │ │ +hhaasshheerr225566 (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(()) ********** │ │ │ │ │ -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] │ │ │ │ │ @@ -10380,19 +10380,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&) &; │ │ │ │ │ explicit aannnnoouunnccee__eennttrryy (string_view u); │ │ │ │ │ + aannnnoouunnccee__eennttrryy (announce_entry const&); │ │ │ │ │ ~~aannnnoouunnccee__eennttrryy (); │ │ │ │ │ aannnnoouunnccee__eennttrryy (); │ │ │ │ │ - aannnnoouunnccee__eennttrryy (announce_entry const&); │ │ │ │ │ + announce_entry& ooppeerraattoorr== (announce_entry const&) &; │ │ │ │ │ │ │ │ │ │ enum tracker_source │ │ │ │ │ { │ │ │ │ │ source_torrent, │ │ │ │ │ source_client, │ │ │ │ │ source_magnet_link, │ │ │ │ │ source_tex, │ │ │ │ │ @@ -10403,20 +10403,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==(()) ********** │ │ │ │ │ -announce_entry& ooppeerraattoorr== (announce_entry const&) &; │ │ │ │ │ +********** ~~aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) aannnnoouunnccee__eennttrryy(()) ********** │ │ │ │ │ explicit aannnnoouunnccee__eennttrryy (string_view u); │ │ │ │ │ +aannnnoouunnccee__eennttrryy (announce_entry const&); │ │ │ │ │ ~~aannnnoouunnccee__eennttrryy (); │ │ │ │ │ aannnnoouunnccee__eennttrryy (); │ │ │ │ │ -aannnnoouunnccee__eennttrryy (announce_entry const&); │ │ │ │ │ +announce_entry& ooppeerraattoorr== (announce_entry const&) &; │ │ │ │ │ constructs a tracker announce _e_n_t_r_y with u as the URL. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** eennuumm ttrraacckkeerr__ssoouurrccee ********** │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p" │ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ │ │ │ │ │ |_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ | │ │ │ │ │ |_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_ _ _ _ _ _ _ _ _ _ | │ │ │ │ │ @@ -11846,24 +11846,24 @@ │ │ │ │ │ next time the SAM connection is re-established (by restarting or changing │ │ │ │ │ i2p_hostname or i2p_port). │ │ │ │ │ struct settings_pack final : settings_interface │ │ │ │ │ { │ │ │ │ │ friend void aappppllyy__ppaacckk__iimmppll (settings_pack const* │ │ │ │ │ , aux::session_settings_single_thread& │ │ │ │ │ , std::vector*); │ │ │ │ │ - void sseett__iinntt (int name, int val) override; │ │ │ │ │ void sseett__ssttrr (int name, std::string val) override; │ │ │ │ │ - void sseett__iinntt (int name, flags::bitfield_flag const val); │ │ │ │ │ void sseett__bbooooll (int name, bool val) override; │ │ │ │ │ + void sseett__iinntt (int name, flags::bitfield_flag const val); │ │ │ │ │ + void sseett__iinntt (int name, int 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, │ │ │ │ │ @@ -11933,19 +11933,19 @@ │ │ │ │ │ socks5, │ │ │ │ │ socks5_pw, │ │ │ │ │ http, │ │ │ │ │ http_pw, │ │ │ │ │ }; │ │ │ │ │ }; │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -********** sseett__iinntt(()) sseett__bbooooll(()) sseett__ssttrr(()) ********** │ │ │ │ │ -void sseett__iinntt (int name, int val) override; │ │ │ │ │ +********** sseett__ssttrr(()) sseett__bbooooll(()) sseett__iinntt(()) ********** │ │ │ │ │ void sseett__ssttrr (int name, std::string val) override; │ │ │ │ │ -void sseett__iinntt (int name, flags::bitfield_flag const val); │ │ │ │ │ void sseett__bbooooll (int name, bool val) override; │ │ │ │ │ +void sseett__iinntt (int name, flags::bitfield_flag const val); │ │ │ │ │ +void sseett__iinntt (int name, int val) override; │ │ │ │ │ set a configuration option in the _s_e_t_t_i_n_g_s___p_a_c_k. name is one of the enum values │ │ │ │ │ from string_types, int_types or bool_types. They must match the respective type │ │ │ │ │ of the set_* function. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** hhaass__vvaall(()) ********** │ │ │ │ │ bool hhaass__vvaall (int name) const override; │ │ │ │ │ queries whether the specified configuration option has a value set in this │ │ │ │ │ @@ -11957,17 +11957,17 @@ │ │ │ │ │ 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__ssttrr(()) ggeett__iinntt(()) ggeett__bbooooll(()) ********** │ │ │ │ │ +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; │ │ │ │ │ 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" │ │ │ │ │ @@ -12143,15 +12143,15 @@ │ │ │ │ │ This configuration is intended to be the starting point for embedded devices. │ │ │ │ │ It will significantly reduce memory usage. │ │ │ │ │ high_performance_seed returns settings optimized for a seed box, serving many │ │ │ │ │ peers and that doesn't do any downloading. It has a 128 MB disk cache and has a │ │ │ │ │ limit of 400 files in its file pool. It support fast upload rates by allowing │ │ │ │ │ large send buffers. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ -************ sseettttiinngg__bbyy__nnaammee(()) nnaammee__ffoorr__sseettttiinngg(()) ************ │ │ │ │ │ +************ nnaammee__ffoorr__sseettttiinngg(()) sseettttiinngg__bbyy__nnaammee(()) ************ │ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p" │ │ │ │ │ int sseettttiinngg__bbyy__nnaammee (string_view name); │ │ │ │ │ char const* nnaammee__ffoorr__sseettttiinngg (int s); │ │ │ │ │ converts a setting integer (from the enums string_types, int_types or │ │ │ │ │ bool_types) to a string, and vice versa. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ************ ddeeffaauulltt__sseettttiinnggss(()) ************ │ │ │ │ │ @@ -12164,46 +12164,46 @@ │ │ │ │ │ Sometimes it's important to get a non-owning reference to the root node ( to be │ │ │ │ │ able to copy it as a reference for instance). For that, use the _n_o_n___o_w_n_i_n_g_(_) │ │ │ │ │ member function. │ │ │ │ │ There are 5 different types of nodes, see _t_y_p_e___t. │ │ │ │ │ struct bdecode_node │ │ │ │ │ { │ │ │ │ │ bbddeeccooddee__nnooddee () = default; │ │ │ │ │ + bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default; │ │ │ │ │ + bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node const&); │ │ │ │ │ bbddeeccooddee__nnooddee (bdecode_node&&) noexcept; │ │ │ │ │ - bdecode_node& ooppeerraattoorr== (bdecode_node const&) &; │ │ │ │ │ - bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default; │ │ │ │ │ type_t ttyyppee () const noexcept; │ │ │ │ │ explicit operator bbooooll () const noexcept; │ │ │ │ │ bdecode_node nnoonn__oowwnniinngg () const; │ │ │ │ │ - span ddaattaa__sseeccttiioonn () const noexcept; │ │ │ │ │ std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept; │ │ │ │ │ + span ddaattaa__sseeccttiioonn () const noexcept; │ │ │ │ │ + bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ - bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ int lliisstt__ssiizzee () const; │ │ │ │ │ string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i │ │ │ │ │ , string_view default_val = string_view()) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ - int ddiicctt__ssiizzee () const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) 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 (string_view key) const; │ │ │ │ │ + std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ + int ddiicctt__ssiizzee () const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key │ │ │ │ │ , string_view default_value = string_view()) const; │ │ │ │ │ - std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ - std::pair ddiicctt__aatt__nnooddee (int i) const; │ │ │ │ │ std::int64_t iinntt__vvaalluuee () const; │ │ │ │ │ - std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ - int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ + std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ char const* ssttrriinngg__ppttrr () 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 │ │ │ │ │ @@ -12216,19 +12216,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&) &; │ │ │ │ │ -bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default; │ │ │ │ │ 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] │ │ │ │ │ @@ -12238,49 +12238,49 @@ │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** nnoonn__oowwnniinngg(()) ********** │ │ │ │ │ bdecode_node nnoonn__oowwnniinngg () const; │ │ │ │ │ return a non-owning reference to this node. This is useful to refer to the root │ │ │ │ │ node without copying it in assignments. │ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e] │ │ │ │ │ ********** ddaattaa__sseeccttiioonn(()) ddaattaa__ooffffsseett(()) ********** │ │ │ │ │ -span ddaattaa__sseeccttiioonn () const noexcept; │ │ │ │ │ std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept; │ │ │ │ │ +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__ssttrriinngg__vvaalluuee__aatt(()) lliisstt__ssiizzee(()) lliisstt__iinntt__vvaalluuee__aatt(()) ********** │ │ │ │ │ +********** lliisstt__ssttrriinngg__vvaalluuee__aatt(()) lliisstt__iinntt__vvaalluuee__aatt(()) lliisstt__aatt(()) lliisstt__ssiizzee(()) ********** │ │ │ │ │ +bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i │ │ │ │ │ , std::int64_t default_val = 0) const; │ │ │ │ │ -bdecode_node lliisstt__aatt (int i) const; │ │ │ │ │ int lliisstt__ssiizzee () 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__ffiinndd__ddiicctt(()) ddiicctt__aatt(()) ddiicctt__ffiinndd__iinntt(()) ddiicctt__ssiizzee(()) ddiicctt__aatt__nnooddee(()) │ │ │ │ │ -ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ffiinndd(()) ddiicctt__ffiinndd__lliisstt(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) │ │ │ │ │ -ddiicctt__ffiinndd__ssttrriinngg(()) ********** │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ -int ddiicctt__ssiizzee () const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ +********** ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) ddiicctt__ffiinndd(()) ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__aatt(()) │ │ │ │ │ +ddiicctt__ffiinndd__lliisstt(()) ddiicctt__ffiinndd__ssttrriinngg(()) ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__ffiinndd__iinntt(()) ddiicctt__ssiizzee │ │ │ │ │ +(()) ddiicctt__aatt__nnooddee(()) ********** │ │ │ │ │ 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 (string_view key) const; │ │ │ │ │ +std::pair ddiicctt__aatt (int i) const; │ │ │ │ │ +int ddiicctt__ssiizzee () const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const; │ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const; │ │ │ │ │ string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key │ │ │ │ │ , string_view default_value = string_view()) const; │ │ │ │ │ -std::pair ddiicctt__aatt (int i) 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 │ │ │ │ │ @@ -12292,19 +12292,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__lleennggtthh(()) ssttrriinngg__ppttrr(()) ssttrriinngg__ooffffsseett(()) ssttrriinngg__vvaalluuee(()) ********** │ │ │ │ │ -std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ +********** ssttrriinngg__ppttrr(()) ssttrriinngg__vvaalluuee(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__ooffffsseett(()) ********** │ │ │ │ │ string_view ssttrriinngg__vvaalluuee () const; │ │ │ │ │ -int ssttrriinngg__lleennggtthh () const; │ │ │ │ │ +std::ptrdiff_t ssttrriinngg__ooffffsseett () const; │ │ │ │ │ char const* ssttrriinngg__ppttrr () 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 (); │ │ │ │ │ @@ -12607,21 +12607,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 (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 (span buffer │ │ │ │ │ , error_code& ec, load_torrent_limits const& cfg = {}); │ │ │ │ │ -add_torrent_params rreeaadd__rreessuummee__ddaattaa (bdecode_node const& rd │ │ │ │ │ - , 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. │ │ │ │ │ @@ -12629,26 +12629,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); │ │ │ │ │ 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(()) ************ │ │ │ │ │ +************ 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 │ │ │ │ │ @@ -12697,18 +12697,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