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.
│ │ │ │
│ │ │ │
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 {}
│ │ │ │ │ @@ -9,15 +9,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 _n_e_w___n_a_m_e_(_)_ _o_l_d___n_a_m_e_(_)
│ │ │ │ │ + o _o_l_d___n_a_m_e_(_)_ _n_e_w___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
│ │ │ │ │ @@ -114,15 +114,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 _n_u_m___s_a_m_p_l_e_s_(_)_ _s_a_m_p_l_e_s_(_)
│ │ │ │ │ o _n_u_m___n_o_d_e_s_(_)
│ │ │ │ │ o _n_o_d_e_s_(_)
│ │ │ │ │ * _b_l_o_c_k___u_p_l_o_a_d_e_d___a_l_e_r_t
│ │ │ │ │ * _a_l_e_r_t_s___d_r_o_p_p_e_d___a_l_e_r_t
│ │ │ │ │ @@ -319,15 +319,15 @@
│ │ │ │ │ char const* nneeww__nnaammee () const;
│ │ │ │ │
│ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category::
│ │ │ │ │ storage;
│ │ │ │ │ file_index_t const index;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** nneeww__nnaammee(()) oolldd__nnaammee(()) **********
│ │ │ │ │ +********** oolldd__nnaammee(()) nneeww__nnaammee(()) **********
│ │ │ │ │ char const* oolldd__nnaammee () const;
│ │ │ │ │ char const* nneeww__nnaammee () const;
│ │ │ │ │ returns the new and previous file name, respectively.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ index
│ │ │ │ │ refers to the index of the file that was renamed,
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -2199,24 +2199,24 @@
│ │ │ │ │ ************ ddhhtt__lliivvee__nnooddeess__aalleerrtt ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p"
│ │ │ │ │ posted in response to a call to session::dht_live_nodes(). It contains the live
│ │ │ │ │ nodes from the DHT routing table of one of the DHT nodes running locally.
│ │ │ │ │ struct dht_live_nodes_alert final : alert
│ │ │ │ │ {
│ │ │ │ │ std::string mmeessssaaggee () const override;
│ │ │ │ │ - std::vector
> nnooddeess () const;
│ │ │ │ │ int nnuumm__nnooddeess () const;
│ │ │ │ │ + std::vector> nnooddeess () const;
│ │ │ │ │
│ │ │ │ │ static constexpr alert_category_t ssttaattiicc__ccaatteeggoorryy = alert_category::dht;
│ │ │ │ │ sha1_hash node_id;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** nnooddeess(()) nnuumm__nnooddeess(()) **********
│ │ │ │ │ -std::vector> nnooddeess () const;
│ │ │ │ │ +********** nnuumm__nnooddeess(()) nnooddeess(()) **********
│ │ │ │ │ int nnuumm__nnooddeess () const;
│ │ │ │ │ +std::vector> nnooddeess () const;
│ │ │ │ │ the number of nodes in the routing table and the actual nodes.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ node_id
│ │ │ │ │ the local DHT node's node-ID this routing table belongs to
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ sseessssiioonn__ssttaattss__hheeaaddeerr__aalleerrtt ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_l_e_r_t___t_y_p_e_s_._h_p_p"
│ │ │ │ │ @@ -2305,17 +2305,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
│ │ │ │ │ @@ -2580,16 +2580,16 @@
│ │ │ │ │ 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"
│ │ │ │ │ char const* ooppeerraattiioonn__nnaammee (operation_t op);
│ │ │ │ │ maps an operation id (from _p_e_e_r___e_r_r_o_r___a_l_e_r_t and _p_e_e_r___d_i_s_c_o_n_n_e_c_t_e_d___a_l_e_r_t) to its
│ │ │ │ │ name. See _o_p_e_r_a_t_i_o_n___t for the constants
│ │ │ │ │ [_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]
│ │ │ │ │ ************ eennuumm ooppeerraattiioonn__tt ************
│ │ │ │ │ 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
│ │ │ │ @@ -36,17 +36,17 @@
│ │ │ │ bdecode_node()
│ │ │ │ operator=() bdecode_node()
│ │ │ │ type()
│ │ │ │ bool()
│ │ │ │ non_owning()
│ │ │ │ data_section() data_offset()
│ │ │ │ list_int_value_at() list_size() list_at() list_string_value_at()
│ │ │ │ -dict_at() dict_find_int_value() dict_find_string_value() dict_find_list() dict_size() dict_find() dict_find_string() dict_find_dict() dict_at_node() dict_find_int()
│ │ │ │ +dict_find_string() dict_at() dict_find_dict() dict_find_int() dict_find() dict_find_int_value() dict_find_list() dict_find_string_value() dict_at_node() dict_size()
│ │ │ │ int_value()
│ │ │ │ -string_ptr() string_length() string_offset() string_value()
│ │ │ │ +string_ptr() string_value() string_length() string_offset()
│ │ │ │ clear()
│ │ │ │ swap()
│ │ │ │ reserve()
│ │ │ │ switch_underlying_buffer()
│ │ │ │ has_soft_error()
│ │ │ │ enum type_t
│ │ │ │
│ │ │ │ @@ -57,50 +57,50 @@
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
bdecode_node
│ │ │ │
Declared in "libtorrent/bdecode.hpp"
│ │ │ │
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
│ │ │ │ non_owning() member function.
│ │ │ │ -
There are 5 different types of nodes, see type_t.
│ │ │ │ +
There are 5 different types of nodes, see type_t.
│ │ │ │
│ │ │ │ struct bdecode_node
│ │ │ │ {
│ │ │ │ bdecode_node () = default;
│ │ │ │ - bdecode_node (bdecode_node const&);
│ │ │ │ + bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │ bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ - bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ + bdecode_node (bdecode_node const&);
│ │ │ │ type_t type () const noexcept;
│ │ │ │ explicit operator bool () const noexcept;
│ │ │ │ bdecode_node non_owning () const;
│ │ │ │ span<char const> data_section () const noexcept;
│ │ │ │ std::ptrdiff_t data_offset () const noexcept;
│ │ │ │ + std::int64_t list_int_value_at (int i
│ │ │ │ + , std::int64_t default_val = 0) 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
│ │ │ │ + string_view dict_find_string_value (string_view key
│ │ │ │ + , string_view default_value = string_view()) const;
│ │ │ │ + std::int64_t dict_find_int_value (string_view key
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ - int list_size () const;
│ │ │ │ - bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ + bdecode_node dict_find (string_view key) const;
│ │ │ │ + bdecode_node dict_find_list (string_view key) const;
│ │ │ │ std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ - int dict_size () const;
│ │ │ │ + bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ - std::int64_t dict_find_int_value (string_view key
│ │ │ │ - , std::int64_t default_val = 0) const;
│ │ │ │ bdecode_node dict_find_int (string_view key) const;
│ │ │ │ - bdecode_node dict_find_list (string_view key) const;
│ │ │ │ + int dict_size () const;
│ │ │ │ bdecode_node dict_find_string (string_view key) const;
│ │ │ │ - string_view dict_find_string_value (string_view key
│ │ │ │ - , string_view default_value = string_view()) const;
│ │ │ │ - bdecode_node dict_find (string_view key) const;
│ │ │ │ std::int64_t int_value () const;
│ │ │ │ + char const* string_ptr () const;
│ │ │ │ int string_length () const;
│ │ │ │ string_view string_value () 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,35 +121,35 @@
│ │ │ │
│ │ │ │
creates a default constructed node, it will have the type none_t.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
operator=() bdecode_node()
│ │ │ │
│ │ │ │ -bdecode_node (bdecode_node const&);
│ │ │ │ +bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │ bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ -bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ +bdecode_node (bdecode_node const&);
│ │ │ │
│ │ │ │
For owning nodes, the copy will create a copy of the tree, but the
│ │ │ │ underlying buffer remains the same.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
type()
│ │ │ │
│ │ │ │ type_t type () const noexcept;
│ │ │ │
│ │ │ │ -
the type of this node. See type_t.
│ │ │ │ +
the type of this node. See type_t.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
bool()
│ │ │ │
│ │ │ │ explicit operator bool () const noexcept;
│ │ │ │
│ │ │ │ -
returns true if type() != none_t.
│ │ │ │ +
returns true if type() != none_t.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
non_owning()
│ │ │ │
│ │ │ │ bdecode_node non_owning () const;
│ │ │ │
│ │ │ │
return a non-owning reference to this node. This is useful to refer to
│ │ │ │ @@ -171,50 +171,50 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
list_int_value_at() list_size() list_at() list_string_value_at()
│ │ │ │
│ │ │ │ -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;
│ │ │ │ +string_view list_string_value_at (int i
│ │ │ │ + , string_view default_val = string_view()) const;
│ │ │ │ +bdecode_node list_at (int i) const;
│ │ │ │
│ │ │ │
functions with the list_ prefix operate on lists. These functions are
│ │ │ │ only valid if type() == list_t. list_at() returns the item
│ │ │ │ in the list at index i. i may not be greater than or equal to the
│ │ │ │ size of the list. size() returns the size of the list.
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
dict_at() dict_find_int_value() dict_find_string_value() dict_find_list() dict_size() dict_find() dict_find_string() dict_find_dict() dict_at_node() dict_find_int()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
dict_find_string() dict_at() dict_find_dict() dict_find_int() dict_find() dict_find_int_value() dict_find_list() dict_find_string_value() dict_at_node() dict_size()
│ │ │ │
│ │ │ │ -bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ -int dict_size () 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;
│ │ │ │ std::int64_t dict_find_int_value (string_view key
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ -bdecode_node dict_find_int (string_view key) const;
│ │ │ │ +bdecode_node dict_find (string_view key) const;
│ │ │ │ bdecode_node dict_find_list (string_view key) const;
│ │ │ │ +std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ +bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ +std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ +bdecode_node dict_find_int (string_view key) const;
│ │ │ │ +int dict_size () const;
│ │ │ │ bdecode_node dict_find_string (string_view key) const;
│ │ │ │ -string_view dict_find_string_value (string_view key
│ │ │ │ - , string_view default_value = string_view()) const;
│ │ │ │ -bdecode_node dict_find (string_view key) const;
│ │ │ │
│ │ │ │
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.
│ │ │ │ @@ -230,23 +230,23 @@
│ │ │ │
int_value()
│ │ │ │
│ │ │ │ std::int64_t int_value () const;
│ │ │ │
│ │ │ │
this function is only valid if type() == int_t. It returns the
│ │ │ │ value of the integer.
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
string_ptr() string_length() string_offset() string_value()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
string_ptr() string_value() string_length() string_offset()
│ │ │ │
│ │ │ │ +char const* string_ptr () const;
│ │ │ │ int string_length () const;
│ │ │ │ string_view string_value () 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.
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -7,19 +7,19 @@
│ │ │ │ │ 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___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)_ _l_i_s_t___a_t_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)
│ │ │ │ │ - o _d_i_c_t___a_t_(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_)
│ │ │ │ │ - _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___s_i_z_e_(_)_ _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)
│ │ │ │ │ - _d_i_c_t___f_i_n_d___d_i_c_t_(_)_ _d_i_c_t___a_t___n_o_d_e_(_)_ _d_i_c_t___f_i_n_d___i_n_t_(_)
│ │ │ │ │ + o _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___i_n_t_(_)
│ │ │ │ │ + _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___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___a_t___n_o_d_e_(_)_ _d_i_c_t___s_i_z_e_(_)
│ │ │ │ │ o _i_n_t___v_a_l_u_e_(_)
│ │ │ │ │ - o _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___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_(_)
│ │ │ │ │ @@ -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 const&);
│ │ │ │ │ + bbddeeccooddee__nnooddee (bdecode_node&&) noexcept;
│ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default;
│ │ │ │ │ - bbddeeccooddee__nnooddee (bdecode_node&&) noexcept;
│ │ │ │ │ + bbddeeccooddee__nnooddee (bdecode_node const&);
│ │ │ │ │ type_t ttyyppee () const noexcept;
│ │ │ │ │ explicit operator bbooooll () const noexcept;
│ │ │ │ │ bdecode_node nnoonn__oowwnniinngg () const;
│ │ │ │ │ span
ddaattaa__sseeccttiioonn () const noexcept;
│ │ │ │ │ std::ptrdiff_t ddaattaa__ooffffsseett () const noexcept;
│ │ │ │ │ + std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i
│ │ │ │ │ + , std::int64_t default_val = 0) const;
│ │ │ │ │ + int lliisstt__ssiizzee () const;
│ │ │ │ │ string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i
│ │ │ │ │ , string_view default_val = string_view()) const;
│ │ │ │ │ bdecode_node lliisstt__aatt (int i) const;
│ │ │ │ │ - std::int64_t lliisstt__iinntt__vvaalluuee__aatt (int i
│ │ │ │ │ + string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key
│ │ │ │ │ + , string_view default_value = string_view()) const;
│ │ │ │ │ + std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key
│ │ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ │ - int lliisstt__ssiizzee () const;
│ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const;
│ │ │ │ │ + bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const;
│ │ │ │ │ std::pair ddiicctt__aatt (int i) const;
│ │ │ │ │ - int ddiicctt__ssiizzee () const;
│ │ │ │ │ + bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const;
│ │ │ │ │ std::pair ddiicctt__aatt__nnooddee (int i) const;
│ │ │ │ │ - std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key
│ │ │ │ │ - , std::int64_t default_val = 0) const;
│ │ │ │ │ bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const;
│ │ │ │ │ - bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const;
│ │ │ │ │ + int ddiicctt__ssiizzee () const;
│ │ │ │ │ bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │ - string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key
│ │ │ │ │ - , string_view default_value = string_view()) const;
│ │ │ │ │ - bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │ std::int64_t iinntt__vvaalluuee () const;
│ │ │ │ │ + char const* ssttrriinngg__ppttrr () const;
│ │ │ │ │ int ssttrriinngg__lleennggtthh () const;
│ │ │ │ │ string_view ssttrriinngg__vvaalluuee () 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 const&);
│ │ │ │ │ +bbddeeccooddee__nnooddee (bdecode_node&&) noexcept;
│ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │ bdecode_node& ooppeerraattoorr== (bdecode_node&&) & = default;
│ │ │ │ │ -bbddeeccooddee__nnooddee (bdecode_node&&) noexcept;
│ │ │ │ │ +bbddeeccooddee__nnooddee (bdecode_node const&);
│ │ │ │ │ For owning nodes, the copy will create a copy of the tree, but the underlying
│ │ │ │ │ buffer remains the same.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttyyppee(()) **********
│ │ │ │ │ type_t ttyyppee () const noexcept;
│ │ │ │ │ the type of this node. See _t_y_p_e___t.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -113,40 +113,40 @@
│ │ │ │ │ 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__iinntt__vvaalluuee__aatt(()) lliisstt__ssiizzee(()) lliisstt__aatt(()) lliisstt__ssttrriinngg__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;
│ │ │ │ │ +string_view lliisstt__ssttrriinngg__vvaalluuee__aatt (int i
│ │ │ │ │ + , string_view default_val = string_view()) const;
│ │ │ │ │ +bdecode_node lliisstt__aatt (int i) const;
│ │ │ │ │ functions with the list_ prefix operate on lists. These functions are only
│ │ │ │ │ valid if type() == list_t. list_at() returns the item in the list at index i. i
│ │ │ │ │ may not be greater than or equal to the size of the list. size() returns the
│ │ │ │ │ size of the list.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddiicctt__aatt(()) ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) ddiicctt__ffiinndd__lliisstt(())
│ │ │ │ │ -ddiicctt__ssiizzee(()) ddiicctt__ffiinndd(()) ddiicctt__ffiinndd__ssttrriinngg(()) ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__aatt__nnooddee(())
│ │ │ │ │ -ddiicctt__ffiinndd__iinntt(()) **********
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const;
│ │ │ │ │ -std::pair ddiicctt__aatt (int i) const;
│ │ │ │ │ -int ddiicctt__ssiizzee () const;
│ │ │ │ │ -std::pair ddiicctt__aatt__nnooddee (int i) const;
│ │ │ │ │ +********** ddiicctt__ffiinndd__ssttrriinngg(()) ddiicctt__aatt(()) ddiicctt__ffiinndd__ddiicctt(()) ddiicctt__ffiinndd__iinntt(()) ddiicctt__ffiinndd(())
│ │ │ │ │ +ddiicctt__ffiinndd__iinntt__vvaalluuee(()) ddiicctt__ffiinndd__lliisstt(()) ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee(()) ddiicctt__aatt__nnooddee(())
│ │ │ │ │ +ddiicctt__ssiizzee(()) **********
│ │ │ │ │ +string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key
│ │ │ │ │ + , string_view default_value = string_view()) const;
│ │ │ │ │ std::int64_t ddiicctt__ffiinndd__iinntt__vvaalluuee (string_view key
│ │ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const;
│ │ │ │ │ +bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │ bdecode_node ddiicctt__ffiinndd__lliisstt (string_view key) const;
│ │ │ │ │ +std::pair ddiicctt__aatt (int i) const;
│ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__ddiicctt (string_view key) const;
│ │ │ │ │ +std::pair ddiicctt__aatt__nnooddee (int i) const;
│ │ │ │ │ +bdecode_node ddiicctt__ffiinndd__iinntt (string_view key) const;
│ │ │ │ │ +int ddiicctt__ssiizzee () const;
│ │ │ │ │ bdecode_node ddiicctt__ffiinndd__ssttrriinngg (string_view key) const;
│ │ │ │ │ -string_view ddiicctt__ffiinndd__ssttrriinngg__vvaalluuee (string_view key
│ │ │ │ │ - , string_view default_value = string_view()) const;
│ │ │ │ │ -bdecode_node ddiicctt__ffiinndd (string_view key) const;
│ │ │ │ │ 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__ppttrr(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__ooffffsseett(()) ssttrriinngg__vvaalluuee(()) **********
│ │ │ │ │ +********** ssttrriinngg__ppttrr(()) ssttrriinngg__vvaalluuee(()) ssttrriinngg__lleennggtthh(()) ssttrriinngg__ooffffsseett(()) **********
│ │ │ │ │ +char const* ssttrriinngg__ppttrr () const;
│ │ │ │ │ int ssttrriinngg__lleennggtthh () const;
│ │ │ │ │ string_view ssttrriinngg__vvaalluuee () 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(()) **********
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Bencoding.html
│ │ │ │ @@ -34,15 +34,15 @@
│ │ │ │
│ │ │ │ - entry
│ │ │ │
│ │ │ │ @@ -69,44 +69,44 @@
│ │ │ │ The entry class represents one node in a bencoded hierarchy. It works as a
│ │ │ │ variant type, it can be either a list, a dictionary (std::map), an integer
│ │ │ │ or a string.
│ │ │ │
│ │ │ │ class entry
│ │ │ │ {
│ │ │ │ data_type type () const;
│ │ │ │ - entry (list_type);
│ │ │ │ - entry (integer_type);
│ │ │ │ entry (span<char const>);
│ │ │ │ - entry (preformatted_type);
│ │ │ │ entry (dictionary_type);
│ │ │ │ + entry (preformatted_type);
│ │ │ │ + entry (list_type);
│ │ │ │ + entry (integer_type);
│ │ │ │ entry (U v);
│ │ │ │ entry (data_type t);
│ │ │ │ entry (bdecode_node const& n);
│ │ │ │ - entry& operator= (preformatted_type) &;
│ │ │ │ - entry& operator= (list_type) &;
│ │ │ │ entry& operator= (bdecode_node const&) &;
│ │ │ │ - entry& operator= (entry&&) & noexcept;
│ │ │ │ entry& operator= (dictionary_type) &;
│ │ │ │ - entry& operator= (span<char const>) &;
│ │ │ │ - entry& operator= (integer_type) &;
│ │ │ │ + entry& operator= (entry&&) & noexcept;
│ │ │ │ + entry& operator= (preformatted_type) &;
│ │ │ │ entry& operator= (entry const&) &;
│ │ │ │ + entry& operator= (list_type) &;
│ │ │ │ + entry& operator= (integer_type) &;
│ │ │ │ + entry& operator= (span<char const>) &;
│ │ │ │ entry& operator= (U v) &;
│ │ │ │ - string_type const& string () const;
│ │ │ │ - preformatted_type& preformatted ();
│ │ │ │ - integer_type& integer ();
│ │ │ │ integer_type const& integer () const;
│ │ │ │ dictionary_type& dict ();
│ │ │ │ - list_type const& list () const;
│ │ │ │ preformatted_type const& preformatted () const;
│ │ │ │ + integer_type& integer ();
│ │ │ │ + string_type const& string () const;
│ │ │ │ + list_type const& list () const;
│ │ │ │ + string_type& string ();
│ │ │ │ dictionary_type const& dict () const;
│ │ │ │ list_type& list ();
│ │ │ │ - string_type& string ();
│ │ │ │ + preformatted_type& preformatted ();
│ │ │ │ void swap (entry& e);
│ │ │ │ - entry const& operator[] (string_view key) const;
│ │ │ │ entry& operator[] (string_view key);
│ │ │ │ + entry const& operator[] (string_view key) const;
│ │ │ │ entry const* find_key (string_view key) const;
│ │ │ │ entry* find_key (string_view key);
│ │ │ │ std::string to_string (bool single_line = false) const;
│ │ │ │
│ │ │ │ enum data_type
│ │ │ │ {
│ │ │ │ int_t,
│ │ │ │ @@ -124,19 +124,19 @@
│ │ │ │ data_type type () const;
│ │ │ │
│ │ │ │ returns the concrete type of the entry
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
entry()
│ │ │ │
│ │ │ │ -entry (list_type);
│ │ │ │ -entry (integer_type);
│ │ │ │ entry (span<char const>);
│ │ │ │ -entry (preformatted_type);
│ │ │ │ entry (dictionary_type);
│ │ │ │ +entry (preformatted_type);
│ │ │ │ +entry (list_type);
│ │ │ │ +entry (integer_type);
│ │ │ │
│ │ │ │
constructors directly from a specific type.
│ │ │ │ The content of the argument is copied into the
│ │ │ │ newly constructed entry
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
entry()
│ │ │ │ @@ -152,43 +152,43 @@
│ │ │ │
entry (bdecode_node const& n);
│ │ │ │
│ │ │ │
construct from bdecode_node parsed form (see bdecode())
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
operator=()
│ │ │ │
│ │ │ │ -entry& operator= (preformatted_type) &;
│ │ │ │ -entry& operator= (list_type) &;
│ │ │ │ entry& operator= (bdecode_node const&) &;
│ │ │ │ -entry& operator= (entry&&) & noexcept;
│ │ │ │ entry& operator= (dictionary_type) &;
│ │ │ │ -entry& operator= (span<char const>) &;
│ │ │ │ -entry& operator= (integer_type) &;
│ │ │ │ +entry& operator= (entry&&) & noexcept;
│ │ │ │ +entry& operator= (preformatted_type) &;
│ │ │ │ entry& operator= (entry const&) &;
│ │ │ │ +entry& operator= (list_type) &;
│ │ │ │ +entry& operator= (integer_type) &;
│ │ │ │ +entry& operator= (span<char const>) &;
│ │ │ │
│ │ │ │
copies the structure of the right hand side into this
│ │ │ │ entry.
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
operator[]()
│ │ │ │
│ │ │ │ -entry const& operator[] (string_view key) const;
│ │ │ │ entry& operator[] (string_view key);
│ │ │ │ +entry const& operator[] (string_view key) const;
│ │ │ │
│ │ │ │
All of these functions requires the entry to be a dictionary, if it
│ │ │ │ isn't they will throw system_error.
│ │ │ │
The non-const versions of the operator[] will return a reference
│ │ │ │ to either the existing element at the given key or, if there is no
│ │ │ │ element with the given key, a reference to a newly inserted element at
│ │ │ │ that key.
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -5,15 +5,15 @@
│ │ │ │ │ Table of contents
│ │ │ │ │ * _e_n_t_r_y
│ │ │ │ │ o _t_y_p_e_(_)
│ │ │ │ │ o _e_n_t_r_y_(_)
│ │ │ │ │ o _e_n_t_r_y_(_)
│ │ │ │ │ o _e_n_t_r_y_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ - o _l_i_s_t_(_)_ _i_n_t_e_g_e_r_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _s_t_r_i_n_g_(_)_ _d_i_c_t_(_)
│ │ │ │ │ + o _s_t_r_i_n_g_(_)_ _d_i_c_t_(_)_ _l_i_s_t_(_)_ _i_n_t_e_g_e_r_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ o _f_i_n_d___k_e_y_(_)
│ │ │ │ │ o _t_o___s_t_r_i_n_g_(_)
│ │ │ │ │ o _e_n_u_m_ _d_a_t_a___t_y_p_e
│ │ │ │ │ * _o_p_e_r_a_t_o_r_<_<_(_)
│ │ │ │ │ * _b_e_n_c_o_d_e_(_)
│ │ │ │ │ @@ -35,44 +35,44 @@
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_n_t_r_y_._h_p_p"
│ │ │ │ │ The entry class represents one node in a bencoded hierarchy. It works as a
│ │ │ │ │ variant type, it can be either a list, a dictionary (std::map), an integer or a
│ │ │ │ │ string.
│ │ │ │ │ class entry
│ │ │ │ │ {
│ │ │ │ │ data_type ttyyppee () const;
│ │ │ │ │ - eennttrryy (list_type);
│ │ │ │ │ - eennttrryy (integer_type);
│ │ │ │ │ eennttrryy (span
);
│ │ │ │ │ - eennttrryy (preformatted_type);
│ │ │ │ │ eennttrryy (dictionary_type);
│ │ │ │ │ + eennttrryy (preformatted_type);
│ │ │ │ │ + eennttrryy (list_type);
│ │ │ │ │ + eennttrryy (integer_type);
│ │ │ │ │ eennttrryy (U v);
│ │ │ │ │ eennttrryy (data_type t);
│ │ │ │ │ eennttrryy (bdecode_node const& n);
│ │ │ │ │ - entry& ooppeerraattoorr== (preformatted_type) &;
│ │ │ │ │ - entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │ entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │ - entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │ entry& ooppeerraattoorr== (dictionary_type) &;
│ │ │ │ │ - entry& ooppeerraattoorr== (span) &;
│ │ │ │ │ - entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ + entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │ + entry& ooppeerraattoorr== (preformatted_type) &;
│ │ │ │ │ entry& ooppeerraattoorr== (entry const&) &;
│ │ │ │ │ + entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │ + entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ + entry& ooppeerraattoorr== (span) &;
│ │ │ │ │ entry& ooppeerraattoorr== (U v) &;
│ │ │ │ │ - string_type const& ssttrriinngg () const;
│ │ │ │ │ - preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │ - integer_type& iinntteeggeerr ();
│ │ │ │ │ integer_type const& iinntteeggeerr () const;
│ │ │ │ │ dictionary_type& ddiicctt ();
│ │ │ │ │ - list_type const& lliisstt () const;
│ │ │ │ │ preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │ + integer_type& iinntteeggeerr ();
│ │ │ │ │ + string_type const& ssttrriinngg () const;
│ │ │ │ │ + list_type const& lliisstt () const;
│ │ │ │ │ + string_type& ssttrriinngg ();
│ │ │ │ │ dictionary_type const& ddiicctt () const;
│ │ │ │ │ list_type& lliisstt ();
│ │ │ │ │ - string_type& ssttrriinngg ();
│ │ │ │ │ + preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │ void sswwaapp (entry& e);
│ │ │ │ │ - entry const& ooppeerraattoorr[[]] (string_view key) const;
│ │ │ │ │ entry& ooppeerraattoorr[[]] (string_view key);
│ │ │ │ │ + entry const& ooppeerraattoorr[[]] (string_view key) const;
│ │ │ │ │ entry const* ffiinndd__kkeeyy (string_view key) const;
│ │ │ │ │ entry* ffiinndd__kkeeyy (string_view key);
│ │ │ │ │ std::string ttoo__ssttrriinngg (bool single_line = false) const;
│ │ │ │ │
│ │ │ │ │ enum data_type
│ │ │ │ │ {
│ │ │ │ │ int_t,
│ │ │ │ │ @@ -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 (list_type);
│ │ │ │ │ -eennttrryy (integer_type);
│ │ │ │ │ eennttrryy (span);
│ │ │ │ │ -eennttrryy (preformatted_type);
│ │ │ │ │ eennttrryy (dictionary_type);
│ │ │ │ │ +eennttrryy (preformatted_type);
│ │ │ │ │ +eennttrryy (list_type);
│ │ │ │ │ +eennttrryy (integer_type);
│ │ │ │ │ constructors directly from a specific type. The content of the argument is
│ │ │ │ │ copied into the newly constructed _e_n_t_r_y
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eennttrryy(()) **********
│ │ │ │ │ eennttrryy (data_type t);
│ │ │ │ │ construct an empty _e_n_t_r_y of the specified type. see _d_a_t_a___t_y_p_e enum.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eennttrryy(()) **********
│ │ │ │ │ eennttrryy (bdecode_node const& n);
│ │ │ │ │ construct from _b_d_e_c_o_d_e___n_o_d_e parsed form (see _b_d_e_c_o_d_e_(_))
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ooppeerraattoorr==(()) **********
│ │ │ │ │ -entry& ooppeerraattoorr== (preformatted_type) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │ entry& ooppeerraattoorr== (bdecode_node const&) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │ entry& ooppeerraattoorr== (dictionary_type) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (span) &;
│ │ │ │ │ -entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (entry&&) & noexcept;
│ │ │ │ │ +entry& ooppeerraattoorr== (preformatted_type) &;
│ │ │ │ │ entry& ooppeerraattoorr== (entry const&) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (list_type) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (integer_type) &;
│ │ │ │ │ +entry& ooppeerraattoorr== (span) &;
│ │ │ │ │ copies the structure of the right hand side into this _e_n_t_r_y.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** lliisstt(()) iinntteeggeerr(()) pprreeffoorrmmaatttteedd(()) ssttrriinngg(()) ddiicctt(()) **********
│ │ │ │ │ -string_type const& ssttrriinngg () const;
│ │ │ │ │ -preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │ -integer_type& iinntteeggeerr ();
│ │ │ │ │ +********** ssttrriinngg(()) ddiicctt(()) lliisstt(()) iinntteeggeerr(()) pprreeffoorrmmaatttteedd(()) **********
│ │ │ │ │ integer_type const& iinntteeggeerr () const;
│ │ │ │ │ dictionary_type& ddiicctt ();
│ │ │ │ │ -list_type const& lliisstt () const;
│ │ │ │ │ preformatted_type const& pprreeffoorrmmaatttteedd () const;
│ │ │ │ │ +integer_type& iinntteeggeerr ();
│ │ │ │ │ +string_type const& ssttrriinngg () const;
│ │ │ │ │ +list_type const& lliisstt () const;
│ │ │ │ │ +string_type& ssttrriinngg ();
│ │ │ │ │ dictionary_type const& ddiicctt () const;
│ │ │ │ │ list_type& lliisstt ();
│ │ │ │ │ -string_type& ssttrriinngg ();
│ │ │ │ │ +preformatted_type& pprreeffoorrmmaatttteedd ();
│ │ │ │ │ The integer(), string(), list() and dict() functions are accessors that return
│ │ │ │ │ the respective type. If the entry object isn't of the type you request, the
│ │ │ │ │ accessor will throw system_error. You can ask an entry for its type through the
│ │ │ │ │ type() function.
│ │ │ │ │ If you want to create an entry you give it the type you want it to have in its
│ │ │ │ │ constructor, and then use one of the non-const accessors to get a reference
│ │ │ │ │ which you then can assign the value you want it to have.
│ │ │ │ │ @@ -161,16 +161,16 @@
│ │ │ │ │ _t_o_r_r_e_n_t___i_n_f_o exists.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sswwaapp(()) **********
│ │ │ │ │ void sswwaapp (entry& e);
│ │ │ │ │ swaps the content of tthhiiss with e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ooppeerraattoorr[[]](()) **********
│ │ │ │ │ -entry const& ooppeerraattoorr[[]] (string_view key) const;
│ │ │ │ │ entry& ooppeerraattoorr[[]] (string_view key);
│ │ │ │ │ +entry const& ooppeerraattoorr[[]] (string_view key) const;
│ │ │ │ │ All of these functions requires the _e_n_t_r_y to be a dictionary, if it isn't they
│ │ │ │ │ will throw system_error.
│ │ │ │ │ The non-const versions of the operator[] will return a reference to either the
│ │ │ │ │ existing element at the given key or, if there is no element with the given
│ │ │ │ │ key, a reference to a newly inserted element at that key.
│ │ │ │ │ The const version of operator[] will only return a reference to an existing
│ │ │ │ │ element at the given key. If the key is not found, it will throw system_error.
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Core.html
│ │ │ │ @@ -30,45 +30,45 @@
│ │ │ │
│ │ │ │ home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │
info_hash_t
│ │ │ │
Declared in "libtorrent/info_hash.hpp"
│ │ │ │ @@ -78,21 +78,21 @@
│ │ │ │
Note
│ │ │ │
If has_v2() is false then the v1 hash might actually be a truncated
│ │ │ │ v2 hash
│ │ │ │
│ │ │ │ struct info_hash_t
│ │ │ │ {
│ │ │ │ - info_hash_t () noexcept = default;
│ │ │ │ - info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ + info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ + info_hash_t () noexcept = default;
│ │ │ │ bool has_v2 () const;
│ │ │ │ - bool has_v1 () const;
│ │ │ │ bool has (protocol_version v) const;
│ │ │ │ + bool has_v1 () const;
│ │ │ │ sha1_hash get (protocol_version v) const;
│ │ │ │ sha1_hash get_best () const;
│ │ │ │ friend bool operator!= (info_hash_t const& lhs, info_hash_t const& rhs);
│ │ │ │ friend bool operator== (info_hash_t const& lhs, info_hash_t const& rhs) noexcept;
│ │ │ │ template <typename F> void for_each (F f) const;
│ │ │ │ bool operator< (info_hash_t const& o) const;
│ │ │ │ friend std::ostream& operator<< (std::ostream& os, info_hash_t const& ih);
│ │ │ │ @@ -100,33 +100,33 @@
│ │ │ │ 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 (sha256_hash h2) noexcept;
│ │ │ │ +info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ +info_hash_t () noexcept = default;
│ │ │ │
│ │ │ │
The default constructor creates an object that has neither a v1 or v2
│ │ │ │ hash.
│ │ │ │
For backwards compatibility, make it possible to construct directly
│ │ │ │ from a v1 hash. This constructor allows implicit conversion from a
│ │ │ │ v1 hash, but the implicitness is deprecated.
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
has() has_v1() has_v2()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
has() has_v2() has_v1()
│ │ │ │
│ │ │ │ bool has_v2 () const;
│ │ │ │ -bool has_v1 () const;
│ │ │ │ bool has (protocol_version v) const;
│ │ │ │ +bool has_v1 () const;
│ │ │ │
│ │ │ │
returns true if the corresponding info hash is present in this
│ │ │ │ object.
│ │ │ │
[report issue]
│ │ │ │
get()
│ │ │ │
│ │ │ │ @@ -148,50 +148,14 @@
│ │ │ │ template <typename F> void for_each (F f) const;
│ │ │ │
│ │ │ │
calls the function object f for each hash that is available.
│ │ │ │ starting with v1. The signature of F is:
│ │ │ │
│ │ │ │ void(sha1_hash const&, protocol_version);
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
peer_request
│ │ │ │ -
Declared in "libtorrent/peer_request.hpp"
│ │ │ │ -
represents a byte range within a piece. Internally this is is used for
│ │ │ │ -incoming piece requests.
│ │ │ │ -
│ │ │ │ -struct peer_request
│ │ │ │ -{
│ │ │ │ - bool operator== (peer_request const& r) const;
│ │ │ │ -
│ │ │ │ - piece_index_t piece;
│ │ │ │ - int start;
│ │ │ │ - int length;
│ │ │ │ -};
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
operator==()
│ │ │ │ -
│ │ │ │ -bool operator== (peer_request const& r) const;
│ │ │ │ -
│ │ │ │ -
returns true if the right hand side peer_request refers to the same
│ │ │ │ -range as this does.
│ │ │ │ -
[report issue]
│ │ │ │ -- piece
│ │ │ │ -- The index of the piece in which the range starts.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -- start
│ │ │ │ -- The byte offset within that piece where the range starts.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -- length
│ │ │ │ -- The size of the range, in bytes.
│ │ │ │ -
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
│ │ │ │
peer_info
│ │ │ │
Declared in "libtorrent/peer_info.hpp"
│ │ │ │
holds information and statistics about one peer
│ │ │ │ that libtorrent is connected to
│ │ │ │ @@ -679,33 +643,111 @@
│ │ │ │
│ │ │ │
│ │ │ │
piece_block
│ │ │ │
Declared in "libtorrent/piece_block.hpp"
│ │ │ │
│ │ │ │ struct piece_block
│ │ │ │ {
│ │ │ │ - piece_block () = default;
│ │ │ │ piece_block (piece_index_t p_index, int b_index);
│ │ │ │ + piece_block () = default;
│ │ │ │ bool operator< (piece_block const& b) const;
│ │ │ │ bool operator== (piece_block const& b) const;
│ │ │ │ bool operator!= (piece_block const& b) const;
│ │ │ │
│ │ │ │ static const piece_block invalid;
│ │ │ │ piece_index_t piece_index {0};
│ │ │ │ int block_index = 0;
│ │ │ │ };
│ │ │ │
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
peer_request
│ │ │ │ +
Declared in "libtorrent/peer_request.hpp"
│ │ │ │ +
represents a byte range within a piece. Internally this is is used for
│ │ │ │ +incoming piece requests.
│ │ │ │ +
│ │ │ │ +struct peer_request
│ │ │ │ +{
│ │ │ │ + bool operator== (peer_request const& r) const;
│ │ │ │ +
│ │ │ │ + piece_index_t piece;
│ │ │ │ + int start;
│ │ │ │ + int length;
│ │ │ │ +};
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
operator==()
│ │ │ │ +
│ │ │ │ +bool operator== (peer_request const& r) const;
│ │ │ │ +
│ │ │ │ +
returns true if the right hand side peer_request refers to the same
│ │ │ │ +range as this does.
│ │ │ │ +
[report issue]
│ │ │ │ +- piece
│ │ │ │ +- The index of the piece in which the range starts.
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +- start
│ │ │ │ +- The byte offset within that piece where the range starts.
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +- length
│ │ │ │ +- The size of the range, in bytes.
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
load_torrent_buffer() load_torrent_parsed() load_torrent_file()
│ │ │ │ +
Declared in "libtorrent/load_torrent.hpp"
│ │ │ │ +
│ │ │ │ +add_torrent_params load_torrent_file (
│ │ │ │ + std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +add_torrent_params load_torrent_parsed (
│ │ │ │ + bdecode_node const& torrent_file);
│ │ │ │ +add_torrent_params load_torrent_file (
│ │ │ │ + std::string const& filename);
│ │ │ │ +add_torrent_params load_torrent_parsed (
│ │ │ │ + bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ +add_torrent_params load_torrent_buffer (
│ │ │ │ + span<char const> buffer);
│ │ │ │ +add_torrent_params load_torrent_buffer (
│ │ │ │ + span<char const> buffer, load_torrent_limits const& cfg);
│ │ │ │ +
│ │ │ │ +
These functions load the content of a .torrent file into an
│ │ │ │ +add_torrent_params object.
│ │ │ │ +The immutable part of a torrent file (the info-dictionary) is stored in
│ │ │ │ +the ti field in the add_torrent_params object (as a torrent_info
│ │ │ │ +object).
│ │ │ │ +The returned object is suitable to be:
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
truncate_files()
│ │ │ │ +
Declared in "libtorrent/truncate.hpp"
│ │ │ │ +
│ │ │ │ +void truncate_files (file_storage const& fs, std::string const& save_path, storage_error& ec);
│ │ │ │ +
│ │ │ │ +
Truncates files larger than specified in the file_storage, saved under
│ │ │ │ +the specified save_path.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
make_magnet_uri()
│ │ │ │
Declared in "libtorrent/magnet_uri.hpp"
│ │ │ │
│ │ │ │ -std::string make_magnet_uri (add_torrent_params const& atp);
│ │ │ │ std::string make_magnet_uri (torrent_info const& info);
│ │ │ │ std::string make_magnet_uri (torrent_handle const& handle);
│ │ │ │ +std::string make_magnet_uri (add_torrent_params const& atp);
│ │ │ │
│ │ │ │
Generates a magnet URI from the specified torrent.
│ │ │ │
Several fields from the add_torrent_params objects are recorded in the
│ │ │ │ magnet link. In order to not include them, they have to be cleared before
│ │ │ │ calling make_magnet_uri(). These fields are used:
│ │ │ │
│ │ │ │ ti, info_hashes, url_seeds, dht_nodes,
│ │ │ │ @@ -725,134 +767,68 @@
│ │ │ │ an empty string is returned.
│ │ │ │ For more information about magnet links, see magnet links.
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
parse_magnet_uri()
│ │ │ │
Declared in "libtorrent/magnet_uri.hpp"
│ │ │ │
│ │ │ │ -void parse_magnet_uri (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │ add_torrent_params parse_magnet_uri (string_view uri, error_code& ec);
│ │ │ │ add_torrent_params parse_magnet_uri (string_view uri);
│ │ │ │ +void parse_magnet_uri (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │
│ │ │ │
This function parses out information from the magnet link and populates the
│ │ │ │ add_torrent_params object. The overload that does not take an
│ │ │ │ error_code reference will throw a system_error on error
│ │ │ │ The overload taking an add_torrent_params reference will fill in the
│ │ │ │ fields specified in the magnet URI.
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
torrent_peer_equal()
│ │ │ │ -
Declared in "libtorrent/torrent_peer.hpp"
│ │ │ │ -
│ │ │ │ -inline bool torrent_peer_equal (torrent_peer const* lhs, torrent_peer const* rhs);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
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, load_torrent_limits const& cfg);
│ │ │ │ -add_torrent_params load_torrent_buffer (
│ │ │ │ - span<char const> buffer);
│ │ │ │ -add_torrent_params load_torrent_file (
│ │ │ │ - std::string const& filename);
│ │ │ │ -add_torrent_params load_torrent_file (
│ │ │ │ - std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ -add_torrent_params load_torrent_parsed (
│ │ │ │ - bdecode_node const& torrent_file);
│ │ │ │ -add_torrent_params load_torrent_buffer (
│ │ │ │ - span<char const> buffer, load_torrent_limits const& cfg);
│ │ │ │ -
│ │ │ │ -
These functions load the content of a .torrent file into an
│ │ │ │ -add_torrent_params object.
│ │ │ │ -The immutable part of a torrent file (the info-dictionary) is stored in
│ │ │ │ -the ti field in the add_torrent_params object (as a torrent_info
│ │ │ │ -object).
│ │ │ │ -The returned object is suitable to be:
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
truncate_files()
│ │ │ │ -
Declared in "libtorrent/truncate.hpp"
│ │ │ │ -
│ │ │ │ -void truncate_files (file_storage const& fs, std::string const& save_path, storage_error& ec);
│ │ │ │ -
│ │ │ │ -
Truncates files larger than specified in the file_storage, saved under
│ │ │ │ -the specified save_path.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
version()
│ │ │ │
Declared in "libtorrent/version.hpp"
│ │ │ │
│ │ │ │ char const* version ();
│ │ │ │
│ │ │ │
returns the libtorrent version as string form in this format:
│ │ │ │ "<major>.<minor>.<tiny>.<tag>"
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
torrent_peer_equal()
│ │ │ │ +
Declared in "libtorrent/torrent_peer.hpp"
│ │ │ │ +
│ │ │ │ +inline bool torrent_peer_equal (torrent_peer const* lhs, torrent_peer const* rhs);
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
enum protocol_version
│ │ │ │ +
Declared in "libtorrent/info_hash.hpp"
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ | name |
│ │ │ │ value |
│ │ │ │ description |
│ │ │ │
|---|
│ │ │ │
│ │ │ │
│ │ │ │ -| tcp |
│ │ │ │ +
| V1 |
│ │ │ │ 0 |
│ │ │ │ - |
│ │ │ │ +The original BitTorrent version, using SHA-1 hashes |
│ │ │ │
│ │ │ │ -| socks5 |
│ │ │ │ +
| V2 |
│ │ │ │ 1 |
│ │ │ │ - |
│ │ │ │ +Version 2 of the BitTorrent protocol, using SHA-256 hashes |
│ │ │ │
│ │ │ │ -| http |
│ │ │ │ +
| NUM |
│ │ │ │ 2 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| utp |
│ │ │ │ -3 |
│ │ │ │ - |
│ │ │ │ -
│ │ │ │ -| i2p |
│ │ │ │ -4 |
│ │ │ │ - |
│ │ │ │ -
│ │ │ │ -| tcp_ssl |
│ │ │ │ -5 |
│ │ │ │ - |
│ │ │ │ -
│ │ │ │ -| socks5_ssl |
│ │ │ │ -6 |
│ │ │ │ - |
│ │ │ │ -
│ │ │ │ -| http_ssl |
│ │ │ │ -7 |
│ │ │ │ - |
│ │ │ │ -
│ │ │ │ -| utp_ssl |
│ │ │ │ -8 |
│ │ │ │ - |
│ │ │ │ -
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
enum connection_type
│ │ │ │ +
Declared in "libtorrent/peer_connection.hpp"
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ | name |
│ │ │ │ value |
│ │ │ │ description |
│ │ │ │
|---|
│ │ │ │
│ │ │ │
│ │ │ │ -| natpmp |
│ │ │ │ +
| bittorrent |
│ │ │ │ 0 |
│ │ │ │ -natpmp can be NAT-PMP or PCP |
│ │ │ │ + |
│ │ │ │
│ │ │ │ -| upnp |
│ │ │ │ +
| url_seed |
│ │ │ │ 1 |
│ │ │ │ |
│ │ │ │
│ │ │ │ +| http_seed |
│ │ │ │ +2 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
enum socket_type_t
│ │ │ │ +
Declared in "libtorrent/socket_type.hpp"
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ | name |
│ │ │ │ value |
│ │ │ │ description |
│ │ │ │
|---|
│ │ │ │
│ │ │ │
│ │ │ │ -| none |
│ │ │ │ +
| tcp |
│ │ │ │ 0 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| tcp |
│ │ │ │ +
| socks5 |
│ │ │ │ 1 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| udp |
│ │ │ │ +
| http |
│ │ │ │ 2 |
│ │ │ │ |
│ │ │ │
│ │ │ │ +| utp |
│ │ │ │ +3 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │ +| i2p |
│ │ │ │ +4 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │ +| tcp_ssl |
│ │ │ │ +5 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │ +| socks5_ssl |
│ │ │ │ +6 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │ +| http_ssl |
│ │ │ │ +7 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │ +| utp_ssl |
│ │ │ │ +8 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
enum portmap_transport
│ │ │ │ +
Declared in "libtorrent/portmap.hpp"
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ | name |
│ │ │ │ value |
│ │ │ │ description |
│ │ │ │
|---|
│ │ │ │
│ │ │ │
│ │ │ │ -| V1 |
│ │ │ │ +
| natpmp |
│ │ │ │ 0 |
│ │ │ │ -The original BitTorrent version, using SHA-1 hashes |
│ │ │ │ +natpmp can be NAT-PMP or PCP |
│ │ │ │
│ │ │ │ -| V2 |
│ │ │ │ +
| upnp |
│ │ │ │ 1 |
│ │ │ │ -Version 2 of the BitTorrent protocol, using SHA-256 hashes |
│ │ │ │ -
│ │ │ │ -| NUM |
│ │ │ │ -2 |
│ │ │ │ |
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
enum portmap_protocol
│ │ │ │ +
Declared in "libtorrent/portmap.hpp"
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ | name |
│ │ │ │ value |
│ │ │ │ description |
│ │ │ │
|---|
│ │ │ │
│ │ │ │
│ │ │ │ -| bittorrent |
│ │ │ │ +
| none |
│ │ │ │ 0 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| url_seed |
│ │ │ │ +
| tcp |
│ │ │ │ 1 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| http_seed |
│ │ │ │ +
| udp |
│ │ │ │ 2 |
│ │ │ │ |
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │ @@ -1027,14 +1027,41 @@
│ │ │ │
low_priority
│ │ │ │
The lowest priority for files and pieces.
│ │ │ │
│ │ │ │
│ │ │ │ - top_priority
│ │ │ │ - The highest priority for files and pieces.
│ │ │ │
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
pex_flags_t
│ │ │ │ +
Declared in "libtorrent/pex_flags.hpp"
│ │ │ │ +
│ │ │ │ +- pex_encryption
│ │ │ │ +- the peer supports protocol encryption
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +- pex_seed
│ │ │ │ +- the peer is a seed
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +- pex_utp
│ │ │ │ +- the peer supports the uTP, transport protocol over UDP.
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +- pex_holepunch
│ │ │ │ +- the peer supports the holepunch extension If this flag is received from a
│ │ │ │ +peer, it can be used as a rendezvous point in case direct connections to
│ │ │ │ +the peer fail
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +- pex_lt_v2
│ │ │ │ +- protocol v2
│ │ │ │ +this is not a standard flag, it is only used internally
│ │ │ │ +
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
int
│ │ │ │
Declared in "libtorrent/version.hpp"
│ │ │ │
│ │ │ │ - version_major
│ │ │ │ - the major, minor and tiny versions of libtorrent
│ │ │ │ @@ -1179,15 +1206,15 @@
│ │ │ │ stop-when-ready immediately.
│ │ │ │ When the stop-when-ready logic fires, the flag is cleared. Any
│ │ │ │ subsequent transitions between downloading and non-downloading states
│ │ │ │ will not be affected, until this flag is set again.
│ │ │ │ The behavior is more robust when setting this flag as part of adding
│ │ │ │ the torrent. See add_torrent_params.
│ │ │ │ The stop-when-ready flag fixes the inherent race condition of waiting
│ │ │ │ -for the state_changed_alert and then call pause(). The download/seeding
│ │ │ │ +for the state_changed_alert and then call pause(). The download/seeding
│ │ │ │ will most likely start in between posting the alert and receiving the
│ │ │ │ call to pause.
│ │ │ │ A downloading state is one where peers are being connected. Which means
│ │ │ │ just downloading the metadata via the ut_metadata extension counts
│ │ │ │ as a downloading state. In order to stop a torrent once the metadata
│ │ │ │ has been downloaded, instead set all file priorities to dont_download
│ │ │ │
│ │ │ │ @@ -1277,41 +1304,14 @@
│ │ │ │ URL.
│ │ │ │
│ │ │ │
│ │ │ │ - all
│ │ │ │ - all torrent flags combined. Can conveniently be used when creating masks
│ │ │ │ for flags
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
pex_flags_t
│ │ │ │ -
Declared in "libtorrent/pex_flags.hpp"
│ │ │ │ -
│ │ │ │ -- pex_encryption
│ │ │ │ -- the peer supports protocol encryption
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -- pex_seed
│ │ │ │ -- the peer is a seed
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -- pex_utp
│ │ │ │ -- the peer supports the uTP, transport protocol over UDP.
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -- pex_holepunch
│ │ │ │ -- the peer supports the holepunch extension If this flag is received from a
│ │ │ │ -peer, it can be used as a rendezvous point in case direct connections to
│ │ │ │ -the peer fail
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -- pex_lt_v2
│ │ │ │ -- protocol v2
│ │ │ │ -this is not a standard flag, it is only used internally
│ │ │ │ -
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
char const*
│ │ │ │
Declared in "libtorrent/version.hpp"
│ │ │ │
│ │ │ │ - version_str
│ │ │ │ - the libtorrent version in string form
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,84 +1,84 @@
│ │ │ │ │ >
│ │ │ │ │ _[_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
│ │ │ │ │ * _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_e_e_r___r_e_q_u_e_s_t
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ * _p_e_e_r___i_n_f_o
│ │ │ │ │ o _i_2_p___d_e_s_t_i_n_a_t_i_o_n_(_)
│ │ │ │ │ * _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_(_)
│ │ │ │ │ + * _t_r_u_n_c_a_t_e___f_i_l_e_s_(_)
│ │ │ │ │ * _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_(_)
│ │ │ │ │ - * _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_(_)
│ │ │ │ │ - * _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
│ │ │ │ │ + * _t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_)
│ │ │ │ │ + * _e_n_u_m_ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ │ * _e_n_u_m_ _e_v_e_n_t___t
│ │ │ │ │ + * _e_n_u_m_ _c_o_n_n_e_c_t_i_o_n___t_y_p_e
│ │ │ │ │ + * _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │ * _e_n_u_m_ _p_o_r_t_m_a_p___t_r_a_n_s_p_o_r_t
│ │ │ │ │ * _e_n_u_m_ _p_o_r_t_m_a_p___p_r_o_t_o_c_o_l
│ │ │ │ │ - * _e_n_u_m_ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ │ - * _e_n_u_m_ _c_o_n_n_e_c_t_i_o_n___t_y_p_e
│ │ │ │ │ * _d_o_w_n_l_o_a_d___p_r_i_o_r_i_t_y___t
│ │ │ │ │ + * _p_e_x___f_l_a_g_s___t
│ │ │ │ │ * _i_n_t
│ │ │ │ │ * _t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ │ - * _p_e_x___f_l_a_g_s___t
│ │ │ │ │ * _c_h_a_r_ _c_o_n_s_t_*
│ │ │ │ │ * _s_t_d_:_:_u_i_n_t_6_4___t
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ iinnffoo__hhaasshh__tt ************
│ │ │ │ │ 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 (sha256_hash h2) noexcept;
│ │ │ │ │ + iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │ explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ + iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │ bool hhaass__vv22 () const;
│ │ │ │ │ - bool hhaass__vv11 () const;
│ │ │ │ │ bool hhaass (protocol_version v) const;
│ │ │ │ │ + bool hhaass__vv11 () const;
│ │ │ │ │ sha1_hash ggeett (protocol_version v) const;
│ │ │ │ │ sha1_hash ggeett__bbeesstt () const;
│ │ │ │ │ friend bool ooppeerraattoorr!!== (info_hash_t const& lhs, info_hash_t const& rhs);
│ │ │ │ │ friend bool ooppeerraattoorr==== (info_hash_t const& lhs, info_hash_t const& rhs)
│ │ │ │ │ noexcept;
│ │ │ │ │ template void ffoorr__eeaacchh (F f) const;
│ │ │ │ │ bool ooppeerraattoorr<< (info_hash_t const& o) const;
│ │ │ │ │ friend std::ostream& ooppeerraattoorr<<<< (std::ostream& os, info_hash_t const& ih);
│ │ │ │ │
│ │ │ │ │ sha1_hash v1;
│ │ │ │ │ sha256_hash v2;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iinnffoo__hhaasshh__tt(()) **********
│ │ │ │ │ -iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │ -iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │ explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ │ +iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │ explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ +iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │ The default constructor creates an object that has neither a v1 or v2 hash.
│ │ │ │ │ For backwards compatibility, make it possible to construct directly from a v1
│ │ │ │ │ hash. This constructor allows iimmpplliicciitt conversion from a v1 hash, but the
│ │ │ │ │ implicitness is deprecated.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaass(()) hhaass__vv11(()) hhaass__vv22(()) **********
│ │ │ │ │ +********** hhaass(()) hhaass__vv22(()) hhaass__vv11(()) **********
│ │ │ │ │ bool hhaass__vv22 () const;
│ │ │ │ │ -bool hhaass__vv11 () const;
│ │ │ │ │ bool hhaass (protocol_version v) const;
│ │ │ │ │ +bool hhaass__vv11 () const;
│ │ │ │ │ returns true if the corresponding info hash is present in this object.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ggeett(()) **********
│ │ │ │ │ sha1_hash ggeett (protocol_version v) const;
│ │ │ │ │ returns the has for the specified protocol version
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ggeett__bbeesstt(()) **********
│ │ │ │ │ @@ -88,41 +88,14 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffoorr__eeaacchh(()) **********
│ │ │ │ │ template void ffoorr__eeaacchh (F f) const;
│ │ │ │ │ calls the function object f for each hash that is available. starting with v1.
│ │ │ │ │ The signature of F is:
│ │ │ │ │ void(sha1_hash const&, protocol_version);
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ ppeeeerr__rreeqquueesstt ************
│ │ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___r_e_q_u_e_s_t_._h_p_p"
│ │ │ │ │ -represents a byte range within a piece. Internally this is is used for incoming
│ │ │ │ │ -piece requests.
│ │ │ │ │ -struct peer_request
│ │ │ │ │ -{
│ │ │ │ │ - bool ooppeerraattoorr==== (peer_request const& r) const;
│ │ │ │ │ -
│ │ │ │ │ - piece_index_t piece;
│ │ │ │ │ - int start;
│ │ │ │ │ - int length;
│ │ │ │ │ -};
│ │ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr====(()) **********
│ │ │ │ │ -bool ooppeerraattoorr==== (peer_request const& r) const;
│ │ │ │ │ -returns true if the right hand side _p_e_e_r___r_e_q_u_e_s_t refers to the same range as
│ │ │ │ │ -this does.
│ │ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ - piece
│ │ │ │ │ - The index of the piece in which the range starts.
│ │ │ │ │ -[_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]
│ │ │ │ │ ************ ppeeeerr__iinnffoo ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___i_n_f_o_._h_p_p"
│ │ │ │ │ holds information and statistics about one peer that libtorrent is connected to
│ │ │ │ │ struct peer_info
│ │ │ │ │ {
│ │ │ │ │ sha256_hash ii22pp__ddeessttiinnaattiioonn () const;
│ │ │ │ │
│ │ │ │ │ @@ -495,30 +468,86 @@
│ │ │ │ │ and receiving data. The states are defined as independent flags of type
│ │ │ │ │ bandwidth_state_flags_t, in this class.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ppiieeccee__bblloocckk ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_i_e_c_e___b_l_o_c_k_._h_p_p"
│ │ │ │ │ struct piece_block
│ │ │ │ │ {
│ │ │ │ │ - ppiieeccee__bblloocckk () = default;
│ │ │ │ │ ppiieeccee__bblloocckk (piece_index_t p_index, int b_index);
│ │ │ │ │ + ppiieeccee__bblloocckk () = default;
│ │ │ │ │ bool ooppeerraattoorr<< (piece_block const& b) const;
│ │ │ │ │ bool ooppeerraattoorr==== (piece_block const& b) const;
│ │ │ │ │ bool ooppeerraattoorr!!== (piece_block const& b) const;
│ │ │ │ │
│ │ │ │ │ static const piece_block invalid;
│ │ │ │ │ piece_index_t piece_index {0};
│ │ │ │ │ int bblloocckk__iinnddeexx = 0;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ +************ ppeeeerr__rreeqquueesstt ************
│ │ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___r_e_q_u_e_s_t_._h_p_p"
│ │ │ │ │ +represents a byte range within a piece. Internally this is is used for incoming
│ │ │ │ │ +piece requests.
│ │ │ │ │ +struct peer_request
│ │ │ │ │ +{
│ │ │ │ │ + bool ooppeerraattoorr==== (peer_request const& r) const;
│ │ │ │ │ +
│ │ │ │ │ + piece_index_t piece;
│ │ │ │ │ + int start;
│ │ │ │ │ + int length;
│ │ │ │ │ +};
│ │ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ +********** ooppeerraattoorr====(()) **********
│ │ │ │ │ +bool ooppeerraattoorr==== (peer_request const& r) const;
│ │ │ │ │ +returns true if the right hand side _p_e_e_r___r_e_q_u_e_s_t refers to the same range as
│ │ │ │ │ +this does.
│ │ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ + piece
│ │ │ │ │ + The index of the piece in which the range starts.
│ │ │ │ │ +[_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(()) ************
│ │ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_l_o_a_d___t_o_r_r_e_n_t_._h_p_p"
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │ + std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ + bdecode_node const& torrent_file);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │ + std::string const& filename);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ + bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ + span buffer);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ + span buffer, load_torrent_limits const& cfg);
│ │ │ │ │ +These functions load the content of a .torrent file into an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ │ +object. The immutable part of a torrent file (the info-dictionary) is stored in
│ │ │ │ │ +the ti field in the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object (as a _t_o_r_r_e_n_t___i_n_f_o object). The
│ │ │ │ │ +returned object is suitable to be:
│ │ │ │ │ + * added to a _s_e_s_s_i_o_n via _a_d_d___t_o_r_r_e_n_t_(_) or _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ + * saved as a .torrent_file via _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ + * turned into a magnet link via _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ +************ ttrruunnccaattee__ffiilleess(()) ************
│ │ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_r_u_n_c_a_t_e_._h_p_p"
│ │ │ │ │ +void ttrruunnccaattee__ffiilleess (file_storage const& fs, std::string const& save_path,
│ │ │ │ │ +storage_error& ec);
│ │ │ │ │ +Truncates files larger than specified in the _f_i_l_e___s_t_o_r_a_g_e, saved under the
│ │ │ │ │ +specified save_path.
│ │ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ mmaakkee__mmaaggnneett__uurrii(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p"
│ │ │ │ │ -std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp);
│ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info);
│ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle);
│ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp);
│ │ │ │ │ Generates a magnet URI from the specified torrent.
│ │ │ │ │ Several fields from the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s objects are recorded in the magnet
│ │ │ │ │ link. In order to not include them, they have to be cleared before calling
│ │ │ │ │ _m_a_k_e___m_a_g_n_e_t___u_r_i_(_). These fields are used:
│ │ │ │ │ ti, info_hashes, url_seeds, dht_nodes, file_priorities, trackers,
│ │ │ │ │ name, peers.
│ │ │ │ │ Depending on what the use case for the resulting magnet link is, clearing peers
│ │ │ │ │ @@ -533,62 +562,59 @@
│ │ │ │ │ The overload that takes a _t_o_r_r_e_n_t___h_a_n_d_l_e will make blocking calls to query
│ │ │ │ │ information about the torrent. If the torrent handle is invalid, an empty
│ │ │ │ │ string is returned.
│ │ │ │ │ For more information about magnet links, see _m_a_g_n_e_t_ _l_i_n_k_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ppaarrssee__mmaaggnneett__uurrii(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p"
│ │ │ │ │ -void ppaarrssee__mmaaggnneett__uurrii (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │ │ add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri, error_code& ec);
│ │ │ │ │ add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri);
│ │ │ │ │ +void ppaarrssee__mmaaggnneett__uurrii (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │ │ 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]
│ │ │ │ │ +************ vveerrssiioonn(()) ************
│ │ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_v_e_r_s_i_o_n_._h_p_p"
│ │ │ │ │ +char const* vveerrssiioonn ();
│ │ │ │ │ +returns the libtorrent version as string form in this format:
│ │ │ │ │ +"..."
│ │ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ttoorrrreenntt__ppeeeerr__eeqquuaall(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___p_e_e_r_._h_p_p"
│ │ │ │ │ inline bool ttoorrrreenntt__ppeeeerr__eeqquuaall (torrent_peer const* lhs, torrent_peer const*
│ │ │ │ │ rhs);
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ 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, load_torrent_limits const& cfg);
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ - span buffer);
│ │ │ │ │ -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__ppaarrsseedd (
│ │ │ │ │ - bdecode_node const& torrent_file);
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ - span buffer, load_torrent_limits const& cfg);
│ │ │ │ │ -These functions load the content of a .torrent file into an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ │ -object. The immutable part of a torrent file (the info-dictionary) is stored in
│ │ │ │ │ -the ti field in the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object (as a _t_o_r_r_e_n_t___i_n_f_o object). The
│ │ │ │ │ -returned object is suitable to be:
│ │ │ │ │ - * added to a _s_e_s_s_i_o_n via _a_d_d___t_o_r_r_e_n_t_(_) or _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ - * saved as a .torrent_file via _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ - * turned into a magnet link via _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ +************ eennuumm pprroottooccooll__vveerrssiioonn ************
│ │ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_n_f_o___h_a_s_h_._h_p_p"
│ │ │ │ │ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ +|_nn_aa_mm_ee_|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ +|_V_1_ _ _|_0_ _ _ _ _|_T_h_e_ _o_r_i_g_i_n_a_l_ _B_i_t_T_o_r_r_e_n_t_ _v_e_r_s_i_o_n_,_ _u_s_i_n_g_ _S_H_A_-_1_ _h_a_s_h_e_s_ _ _ _ _ _ _ |
│ │ │ │ │ +|_V_2_ _ _|_1_ _ _ _ _|_V_e_r_s_i_o_n_ _2_ _o_f_ _t_h_e_ _B_i_t_T_o_r_r_e_n_t_ _p_r_o_t_o_c_o_l_,_ _u_s_i_n_g_ _S_H_A_-_2_5_6_ _h_a_s_h_e_s|
│ │ │ │ │ +|_N_U_M_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ ttrruunnccaattee__ffiilleess(()) ************
│ │ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_r_u_n_c_a_t_e_._h_p_p"
│ │ │ │ │ -void ttrruunnccaattee__ffiilleess (file_storage const& fs, std::string const& save_path,
│ │ │ │ │ -storage_error& ec);
│ │ │ │ │ -Truncates files larger than specified in the _f_i_l_e___s_t_o_r_a_g_e, saved under the
│ │ │ │ │ -specified save_path.
│ │ │ │ │ +************ eennuumm eevveenntt__tt ************
│ │ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_r_a_c_k_e_r___m_a_n_a_g_e_r_._h_p_p"
│ │ │ │ │ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ +|_nn_aa_mm_ee_ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ │ +|_n_o_n_e_ _ _ _ _ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ +|_c_o_m_p_l_e_t_e_d_|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ +|_s_t_a_r_t_e_d_ _ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ +|_s_t_o_p_p_e_d_ _ _|_3_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ +|_p_a_u_s_e_d_ _ _ _|_4_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ vveerrssiioonn(()) ************
│ │ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_v_e_r_s_i_o_n_._h_p_p"
│ │ │ │ │ -char const* vveerrssiioonn ();
│ │ │ │ │ -returns the libtorrent version as string form in this format:
│ │ │ │ │ -"..."
│ │ │ │ │ +************ eennuumm ccoonnnneeccttiioonn__ttyyppee ************
│ │ │ │ │ +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_p_p"
│ │ │ │ │ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ +|_nn_aa_mm_ee_ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ │ +|_b_i_t_t_o_r_r_e_n_t_|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ +|_u_r_l___s_e_e_d_ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ +|_h_t_t_p___s_e_e_d_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ eennuumm ssoocckkeett__ttyyppee__tt ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_o_c_k_e_t___t_y_p_e_._h_p_p"
│ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ |_nn_aa_mm_ee_ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ │ |_t_c_p_ _ _ _ _ _ _ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_s_o_c_k_s_5_ _ _ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ @@ -596,24 +622,14 @@
│ │ │ │ │ |_u_t_p_ _ _ _ _ _ _ _|_3_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_i_2_p_ _ _ _ _ _ _ _|_4_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_t_c_p___s_s_l_ _ _ _|_5_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_s_o_c_k_s_5___s_s_l_|_6_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_h_t_t_p___s_s_l_ _ _|_7_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_u_t_p___s_s_l_ _ _ _|_8_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ eennuumm eevveenntt__tt ************
│ │ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_r_a_c_k_e_r___m_a_n_a_g_e_r_._h_p_p"
│ │ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ │ -|_n_o_n_e_ _ _ _ _ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -|_c_o_m_p_l_e_t_e_d_|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -|_s_t_a_r_t_e_d_ _ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -|_s_t_o_p_p_e_d_ _ _|_3_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -|_p_a_u_s_e_d_ _ _ _|_4_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ eennuumm ppoorrttmmaapp__ttrraannssppoorrtt ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_o_r_t_m_a_p_._h_p_p"
│ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ |_nn_aa_mm_ee_ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_n_a_t_p_m_p_|_0_ _ _ _ _|_n_a_t_p_m_p_ _c_a_n_ _b_e_ _N_A_T_-_P_M_P_ _o_r_ _P_C_P|
│ │ │ │ │ |_u_p_n_p_ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -621,42 +637,41 @@
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_o_r_t_m_a_p_._h_p_p"
│ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ |_nn_aa_mm_ee_|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ │ |_n_o_n_e_|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_t_c_p_ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_u_d_p_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ eennuumm pprroottooccooll__vveerrssiioonn ************
│ │ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_n_f_o___h_a_s_h_._h_p_p"
│ │ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ -|_nn_aa_mm_ee_|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -|_V_1_ _ _|_0_ _ _ _ _|_T_h_e_ _o_r_i_g_i_n_a_l_ _B_i_t_T_o_r_r_e_n_t_ _v_e_r_s_i_o_n_,_ _u_s_i_n_g_ _S_H_A_-_1_ _h_a_s_h_e_s_ _ _ _ _ _ _ |
│ │ │ │ │ -|_V_2_ _ _|_1_ _ _ _ _|_V_e_r_s_i_o_n_ _2_ _o_f_ _t_h_e_ _B_i_t_T_o_r_r_e_n_t_ _p_r_o_t_o_c_o_l_,_ _u_s_i_n_g_ _S_H_A_-_2_5_6_ _h_a_s_h_e_s|
│ │ │ │ │ -|_N_U_M_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ eennuumm ccoonnnneeccttiioonn__ttyyppee ************
│ │ │ │ │ -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_p_p"
│ │ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ │ -|_b_i_t_t_o_r_r_e_n_t_|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -|_u_r_l___s_e_e_d_ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -|_h_t_t_p___s_e_e_d_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ddoowwnnllooaadd__pprriioorriittyy__tt ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_o_w_n_l_o_a_d___p_r_i_o_r_i_t_y_._h_p_p"
│ │ │ │ │ dont_download
│ │ │ │ │ Don't download the file or piece. Partial pieces may still be downloaded
│ │ │ │ │ when setting file priorities.
│ │ │ │ │ default_priority
│ │ │ │ │ The default priority for files and pieces.
│ │ │ │ │ low_priority
│ │ │ │ │ The lowest priority for files and pieces.
│ │ │ │ │ top_priority
│ │ │ │ │ The highest priority for files and pieces.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ +************ ppeexx__ffllaaggss__tt ************
│ │ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_x___f_l_a_g_s_._h_p_p"
│ │ │ │ │ + pex_encryption
│ │ │ │ │ + the peer supports protocol encryption
│ │ │ │ │ + pex_seed
│ │ │ │ │ + the peer is a seed
│ │ │ │ │ + pex_utp
│ │ │ │ │ + the peer supports the uTP, transport protocol over UDP.
│ │ │ │ │ + pex_holepunch
│ │ │ │ │ + the peer supports the holepunch extension If this flag is received from a
│ │ │ │ │ + peer, it can be used as a rendezvous point in case direct connections to
│ │ │ │ │ + the peer fail
│ │ │ │ │ + pex_lt_v2
│ │ │ │ │ + protocol v2 this is not a standard flag, it is only used internally
│ │ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ iinntt ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_v_e_r_s_i_o_n_._h_p_p"
│ │ │ │ │ version_major
│ │ │ │ │ the major, minor and tiny versions of libtorrent
│ │ │ │ │ version_minor
│ │ │ │ │ the major, minor and tiny versions of libtorrent
│ │ │ │ │ version_tiny
│ │ │ │ │ @@ -834,29 +849,14 @@
│ │ │ │ │ This flag is set automatically when adding a torrent that has at least
│ │ │ │ │ one tracker whose hostname ends with .i2p. It's also set by
│ │ │ │ │ _p_a_r_s_e___m_a_g_n_e_t___u_r_i_(_) if the tracker list contains such URL.
│ │ │ │ │ all
│ │ │ │ │ all torrent flags combined. Can conveniently be used when creating masks
│ │ │ │ │ for flags
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ ppeexx__ffllaaggss__tt ************
│ │ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_x___f_l_a_g_s_._h_p_p"
│ │ │ │ │ - pex_encryption
│ │ │ │ │ - the peer supports protocol encryption
│ │ │ │ │ - pex_seed
│ │ │ │ │ - the peer is a seed
│ │ │ │ │ - pex_utp
│ │ │ │ │ - the peer supports the uTP, transport protocol over UDP.
│ │ │ │ │ - pex_holepunch
│ │ │ │ │ - the peer supports the holepunch extension If this flag is received from a
│ │ │ │ │ - peer, it can be used as a rendezvous point in case direct connections to
│ │ │ │ │ - the peer fail
│ │ │ │ │ - pex_lt_v2
│ │ │ │ │ - protocol v2 this is not a standard flag, it is only used internally
│ │ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ cchhaarr ccoonnsstt** ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_v_e_r_s_i_o_n_._h_p_p"
│ │ │ │ │ version_str
│ │ │ │ │ the libtorrent version in string form
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ssttdd::::uuiinntt6644__tt ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_v_e_r_s_i_o_n_._h_p_p"
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Create_Torrents.html
│ │ │ │ @@ -37,26 +37,26 @@
│ │ │ │ - generate() generate_buf()
│ │ │ │ - files()
│ │ │ │ - set_comment()
│ │ │ │ - set_creator()
│ │ │ │ - set_creation_date()
│ │ │ │ - set_hash()
│ │ │ │ - set_hash2()
│ │ │ │ -- add_url_seed() add_http_seed()
│ │ │ │ +- add_http_seed() add_url_seed()
│ │ │ │ - add_node()
│ │ │ │ - add_tracker()
│ │ │ │ - set_root_cert()
│ │ │ │ -- priv() set_priv()
│ │ │ │ +- set_priv() priv()
│ │ │ │ - num_pieces()
│ │ │ │ - piece_range()
│ │ │ │ - file_range()
│ │ │ │ - file_piece_range()
│ │ │ │ - total_size()
│ │ │ │ - piece_size() piece_length()
│ │ │ │ -- add_collection() add_similar_torrent()
│ │ │ │ +- add_similar_torrent() add_collection()
│ │ │ │
│ │ │ │
│ │ │ │ - add_files()
│ │ │ │ - set_piece_hashes()
│ │ │ │
│ │ │ │
│ │ │ │
This section describes the functions and classes that are used
│ │ │ │ @@ -105,43 +105,43 @@
│ │ │ │
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;
│ │ │ │ + std::vector<char> generate_buf () const;
│ │ │ │ file_storage const& files () const;
│ │ │ │ void set_comment (char const* str);
│ │ │ │ void set_creator (char const* str);
│ │ │ │ void set_creation_date (std::time_t timestamp);
│ │ │ │ void set_hash (piece_index_t index, sha1_hash const& h);
│ │ │ │ void set_hash2 (file_index_t file, piece_index_t::diff_type piece, sha256_hash const& h);
│ │ │ │ - void add_url_seed (string_view url);
│ │ │ │ void add_http_seed (string_view url);
│ │ │ │ + void add_url_seed (string_view url);
│ │ │ │ void add_node (std::pair<std::string, int> node);
│ │ │ │ void add_tracker (string_view url, int tier = 0);
│ │ │ │ void set_root_cert (string_view cert);
│ │ │ │ void set_priv (bool p);
│ │ │ │ bool priv () const;
│ │ │ │ - bool is_v1_only () const;
│ │ │ │ bool is_v2_only () const;
│ │ │ │ + bool is_v1_only () const;
│ │ │ │ int num_pieces () const;
│ │ │ │ piece_index_t end_piece () const;
│ │ │ │ index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │ file_index_t end_file () const;
│ │ │ │ index_range<file_index_t> file_range () const noexcept;
│ │ │ │ index_range<piece_index_t::diff_type> file_piece_range (file_index_t f);
│ │ │ │ std::int64_t total_size () const;
│ │ │ │ - int piece_length () const;
│ │ │ │ int piece_size (piece_index_t i) const;
│ │ │ │ + int piece_length () const;
│ │ │ │ void add_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;
│ │ │ │ @@ -149,17 +149,17 @@
│ │ │ │ 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
│ │ │ │ @@ -178,16 +178,16 @@
│ │ │ │ entire duration of the create_torrent object.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │ +
add_similar_torrent() add_collection()
│ │ │ │
│ │ │ │ void add_collection (string_view c);
│ │ │ │ void add_similar_torrent (sha1_hash ih);
│ │ │ │
│ │ │ │
Add similar torrents (by info-hash) or collections of similar torrents.
│ │ │ │ Similar torrents are expected to share some files with this torrent.
│ │ │ │ Torrents sharing a collection name with this torrent are also expected
│ │ │ │ @@ -485,22 +485,22 @@
│ │ │ │
Declared in "libtorrent/create_torrent.hpp"
│ │ │ │
│ │ │ │ void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ , std::function<void(piece_index_t)> const& f);
│ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p);
│ │ │ │ -void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ - , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ -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);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p, error_code& ec);
│ │ │ │ +void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ , settings_interface const& settings
│ │ │ │ , 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:
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -8,26 +8,26 @@
│ │ │ │ │ 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___u_r_l___s_e_e_d_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ + o _a_d_d___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)
│ │ │ │ │ o _a_d_d___n_o_d_e_(_)
│ │ │ │ │ o _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ o _s_e_t___r_o_o_t___c_e_r_t_(_)
│ │ │ │ │ - o _p_r_i_v_(_)_ _s_e_t___p_r_i_v_(_)
│ │ │ │ │ + o _s_e_t___p_r_i_v_(_)_ _p_r_i_v_(_)
│ │ │ │ │ o _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ o _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ │ o _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ - o _a_d_d___c_o_l_l_e_c_t_i_o_n_(_)_ _a_d_d___s_i_m_i_l_a_r___t_o_r_r_e_n_t_(_)
│ │ │ │ │ + o _a_d_d___s_i_m_i_l_a_r___t_o_r_r_e_n_t_(_)_ _a_d_d___c_o_l_l_e_c_t_i_o_n_(_)
│ │ │ │ │ * _a_d_d___f_i_l_e_s_(_)
│ │ │ │ │ * _s_e_t___p_i_e_c_e___h_a_s_h_e_s_(_)
│ │ │ │ │ This section describes the functions and classes that are used to create
│ │ │ │ │ torrent files. It is a layered API with low level classes and higher level
│ │ │ │ │ convenience functions. A torrent is created in 4 steps:
│ │ │ │ │ 1. first the files that will be part of the torrent are determined.
│ │ │ │ │ 2. the torrent properties are set, such as tracker url, web seeds, DHT nodes
│ │ │ │ │ @@ -66,60 +66,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;
│ │ │ │ │ + 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);
│ │ │ │ │ - void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │ void aadddd__hhttttpp__sseeeedd (string_view url);
│ │ │ │ │ + void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │ void aadddd__nnooddee (std::pair node);
│ │ │ │ │ void aadddd__ttrraacckkeerr (string_view url, int tier = 0);
│ │ │ │ │ void sseett__rroooott__cceerrtt (string_view cert);
│ │ │ │ │ void sseett__pprriivv (bool p);
│ │ │ │ │ bool pprriivv () const;
│ │ │ │ │ - bool iiss__vv11__oonnllyy () const;
│ │ │ │ │ bool iiss__vv22__oonnllyy () const;
│ │ │ │ │ + bool iiss__vv11__oonnllyy () const;
│ │ │ │ │ int nnuumm__ppiieecceess () const;
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │ file_index_t eenndd__ffiillee () const;
│ │ │ │ │ index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t f);
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ - int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t i) const;
│ │ │ │ │ + int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ void aadddd__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
│ │ │ │ │ @@ -131,16 +131,16 @@
│ │ │ │ │ (such as _s_e_t___h_a_s_h_(_)), will have any affect. Instead of using this overload,
│ │ │ │ │ consider using _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_) instead.
│ │ │ │ │ Warning
│ │ │ │ │ The _f_i_l_e___s_t_o_r_a_g_e and _t_o_r_r_e_n_t___i_n_f_o objects must stay alive for the entire
│ │ │ │ │ duration of the _c_r_e_a_t_e___t_o_r_r_e_n_t object.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ggeenneerraattee(()) ggeenneerraattee__bbuuff(()) **********
│ │ │ │ │ -std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │ entry ggeenneerraattee () const;
│ │ │ │ │ +std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │ This function will generate the .torrent file as a bencode tree, or a bencoded
│ │ │ │ │ into a buffer. In order to encode the _e_n_t_r_y into a flat file, use the _b_e_n_c_o_d_e_(_)
│ │ │ │ │ function.
│ │ │ │ │ The function returning an _e_n_t_r_y may be useful to add custom entries to the
│ │ │ │ │ torrent file before bencoding it and saving it to disk.
│ │ │ │ │ Whether the resulting torrent object is v1, v2 or hybrid depends on whether any
│ │ │ │ │ of the v1_only or v2_only flags were set on the constructor. If neither were
│ │ │ │ │ @@ -197,17 +197,17 @@
│ │ │ │ │ the merkle tree formed by the piece's 16 kiB blocks. Note that piece sizes must
│ │ │ │ │ be powers-of-2, so all per-piece merkle trees are complete. A SHA-256 hash of
│ │ │ │ │ all zeros is internally used to indicate a hash that has not been set. Setting
│ │ │ │ │ such hash will not be considered set when calling _g_e_n_e_r_a_t_e_(_). This function
│ │ │ │ │ will throw std::system_error if it is called on an object constructed with the
│ │ │ │ │ v1_only flag.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__uurrll__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ -void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │ +********** aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │ void aadddd__hhttttpp__sseeeedd (string_view url);
│ │ │ │ │ +void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │ This adds a url seed to the torrent. You can have any number of url seeds. For
│ │ │ │ │ a single file torrent, this should be an HTTP url, pointing to a file with
│ │ │ │ │ identical content as the file of the torrent. For a multi-file torrent, it
│ │ │ │ │ should point to a directory containing a directory with the same name as this
│ │ │ │ │ torrent, and all the files of the torrent in it.
│ │ │ │ │ The second function, add_http_seed() adds an HTTP seed instead.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -234,15 +234,15 @@
│ │ │ │ │ makes the torrent an SSSSLL ttoorrrreenntt. An SSL torrent requires that each peer has a
│ │ │ │ │ valid certificate signed by this root certificate. For SSL torrents, all peers
│ │ │ │ │ are connecting over SSL connections. For more information, see the section on
│ │ │ │ │ _s_s_l_ _t_o_r_r_e_n_t_s.
│ │ │ │ │ The string is not the path to the cert, it's the actual content of the
│ │ │ │ │ certificate.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** pprriivv(()) sseett__pprriivv(()) **********
│ │ │ │ │ +********** sseett__pprriivv(()) pprriivv(()) **********
│ │ │ │ │ void sseett__pprriivv (bool p);
│ │ │ │ │ bool pprriivv () const;
│ │ │ │ │ Sets and queries the private flag of the torrent. Torrents with the private
│ │ │ │ │ flag set ask the client to not use any other sources than the tracker for
│ │ │ │ │ peers, and to not use DHT to advertise itself publicly, only the tracker.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnuumm__ppiieecceess(()) **********
│ │ │ │ │ @@ -263,21 +263,21 @@
│ │ │ │ │ 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__lleennggtthh () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t i) const;
│ │ │ │ │ +int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ piece_length() returns the piece size of all pieces but the last one.
│ │ │ │ │ piece_size() returns the size of the specified piece. these functions are just
│ │ │ │ │ forwarding to the associated _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__ccoolllleeccttiioonn(()) aadddd__ssiimmiillaarr__ttoorrrreenntt(()) **********
│ │ │ │ │ +********** aadddd__ssiimmiillaarr__ttoorrrreenntt(()) aadddd__ccoolllleeccttiioonn(()) **********
│ │ │ │ │ void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │ void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih);
│ │ │ │ │ Add similar torrents (by info-hash) or collections of similar torrents. Similar
│ │ │ │ │ torrents are expected to share some files with this torrent. Torrents sharing a
│ │ │ │ │ collection name with this torrent are also expected to share files with this
│ │ │ │ │ torrent. A torrent may have more than one collection and more than one similar
│ │ │ │ │ torrents. For more information, see _B_E_P_ _3_8.
│ │ │ │ │ @@ -352,22 +352,22 @@
│ │ │ │ │ ************ sseett__ppiieeccee__hhaasshheess(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_c_r_e_a_t_e___t_o_r_r_e_n_t_._h_p_p"
│ │ │ │ │ void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ │ , std::function const& f, error_code& ec);
│ │ │ │ │ inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ , std::function const& f);
│ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p);
│ │ │ │ │ +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
│ │ │ │ │ , 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
│ │ │ │ │ - , settings_interface const& settings
│ │ │ │ │ - , 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:
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Custom_Storage.html
│ │ │ │ @@ -51,31 +51,31 @@
│ │ │ │ get_status()
│ │ │ │ abort()
│ │ │ │ submit_jobs()
│ │ │ │ settings_updated()
│ │ │ │
│ │ │ │
│ │ │ │ storage_holder
│ │ │ │ -buffer_allocator_interface
│ │ │ │ -disk_buffer_holder
│ │ │ │
│ │ │ │