│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -13,23 +13,23 @@
│ │ │ │ │ ************ ccoouunntteerrss ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_r_f_o_r_m_a_n_c_e___c_o_u_n_t_e_r_s_._h_p_p"
│ │ │ │ │ struct counters
│ │ │ │ │ {
│ │ │ │ │ ccoouunntteerrss () ;
│ │ │ │ │ counters& ooppeerraattoorr== (counters const&) & ;
│ │ │ │ │ ccoouunntteerrss (counters const&) ;
│ │ │ │ │ - std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ std::int64_t ooppeerraattoorr[[]] (int i) const ;
│ │ │ │ │ - void bblleenndd__ssttaattss__ccoouunntteerr (int c, std::int64_t value, int ratio) ;
│ │ │ │ │ + std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ void sseett__vvaalluuee (int c, std::int64_t value) ;
│ │ │ │ │ + void bblleenndd__ssttaattss__ccoouunntteerr (int c, std::int64_t value, int ratio) ;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iinncc__ssttaattss__ccoouunntteerr(()) ooppeerraattoorr[[]](()) **********
│ │ │ │ │ -std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ std::int64_t ooppeerraattoorr[[]] (int i) const ;
│ │ │ │ │ +std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ returns the new value
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ssttaattss__mmeettrriicc ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___s_t_a_t_s_._h_p_p"
│ │ │ │ │ describes one statistics metric from the _s_e_s_s_i_o_n. For more information, see the
│ │ │ │ │ _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section.
│ │ │ │ │ struct stats_metric
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Storage.html
│ │ │ │ @@ -32,36 +32,36 @@
│ │ │ │
│ │ │ │
piece_size()
│ │ │ │
│ │ │ │ @@ -413,18 +413,18 @@
│ │ │ │
│ │ │ │
blocks_per_piece()
│ │ │ │
│ │ │ │ int blocks_per_piece () const;
│ │ │ │
│ │ │ │
returns the number of blocks there are in the typical piece. There
│ │ │ │ may be fewer in the last piece)
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
name() set_name()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
set_name() name()
│ │ │ │
│ │ │ │ std::string const& name () const;
│ │ │ │ void set_name (std::string const& n);
│ │ │ │
│ │ │ │
set and get the name of this torrent. For multi-file torrents, this is also
│ │ │ │ the name of the root directory all the files are stored in.
│ │ │ │
[report issue]
│ │ │ │
canonicalize()
│ │ │ │
│ │ │ │ void canonicalize ();
│ │ │ │
│ │ │ │
arrange files and padding to match the canonical form required
│ │ │ │ by BEP 52
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
root_ptr() file_offset() hash() root() pad_file_at() file_size() mtime() file_name() symlink() file_path()
│ │ │ │ +
[report issue]
│ │ │ │ +
mtime() symlink() file_name() file_size() root_ptr() file_path() file_offset() root() pad_file_at() hash()
│ │ │ │
│ │ │ │ +std::int64_t file_offset (file_index_t index) const;
│ │ │ │ sha256_hash root (file_index_t index) const;
│ │ │ │ +std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ sha1_hash hash (file_index_t index) const;
│ │ │ │ +bool pad_file_at (file_index_t index) const;
│ │ │ │ +std::time_t mtime (file_index_t index) const;
│ │ │ │ std::int64_t file_size (file_index_t index) const;
│ │ │ │ -std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ -std::int64_t file_offset (file_index_t index) const;
│ │ │ │ -char const* root_ptr (file_index_t const index) const;
│ │ │ │ string_view file_name (file_index_t index) const;
│ │ │ │ -bool pad_file_at (file_index_t index) const;
│ │ │ │ std::string symlink (file_index_t index) const;
│ │ │ │ -std::time_t mtime (file_index_t index) const;
│ │ │ │ +char const* root_ptr (file_index_t const index) const;
│ │ │ │
│ │ │ │
These functions are used to query attributes of files at
│ │ │ │ a given index.
│ │ │ │
The hash() is a SHA-1 hash of the file, or 0 if none was
│ │ │ │ provided in the torrent file. This can potentially be used to
│ │ │ │ join a bittorrent network with other file sharing networks.
│ │ │ │
root() returns the SHA-256 merkle tree root of the specified file,
│ │ │ │ @@ -486,37 +486,37 @@
│ │ │ │ index is a pad-file.
│ │ │ │
file_name() returns just the name of the file, whereas
│ │ │ │ file_path() returns the path (inside the torrent file) with
│ │ │ │ the filename appended.
│ │ │ │
file_offset() returns the byte offset within the torrent file
│ │ │ │ where this file starts. It can be used to map the file to a piece
│ │ │ │ index (given the piece size).
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
file_piece_range() file_num_pieces() file_num_blocks()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
file_num_pieces() file_piece_range() file_num_blocks()
│ │ │ │
│ │ │ │ -int file_num_blocks (file_index_t index) const;
│ │ │ │ -index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │ int file_num_pieces (file_index_t index) const;
│ │ │ │ +index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │ +int file_num_blocks (file_index_t index) const;
│ │ │ │
│ │ │ │
Returns the number of pieces or blocks the file at index spans,
│ │ │ │ under the assumption that the file is aligned to the start of a piece.
│ │ │ │ This is only meaningful for v2 torrents, where files are guaranteed
│ │ │ │ such alignment.
│ │ │ │ These numbers are used to size and navigate the merkle hash tree for
│ │ │ │ each file.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
file_first_piece_node() file_first_block_node()
│ │ │ │
│ │ │ │ -int file_first_block_node (file_index_t index) const;
│ │ │ │ int file_first_piece_node (file_index_t index) const;
│ │ │ │ +int file_first_block_node (file_index_t index) const;
│ │ │ │
│ │ │ │
index of first piece node in the merkle tree
│ │ │ │
[report issue]
│ │ │ │
file_path_hash()
│ │ │ │
│ │ │ │ std::uint32_t file_path_hash (file_index_t index, std::string const& save_path) const;
│ │ │ │ @@ -552,16 +552,16 @@
│ │ │ │ have an absolute path, i.e. is not anchored in the save path of the
│ │ │ │ torrent.
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
file_index_at_offset() file_index_at_piece()
│ │ │ │
│ │ │ │ -file_index_t file_index_at_piece (piece_index_t piece) const;
│ │ │ │ file_index_t file_index_at_offset (std::int64_t offset) const;
│ │ │ │ +file_index_t file_index_at_piece (piece_index_t piece) const;
│ │ │ │
│ │ │ │
returns the index of the file at the given offset in the torrent
│ │ │ │
[report issue]
│ │ │ │
file_index_for_root()
│ │ │ │
│ │ │ │ file_index_t file_index_for_root (sha256_hash const& root_hash) const;
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,37 +3,37 @@
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _f_i_l_e___s_l_i_c_e
│ │ │ │ │ * _f_i_l_e___s_t_o_r_a_g_e
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ o _r_e_s_e_r_v_e_(_)
│ │ │ │ │ - o _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)_ _a_d_d___f_i_l_e_(_)
│ │ │ │ │ + o _a_d_d___f_i_l_e_(_)_ _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │ o _m_a_p___f_i_l_e_(_)
│ │ │ │ │ o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │ o _e_n_d___f_i_l_e_(_)
│ │ │ │ │ o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ - o _n_u_m___p_i_e_c_e_s_(_)_ _s_e_t___n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ + o _s_e_t___n_u_m___p_i_e_c_e_s_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ o _e_n_d___p_i_e_c_e_(_)
│ │ │ │ │ o _l_a_s_t___p_i_e_c_e_(_)
│ │ │ │ │ o _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ - o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ + o _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_2_(_)
│ │ │ │ │ o _b_l_o_c_k_s___i_n___p_i_e_c_e_2_(_)
│ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │ - o _n_a_m_e_(_)_ _s_e_t___n_a_m_e_(_)
│ │ │ │ │ + o _s_e_t___n_a_m_e_(_)_ _n_a_m_e_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _c_a_n_o_n_i_c_a_l_i_z_e_(_)
│ │ │ │ │ - o _r_o_o_t___p_t_r_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _h_a_s_h_(_)_ _r_o_o_t_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _f_i_l_e___s_i_z_e_(_)
│ │ │ │ │ - _m_t_i_m_e_(_)_ _f_i_l_e___n_a_m_e_(_)_ _s_y_m_l_i_n_k_(_)_ _f_i_l_e___p_a_t_h_(_)
│ │ │ │ │ - o _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)_ _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)
│ │ │ │ │ + o _m_t_i_m_e_(_)_ _s_y_m_l_i_n_k_(_)_ _f_i_l_e___n_a_m_e_(_)_ _f_i_l_e___s_i_z_e_(_)_ _r_o_o_t___p_t_r_(_)_ _f_i_l_e___p_a_t_h_(_)
│ │ │ │ │ + _f_i_l_e___o_f_f_s_e_t_(_)_ _r_o_o_t_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _h_a_s_h_(_)
│ │ │ │ │ + o _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)
│ │ │ │ │ o _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_)
│ │ │ │ │ o _f_i_l_e___p_a_t_h___h_a_s_h_(_)
│ │ │ │ │ o _a_l_l___p_a_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │ o _f_i_l_e___f_l_a_g_s_(_)
│ │ │ │ │ o _f_i_l_e___a_b_s_o_l_u_t_e___p_a_t_h_(_)
│ │ │ │ │ o _f_i_l_e___i_n_d_e_x___a_t___o_f_f_s_e_t_(_)_ _f_i_l_e___i_n_d_e_x___a_t___p_i_e_c_e_(_)
│ │ │ │ │ o _f_i_l_e___i_n_d_e_x___f_o_r___r_o_o_t_(_)
│ │ │ │ │ @@ -82,75 +82,75 @@
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ void rreesseerrvvee (int num_files);
│ │ │ │ │ void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ + void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ + , file_flags_t file_flags = {}
│ │ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ + , char const* root_hash = nullptr);
│ │ │ │ │ void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t
│ │ │ │ │ file_size
│ │ │ │ │ , file_flags_t file_flags = {}
│ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ - void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ - , file_flags_t file_flags = {}
│ │ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ - , char const* root_hash = nullptr);
│ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t piece, std::int64_t offset
│ │ │ │ │ , std::int64_t size) const;
│ │ │ │ │ peer_request mmaapp__ffiillee (file_index_t file, std::int64_t offset, int size)
│ │ │ │ │ const;
│ │ │ │ │ int nnuumm__ffiilleess () const noexcept;
│ │ │ │ │ file_index_t eenndd__ffiillee () const noexcept;
│ │ │ │ │ index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ int nnuumm__ppiieecceess () const;
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │ - void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ + void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ int ppiieeccee__ssiizzee22 (piece_index_t index) const;
│ │ │ │ │ int bblloocckkss__iinn__ppiieeccee22 (piece_index_t index) const;
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ std::string const& nnaammee () const;
│ │ │ │ │ void sseett__nnaammee (std::string const& n);
│ │ │ │ │ void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │ void ccaannoonniiccaalliizzee ();
│ │ │ │ │ + std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ - sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ - std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ "") const;
│ │ │ │ │ - std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ - char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ - string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ + sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ - std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ - int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ - index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ + std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ + string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ + std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ + char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ - int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ + index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ + int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ + int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const&
│ │ │ │ │ save_path) const;
│ │ │ │ │ void aallll__ppaatthh__hhaasshheess (std::unordered_set& table) const;
│ │ │ │ │ file_flags_t ffiillee__ffllaaggss (file_index_t index) const;
│ │ │ │ │ bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │ - file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │ + file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │ piece_index_t ppiieeccee__iinnddeexx__aatt__ffiillee (file_index_t f) const;
│ │ │ │ │ void ssaanniittiizzee__ssyymmlliinnkkss ();
│ │ │ │ │ bool vv22 () const;
│ │ │ │ │
│ │ │ │ │ static constexpr file_flags_t ffllaagg__ppaadd__ffiillee = 0_bit;
│ │ │ │ │ static constexpr file_flags_t ffllaagg__hhiiddddeenn = 1_bit;
│ │ │ │ │ @@ -166,33 +166,33 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** rreesseerrvvee(()) **********
│ │ │ │ │ void rreesseerrvvee (int num_files);
│ │ │ │ │ allocates space for num_files in the internal file list. This can be used to
│ │ │ │ │ avoid reallocating the internal file list when the number of files to be added
│ │ │ │ │ is known up-front.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__ffiillee__bboorrrrooww(()) aadddd__ffiillee(()) **********
│ │ │ │ │ +********** aadddd__ffiillee(()) aadddd__ffiillee__bboorrrrooww(()) **********
│ │ │ │ │ void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ +void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ + , file_flags_t file_flags = {}
│ │ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ + , char const* root_hash = nullptr);
│ │ │ │ │ void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}
│ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ -void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ - , file_flags_t file_flags = {}
│ │ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ - , char const* root_hash = nullptr);
│ │ │ │ │ Adds a file to the file storage. The add_file_borrow version expects that
│ │ │ │ │ filename is the file name (without a path) of the file that's being added. This
│ │ │ │ │ memory is bboorrrroowweedd, i.e. it is the caller's responsibility to make sure it
│ │ │ │ │ stays valid throughout the lifetime of this _f_i_l_e___s_t_o_r_a_g_e object or any copy of
│ │ │ │ │ it. The same thing applies to filehash, which is an optional pointer to a 20
│ │ │ │ │ byte binary SHA-1 hash of the file.
│ │ │ │ │ if filename is empty, the filename from path is used and not borrowed.
│ │ │ │ │ @@ -261,15 +261,15 @@
│ │ │ │ │ range-for loop. Where the values are the indices of all files in the
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttoottaall__ssiizzee(()) **********
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ returns the total number of bytes all the files in this torrent spans
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** nnuumm__ppiieecceess(()) sseett__nnuumm__ppiieecceess(()) **********
│ │ │ │ │ +********** sseett__nnuumm__ppiieecceess(()) nnuumm__ppiieecceess(()) **********
│ │ │ │ │ void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ int nnuumm__ppiieecceess () const;
│ │ │ │ │ set and get the number of pieces in the torrent
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eenndd__ppiieeccee(()) **********
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ returns the index of the one-past-end piece in the file storage
│ │ │ │ │ @@ -282,17 +282,17 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__rraannggee(()) **********
│ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │ returns an implementation-defined type that can be used as the container in a
│ │ │ │ │ range-for loop. Where the values are the indices of all pieces in the
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__lleennggtthh(()) sseett__ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ -void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ +********** sseett__ppiieeccee__lleennggtthh(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ set and get the size of each piece in this torrent. It must be a power of two
│ │ │ │ │ and at least 16 kiB.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ returns the piece size of index. This will be the same as _p_i_e_c_e___l_e_n_g_t_h_(_),
│ │ │ │ │ except for the last piece, which may be shorter.
│ │ │ │ │ @@ -309,41 +309,41 @@
│ │ │ │ │ returns the number of blocks in the specified piece, for v2 torrents.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bblloocckkss__ppeerr__ppiieeccee(()) **********
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ returns the number of blocks there are in the typical piece. There may be fewer
│ │ │ │ │ in the last piece)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** nnaammee(()) sseett__nnaammee(()) **********
│ │ │ │ │ +********** sseett__nnaammee(()) nnaammee(()) **********
│ │ │ │ │ std::string const& nnaammee () const;
│ │ │ │ │ void sseett__nnaammee (std::string const& n);
│ │ │ │ │ set and get the name of this torrent. For multi-file torrents, this is also the
│ │ │ │ │ name of the root directory all the files are stored in.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sswwaapp(()) **********
│ │ │ │ │ void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │ swap all content of tthhiiss with ttii.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ccaannoonniiccaalliizzee(()) **********
│ │ │ │ │ void ccaannoonniiccaalliizzee ();
│ │ │ │ │ arrange files and padding to match the canonical form required by BEP 52
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** rroooott__ppttrr(()) ffiillee__ooffffsseett(()) hhaasshh(()) rroooott(()) ppaadd__ffiillee__aatt(()) ffiillee__ssiizzee(()) mmttiimmee(())
│ │ │ │ │ -ffiillee__nnaammee(()) ssyymmlliinnkk(()) ffiillee__ppaatthh(()) **********
│ │ │ │ │ +********** mmttiimmee(()) ssyymmlliinnkk(()) ffiillee__nnaammee(()) ffiillee__ssiizzee(()) rroooott__ppttrr(()) ffiillee__ppaatthh(())
│ │ │ │ │ +ffiillee__ooffffsseett(()) rroooott(()) ppaadd__ffiillee__aatt(()) hhaasshh(()) **********
│ │ │ │ │ +std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ -sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ -std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ const;
│ │ │ │ │ -std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ -string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ -std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ +std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ +string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ These functions are used to query attributes of files at a given index.
│ │ │ │ │ The hash() is a SHA-1 hash of the file, or 0 if none was provided in the
│ │ │ │ │ torrent file. This can potentially be used to join a bittorrent network with
│ │ │ │ │ other file sharing networks.
│ │ │ │ │ root() returns the SHA-256 merkle tree root of the specified file, in case this
│ │ │ │ │ is a v2 torrent. Otherwise returns zeros. root_ptr() returns a pointer to the
│ │ │ │ │ SHA-256 merkle tree root hash for the specified file. The pointer points into
│ │ │ │ │ @@ -356,26 +356,26 @@
│ │ │ │ │ file_size() returns the size of a file.
│ │ │ │ │ pad_file_at() returns true if the file at the given index is a pad-file.
│ │ │ │ │ file_name() returns jjuusstt the name of the file, whereas file_path() returns the
│ │ │ │ │ path (inside the torrent file) with the filename appended.
│ │ │ │ │ file_offset() returns the byte offset within the torrent file where this file
│ │ │ │ │ starts. It can be used to map the file to a piece index (given the piece size).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__ppiieeccee__rraannggee(()) ffiillee__nnuumm__ppiieecceess(()) ffiillee__nnuumm__bblloocckkss(()) **********
│ │ │ │ │ -int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ -index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ +********** ffiillee__nnuumm__ppiieecceess(()) ffiillee__ppiieeccee__rraannggee(()) ffiillee__nnuumm__bblloocckkss(()) **********
│ │ │ │ │ int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ +index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ +int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ Returns the number of pieces or blocks the file atindexspans, under the
│ │ │ │ │ assumption that the file is aligned to the start of a piece. This is only
│ │ │ │ │ meaningful for v2 torrents, where files are guaranteed such alignment. These
│ │ │ │ │ numbers are used to size and navigate the merkle hash tree for each file.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) ffiillee__ffiirrsstt__bblloocckk__nnooddee(()) **********
│ │ │ │ │ -int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ +int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ index of first piece node in the merkle tree
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__ppaatthh__hhaasshh(()) **********
│ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const& save_path)
│ │ │ │ │ const;
│ │ │ │ │ returns the crc32 hash of file_path(index)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -393,16 +393,16 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__aabbssoolluuttee__ppaatthh(()) **********
│ │ │ │ │ bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │ returns true if the file at the specified index has been renamed to have an
│ │ │ │ │ absolute path, i.e. is not anchored in the save path of the torrent.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__iinnddeexx__aatt__ooffffsseett(()) ffiillee__iinnddeexx__aatt__ppiieeccee(()) **********
│ │ │ │ │ -file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │ +file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ returns the index of the file at the given offset in the torrent
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__iinnddeexx__ffoorr__rroooott(()) **********
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │ finds the file with the given root hash and returns its index if there is no
│ │ │ │ │ file with the root hash, file_index_t{-1} is returned
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Handle.html
│ │ │ │ @@ -29,62 +29,62 @@
│ │ │ │
│ │ │ │
│ │ │ │ home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │ struct block_info
│ │ │ │ {
│ │ │ │ - void set_peer (tcp::endpoint const& ep);
│ │ │ │ tcp::endpoint peer () const;
│ │ │ │ + void set_peer (tcp::endpoint const& ep);
│ │ │ │
│ │ │ │ enum block_state_t
│ │ │ │ {
│ │ │ │ none,
│ │ │ │ requested,
│ │ │ │ writing,
│ │ │ │ finished,
│ │ │ │ @@ -111,20 +111,20 @@
│ │ │ │
│ │ │ │ unsigned bytes_progress:15;
│ │ │ │ unsigned block_size:15;
│ │ │ │ unsigned state:2;
│ │ │ │ unsigned num_peers:14;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
set_peer() peer()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
peer() set_peer()
│ │ │ │
│ │ │ │ -void set_peer (tcp::endpoint const& ep);
│ │ │ │ tcp::endpoint peer () const;
│ │ │ │ +void set_peer (tcp::endpoint const& ep);
│ │ │ │
│ │ │ │
The peer is the ip address of the peer this block was downloaded from.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
enum block_state_t
│ │ │ │
Declared in "libtorrent/torrent_handle.hpp"
│ │ │ │
│ │ │ │ @@ -267,106 +267,106 @@
│ │ │ │ {
│ │ │ │ friend std::size_t hash_value (torrent_handle const& th);
│ │ │ │ torrent_handle () noexcept = default;
│ │ │ │ void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │ void read_piece (piece_index_t piece) const;
│ │ │ │ bool have_piece (piece_index_t piece) const;
│ │ │ │ - void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ void post_peer_info () const;
│ │ │ │ - void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ + void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ - std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ - void post_download_queue () const;
│ │ │ │ + void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ - void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ + void post_download_queue () const;
│ │ │ │ + std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ + void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ void clear_piece_deadlines () const;
│ │ │ │ + void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ - void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ std::vector<open_file_state> file_status () const;
│ │ │ │ void clear_error () const;
│ │ │ │ + void add_tracker (announce_entry const&) const;
│ │ │ │ void post_trackers () const;
│ │ │ │ - void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ std::vector<announce_entry> trackers () const;
│ │ │ │ - void add_tracker (announce_entry const&) const;
│ │ │ │ + void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ + void remove_url_seed (std::string const& url) const;
│ │ │ │ void add_url_seed (std::string const& url) const;
│ │ │ │ std::set<std::string> url_seeds () const;
│ │ │ │ - void remove_url_seed (std::string const& url) const;
│ │ │ │ void remove_http_seed (std::string const& url) const;
│ │ │ │ std::set<std::string> http_seeds () const;
│ │ │ │ void add_http_seed (std::string const& url) const;
│ │ │ │ void add_extension (
│ │ │ │ std::function<std::shared_ptr<torrent_plugin>(torrent_handle const&, client_data_t)> const& ext
│ │ │ │ , client_data_t userdata = client_data_t{});
│ │ │ │ bool set_metadata (span<char const> metadata) const;
│ │ │ │ bool is_valid () const;
│ │ │ │ - void resume () const;
│ │ │ │ void pause (pause_flags_t flags = {}) const;
│ │ │ │ + void resume () const;
│ │ │ │ + void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ torrent_flags_t flags () const;
│ │ │ │ void set_flags (torrent_flags_t flags) const;
│ │ │ │ void unset_flags (torrent_flags_t flags) const;
│ │ │ │ - void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ void flush_cache () const;
│ │ │ │ void force_recheck () const;
│ │ │ │ void save_resume_data (resume_data_flags_t flags = {}) const;
│ │ │ │ - bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ bool need_save_resume_data () const;
│ │ │ │ - queue_position_t queue_position () const;
│ │ │ │ + bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ void queue_position_top () const;
│ │ │ │ - void queue_position_down () const;
│ │ │ │ void queue_position_bottom () const;
│ │ │ │ + void queue_position_down () const;
│ │ │ │ + queue_position_t queue_position () const;
│ │ │ │ void queue_position_up () const;
│ │ │ │ void queue_position_set (queue_position_t p) const;
│ │ │ │ + void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ + , std::string const& private_key
│ │ │ │ + , std::string const& dh_params);
│ │ │ │ void set_ssl_certificate (std::string const& certificate
│ │ │ │ , std::string const& private_key
│ │ │ │ , std::string const& dh_params
│ │ │ │ , std::string const& passphrase = "");
│ │ │ │ - void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ - , std::string const& private_key
│ │ │ │ - , std::string const& dh_params);
│ │ │ │ - std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │ + std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ std::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │ - void piece_availability (std::vector<int>& avail) const;
│ │ │ │ void post_piece_availability () const;
│ │ │ │ - void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ + void piece_availability (std::vector<int>& avail) const;
│ │ │ │ + void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ + void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ - void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ - download_priority_t file_priority (file_index_t index) const;
│ │ │ │ - void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │ + void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ + download_priority_t file_priority (file_index_t index) const;
│ │ │ │ std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ void force_lsd_announce () const;
│ │ │ │ - void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ void force_dht_announce () const;
│ │ │ │ + void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ void scrape_tracker (int idx = -1) const;
│ │ │ │ - int download_limit () const;
│ │ │ │ void set_upload_limit (int limit) const;
│ │ │ │ int upload_limit () const;
│ │ │ │ void set_download_limit (int limit) const;
│ │ │ │ + int download_limit () const;
│ │ │ │ void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │ , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │ void clear_peers ();
│ │ │ │ void set_max_uploads (int max_uploads) const;
│ │ │ │ int max_uploads () const;
│ │ │ │ - int max_connections () const;
│ │ │ │ void set_max_connections (int max_connections) const;
│ │ │ │ + int max_connections () const;
│ │ │ │ void move_storage (std::string const& save_path
│ │ │ │ , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │ ) const;
│ │ │ │ void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │ info_hash_t info_hashes () const;
│ │ │ │ sha1_hash info_hash () const;
│ │ │ │ bool operator== (const torrent_handle& h) const;
│ │ │ │ - bool operator!= (const torrent_handle& h) const;
│ │ │ │ bool operator< (const torrent_handle& h) const;
│ │ │ │ + bool operator!= (const torrent_handle& h) const;
│ │ │ │ std::uint32_t id () const;
│ │ │ │ std::shared_ptr<torrent> native_handle () const;
│ │ │ │ client_data_t userdata () const;
│ │ │ │ bool in_session () const;
│ │ │ │
│ │ │ │ static constexpr add_piece_flags_t overwrite_existing = 0_bit;
│ │ │ │ static constexpr status_flags_t query_distributed_copies = 0_bit;
│ │ │ │ @@ -449,34 +449,34 @@
│ │ │ │ Returns true if this piece has been completely downloaded and written
│ │ │ │ to disk, and false otherwise.
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
post_peer_info() get_peer_info()
│ │ │ │
│ │ │ │ -void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ void post_peer_info () const;
│ │ │ │ +void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │
│ │ │ │
Query information about connected peers for this torrent. If the
│ │ │ │ torrent_handle is invalid, it will throw a system_error exception.
│ │ │ │
post_peer_info() is asynchronous and will trigger the posting of
│ │ │ │ a peer_info_alert. The alert contain a list of peer_info objects, one
│ │ │ │ for each connected peer.
│ │ │ │
get_peer_info() is synchronous and takes a reference to a vector
│ │ │ │ that will be cleared and filled with one entry for each peer
│ │ │ │ connected to this torrent, given the handle is valid. Each entry in
│ │ │ │ the vector contains information about that particular peer. See
│ │ │ │ peer_info.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
status() post_status()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
post_status() status()
│ │ │ │
│ │ │ │ -void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │
│ │ │ │
status() will return a structure with information about the status
│ │ │ │ of this torrent. If the torrent_handle is invalid, it will throw
│ │ │ │ system_error exception. See torrent_status. The flags
│ │ │ │ argument filters what information is returned in the torrent_status.
│ │ │ │ Some information in there is relatively expensive to calculate, and if
│ │ │ │ you're not interested in it (and see performance issues), you can
│ │ │ │ @@ -486,37 +486,37 @@
│ │ │ │ instead call post_status(). It will trigger posting of a
│ │ │ │ state_update_alert with a single torrent_status object for this
│ │ │ │ torrent.
│ │ │ │
In order to get regular updates for torrents whose status changes,
│ │ │ │ consider calling session::post_torrent_updates()`` instead.
│ │ │ │
By default everything is included. The flags you can use to decide
│ │ │ │ what to include are defined in this class.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
post_download_queue() get_download_queue()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
get_download_queue() post_download_queue()
│ │ │ │
│ │ │ │ -std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ -void post_download_queue () const;
│ │ │ │ void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ +void post_download_queue () const;
│ │ │ │ +std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │
│ │ │ │
post_download_queue() triggers a download_queue_alert to be
│ │ │ │ posted.
│ │ │ │ get_download_queue() is a synchronous call and returns a vector
│ │ │ │ with information about pieces that are partially downloaded or not
│ │ │ │ downloaded but partially requested. See partial_piece_info for the
│ │ │ │ fields in the returned vector.
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
set_piece_deadline() reset_piece_deadline() clear_piece_deadlines()
│ │ │ │ +
[report issue]
│ │ │ │ +
clear_piece_deadlines() reset_piece_deadline() set_piece_deadline()
│ │ │ │
│ │ │ │ -void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ +void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ void clear_piece_deadlines () const;
│ │ │ │
│ │ │ │
This function sets or resets the deadline associated with a specific
│ │ │ │ piece index (index). libtorrent will attempt to download this
│ │ │ │ entire piece before the deadline expires. This is not necessarily
│ │ │ │ possible, but pieces with a more recent deadline will always be
│ │ │ │ prioritized over pieces with a deadline further ahead in time. The
│ │ │ │ @@ -533,17 +533,17 @@
│ │ │ │
clear_piece_deadlines() removes deadlines on all pieces in
│ │ │ │ the torrent. As if reset_piece_deadline() was called on all pieces.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
post_file_progress() file_progress()
│ │ │ │
│ │ │ │ +void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ -void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │
│ │ │ │
This function fills in the supplied vector, or returns a vector, with
│ │ │ │ the number of bytes downloaded of each file in this torrent. The
│ │ │ │ progress values are ordered the same as the files in the
│ │ │ │ torrent_info.
│ │ │ │
This operation is not very cheap. Its complexity is O(n + mj).
│ │ │ │ Where n is the number of files, m is the number of currently
│ │ │ │ @@ -572,25 +572,25 @@
│ │ │ │
│ │ │ │
clear_error()
│ │ │ │
│ │ │ │ void clear_error () const;
│ │ │ │
│ │ │ │
If the torrent is in an error state (i.e. torrent_status::error is
│ │ │ │ non-empty), this will clear the error and start the torrent again.
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
post_trackers() trackers() add_tracker() replace_trackers()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
trackers() replace_trackers() post_trackers() add_tracker()
│ │ │ │
│ │ │ │ +void add_tracker (announce_entry const&) const;
│ │ │ │ void post_trackers () const;
│ │ │ │ -void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ std::vector<announce_entry> trackers () const;
│ │ │ │ -void add_tracker (announce_entry const&) const;
│ │ │ │ +void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │
│ │ │ │
trackers() returns the list of trackers for this torrent. The
│ │ │ │ announce entry contains both a string url which specify the
│ │ │ │ announce url for the tracker as well as an int tier, which is
│ │ │ │ specifies the order in which this tracker is tried. If you want
│ │ │ │ libtorrent to use another list of trackers for this torrent, you can
│ │ │ │ use replace_trackers() which takes a list of the same form as the
│ │ │ │ @@ -608,32 +608,32 @@
│ │ │ │ data will replace the original ones.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_url_seed() remove_url_seed() url_seeds()
│ │ │ │
│ │ │ │ +void remove_url_seed (std::string const& url) const;
│ │ │ │ void add_url_seed (std::string const& url) const;
│ │ │ │ std::set<std::string> url_seeds () const;
│ │ │ │ -void remove_url_seed (std::string const& url) const;
│ │ │ │
│ │ │ │
add_url_seed() adds another url to the torrent's list of url
│ │ │ │ seeds. If the given url already exists in that list, the call has no
│ │ │ │ effect. The torrent will connect to the server and try to download
│ │ │ │ pieces from it, unless it's paused, queued, checking or seeding.
│ │ │ │ remove_url_seed() removes the given url if it exists already.
│ │ │ │ url_seeds() return a set of the url seeds currently in this
│ │ │ │ torrent. Note that URLs that fails may be removed automatically from
│ │ │ │ the list.
│ │ │ │
See http seeding for more information.
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
http_seeds() remove_http_seed() add_http_seed()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
http_seeds() add_http_seed() remove_http_seed()
│ │ │ │
│ │ │ │ void remove_http_seed (std::string const& url) const;
│ │ │ │ std::set<std::string> http_seeds () const;
│ │ │ │ void add_http_seed (std::string const& url) const;
│ │ │ │
│ │ │ │
These functions are identical as the *_url_seed() variants, but
│ │ │ │ they operate on BEP 17 web seeds instead of BEP 19.
│ │ │ │ @@ -679,21 +679,21 @@
│ │ │ │ afterward.
│ │ │ │
Clients should only use is_valid() to determine if the result of
│ │ │ │ session::find_torrent() was successful.
│ │ │ │
Unlike other member functions which return a value, is_valid()
│ │ │ │ completes immediately, without blocking on a result from the
│ │ │ │ network thread. Also unlike other functions, it never throws
│ │ │ │ the system_error exception.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
pause() resume()
│ │ │ │
│ │ │ │ -void resume () const;
│ │ │ │ void pause (pause_flags_t flags = {}) const;
│ │ │ │ +void resume () const;
│ │ │ │
│ │ │ │
pause(), and resume() will disconnect all peers and reconnect
│ │ │ │ all peers respectively. When a torrent is paused, it will however
│ │ │ │ remember all share ratios to all peers and remember all potential (not
│ │ │ │ connected) peers. Torrents may be paused automatically if there is a
│ │ │ │ file error (e.g. disk full) or something similar. See
│ │ │ │ file_error_alert.
│ │ │ │ @@ -710,18 +710,18 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
unset_flags() set_flags() flags()
│ │ │ │
│ │ │ │ +void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ torrent_flags_t flags () const;
│ │ │ │ void set_flags (torrent_flags_t flags) const;
│ │ │ │ void unset_flags (torrent_flags_t flags) const;
│ │ │ │ -void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │
│ │ │ │
sets and gets the torrent state flags. See torrent_flags_t.
│ │ │ │ The set_flags overload that take a mask will affect all
│ │ │ │ flags part of the mask, and set their values to what the
│ │ │ │ flags argument is set to. This allows clearing and
│ │ │ │ setting flags in a single function call.
│ │ │ │ The set_flags overload that just takes flags, sets all
│ │ │ │ @@ -858,16 +858,16 @@
│ │ │ │ report that they don't need to save resume data again, and skipped by
│ │ │ │ the initial loop, and thwart the counter otherwise.
│ │ │ │
│ │ │ │
need_save_resume_data()
│ │ │ │
│ │ │ │ -bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ bool need_save_resume_data () const;
│ │ │ │ +bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │
│ │ │ │
This function returns true if anything that is stored in the resume
│ │ │ │ data has changed since the last time resume data was saved.
│ │ │ │ The overload that takes flags let you ask if specific categories
│ │ │ │ of properties have changed. These flags have the same behavior as in
│ │ │ │ the save_resume_data() call.
│ │ │ │
This is a blocking call. It will wait for a response from
│ │ │ │ @@ -877,26 +877,26 @@
│ │ │ │
│ │ │ │
Note
│ │ │ │
A torrent's resume data is considered saved as soon as the
│ │ │ │ save_resume_data_alert is posted. It is important to make sure this
│ │ │ │ alert is received and handled in order for this function to be
│ │ │ │ meaningful.
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
queue_position_up() queue_position_down() queue_position_top() queue_position_bottom() queue_position()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
queue_position_bottom() queue_position_up() queue_position_top() queue_position() queue_position_down()
│ │ │ │
│ │ │ │ -queue_position_t queue_position () const;
│ │ │ │ void queue_position_top () const;
│ │ │ │ -void queue_position_down () const;
│ │ │ │ void queue_position_bottom () const;
│ │ │ │ +void queue_position_down () const;
│ │ │ │ +queue_position_t queue_position () const;
│ │ │ │ void queue_position_up () const;
│ │ │ │
│ │ │ │
Every torrent that is added is assigned a queue position exactly one
│ │ │ │ greater than the greatest queue position of all existing torrents.
│ │ │ │ Torrents that are being seeded have -1 as their queue position, since
│ │ │ │ they're no longer in line to be downloaded.
│ │ │ │
When a torrent is removed or turns into a seed, all torrents with
│ │ │ │ @@ -921,21 +921,21 @@
│ │ │ │ of all other torrents remain intact but their numerical queue position
│ │ │ │ shifts to make space for this torrent's new position
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
set_ssl_certificate_buffer() set_ssl_certificate()
│ │ │ │
│ │ │ │ +void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ + , std::string const& private_key
│ │ │ │ + , std::string const& dh_params);
│ │ │ │ void set_ssl_certificate (std::string const& certificate
│ │ │ │ , std::string const& private_key
│ │ │ │ , std::string const& dh_params
│ │ │ │ , std::string const& passphrase = "");
│ │ │ │ -void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ - , std::string const& private_key
│ │ │ │ - , std::string const& dh_params);
│ │ │ │
│ │ │ │
For SSL torrents, use this to specify a path to a .pem file to use as
│ │ │ │ this client's certificate. The certificate must be signed by the
│ │ │ │ certificate in the .torrent file to be valid.
│ │ │ │
The set_ssl_certificate_buffer() overload takes the actual certificate,
│ │ │ │ private key and DH params as strings, rather than paths to files.
│ │ │ │
cert is a path to the (signed) certificate in .pem format
│ │ │ │ @@ -951,21 +951,21 @@
│ │ │ │
Note that when a torrent first starts up, and it needs a certificate,
│ │ │ │ it will suspend connecting to any peers until it has one. It's
│ │ │ │ typically desirable to resume the torrent after setting the SSL
│ │ │ │ certificate.
│ │ │ │
If you receive a torrent_need_cert_alert, you need to call this to
│ │ │ │ provide a valid cert. If you don't have a cert you won't be allowed to
│ │ │ │ connect to any peers.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
torrent_file() torrent_file_with_hashes()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
torrent_file_with_hashes() torrent_file()
│ │ │ │
│ │ │ │ -std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │ +std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │
│ │ │ │
torrent_file() returns a pointer to the torrent_info object
│ │ │ │ associated with this torrent. The torrent_info object may be a copy
│ │ │ │ of the internal object. If the torrent doesn't have metadata, the
│ │ │ │ pointer will not be initialized (i.e. a nullptr). The torrent may be
│ │ │ │ in a state without metadata only if it was started without a .torrent
│ │ │ │ file, e.g. by being added by magnet link.
│ │ │ │ @@ -1002,16 +1002,16 @@
│ │ │ │ vector. This is a blocking call that will synchronize with the
│ │ │ │ libtorrent network thread.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
piece_availability() post_piece_availability()
│ │ │ │
│ │ │ │ -void piece_availability (std::vector<int>& avail) const;
│ │ │ │ void post_piece_availability () const;
│ │ │ │ +void piece_availability (std::vector<int>& avail) const;
│ │ │ │
│ │ │ │
The piece availability is the number of peers that we are connected
│ │ │ │ that has advertised having a particular piece. This is the information
│ │ │ │ that libtorrent uses in order to prefer picking rare pieces.
│ │ │ │
post_piece_availability() will trigger a piece_availability_alert
│ │ │ │ to be posted.
│ │ │ │
piece_availability() fills the specified std::vector<int>
│ │ │ │ @@ -1020,19 +1020,19 @@
│ │ │ │ seeding the availability for all pieces is reported as 0.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
piece_priority() prioritize_pieces() get_piece_priorities()
│ │ │ │
│ │ │ │ -void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ +void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ +void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ -void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │
│ │ │ │
These functions are used to set and get the priority of individual
│ │ │ │ pieces. By default all pieces have priority 4. That means that the
│ │ │ │ random rarest first algorithm is effectively active for all pieces.
│ │ │ │ You may however change the priority of individual pieces. There are 8
│ │ │ │ priority levels. 0 means not to download the piece at all. Otherwise,
│ │ │ │ lower priority values means less likely to be picked. Piece priority
│ │ │ │ @@ -1054,23 +1054,23 @@
│ │ │ │ Invalid entries, where the piece index or priority is out of range, are
│ │ │ │ not allowed.
│ │ │ │
get_piece_priorities returns a vector with one element for each piece
│ │ │ │ in the torrent. Each element is the current priority of that piece.
│ │ │ │
It's possible to cancel the effect of file priorities by setting the
│ │ │ │ priorities for the affected pieces. Care has to be taken when mixing
│ │ │ │ usage of file- and piece priorities.
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
prioritize_files() file_priority() get_file_priorities()
│ │ │ │ +
[report issue]
│ │ │ │ +
get_file_priorities() file_priority() prioritize_files()
│ │ │ │
│ │ │ │ -download_priority_t file_priority (file_index_t index) const;
│ │ │ │ -void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │ +void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ +download_priority_t file_priority (file_index_t index) const;
│ │ │ │ std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │
│ │ │ │
index must be in the range [0, number_of_files).
│ │ │ │
file_priority() queries or sets the priority of file index.
│ │ │ │
prioritize_files() takes a vector that has at as many elements as
│ │ │ │ there are files in the torrent. Each entry is the priority of that
│ │ │ │ file. The function sets the priorities of all the pieces in the
│ │ │ │ @@ -1101,16 +1101,16 @@
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
force_dht_announce() force_reannounce() force_lsd_announce()
│ │ │ │
│ │ │ │ void force_lsd_announce () const;
│ │ │ │ -void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ void force_dht_announce () const;
│ │ │ │ +void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │
│ │ │ │
force_reannounce() will force this torrent to do another tracker
│ │ │ │ request, to receive new peers. The seconds argument specifies how
│ │ │ │ many seconds from now to issue the tracker announces.
│ │ │ │
If the tracker's min_interval has not passed since the last
│ │ │ │ announce, the forced announce will be scheduled to happen immediately
│ │ │ │ as the min_interval expires. This is to honor trackers minimum
│ │ │ │ @@ -1134,25 +1134,25 @@
│ │ │ │ idx is >= 0, the tracker with the specified index will scraped.
│ │ │ │
A scrape request queries the tracker for statistics such as total
│ │ │ │ number of incomplete peers, complete peers, number of downloads etc.
│ │ │ │
This request will specifically update the num_complete and
│ │ │ │ num_incomplete fields in the torrent_status struct once it
│ │ │ │ completes. When it completes, it will generate a scrape_reply_alert.
│ │ │ │ If it fails, it will generate a scrape_failed_alert.
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
download_limit() upload_limit() set_upload_limit() set_download_limit()
│ │ │ │ +
[report issue]
│ │ │ │ +
set_upload_limit() download_limit() upload_limit() set_download_limit()
│ │ │ │
│ │ │ │ -int download_limit () const;
│ │ │ │ void set_upload_limit (int limit) const;
│ │ │ │ int upload_limit () const;
│ │ │ │ void set_download_limit (int limit) const;
│ │ │ │ +int download_limit () const;
│ │ │ │
│ │ │ │
set_upload_limit will limit the upload bandwidth used by this
│ │ │ │ particular torrent to the limit you set. It is given as the number of
│ │ │ │ bytes per second the torrent is allowed to upload.
│ │ │ │ set_download_limit works the same way but for download bandwidth
│ │ │ │ instead of upload bandwidth. Note that setting a higher limit on a
│ │ │ │ torrent then the global limit
│ │ │ │ @@ -1184,18 +1184,18 @@
│ │ │ │
clear_peers()
│ │ │ │
│ │ │ │ void clear_peers ();
│ │ │ │
│ │ │ │
This will disconnect all peers and clear the peer list for this
│ │ │ │ torrent. New peers will have to be acquired before resuming, from
│ │ │ │ trackers, DHT or local service discovery, for example.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
max_uploads() set_max_uploads()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
set_max_uploads() max_uploads()
│ │ │ │
│ │ │ │ void set_max_uploads (int max_uploads) const;
│ │ │ │ int max_uploads () const;
│ │ │ │
│ │ │ │
set_max_uploads() sets the maximum number of peers that's unchoked
│ │ │ │ at the same time on this torrent. If you set this to -1, there will be
│ │ │ │ no limit. This defaults to infinite. The primary setting controlling
│ │ │ │ @@ -1203,16 +1203,16 @@
│ │ │ │ settings_pack.
│ │ │ │
max_uploads() returns the current settings.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
max_connections() set_max_connections()
│ │ │ │
│ │ │ │ -int max_connections () const;
│ │ │ │ void set_max_connections (int max_connections) const;
│ │ │ │ +int max_connections () const;
│ │ │ │
│ │ │ │
set_max_connections() sets the maximum number of connection this
│ │ │ │ torrent will open. If all connections are used up, incoming
│ │ │ │ connections may be refused or poor connections may be closed. This
│ │ │ │ must be at least 2. The default is unlimited number of connections. If
│ │ │ │ -1 is given to the function, it means unlimited. There is also a
│ │ │ │ global limit of the number of connections, set by
│ │ │ │ @@ -1289,23 +1289,23 @@
│ │ │ │
│ │ │ │
returns the info-hash(es) of the torrent. If this handle is to a
│ │ │ │ torrent that hasn't loaded yet (for instance by being added) by a
│ │ │ │ URL, the returned value is undefined.
│ │ │ │ The info_hash() returns the SHA-1 info-hash for v1 torrents and a
│ │ │ │ truncated hash for v2 torrents. For the full v2 info-hash, use
│ │ │ │ info_hashes() instead.
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
operator!=() operator<() operator==()
│ │ │ │ +
operator==() operator!=() operator<()
│ │ │ │
│ │ │ │ bool operator== (const torrent_handle& h) const;
│ │ │ │ -bool operator!= (const torrent_handle& h) const;
│ │ │ │ bool operator< (const torrent_handle& h) const;
│ │ │ │ +bool operator!= (const torrent_handle& h) const;
│ │ │ │
│ │ │ │
comparison operators. The order of the torrents is unspecified
│ │ │ │ but stable.
│ │ │ │
[report issue]
│ │ │ │
id()
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,75 +1,75 @@
│ │ │ │ │ >
│ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _b_l_o_c_k___i_n_f_o
│ │ │ │ │ - o _s_e_t___p_e_e_r_(_)_ _p_e_e_r_(_)
│ │ │ │ │ + o _p_e_e_r_(_)_ _s_e_t___p_e_e_r_(_)
│ │ │ │ │ o _e_n_u_m_ _b_l_o_c_k___s_t_a_t_e___t
│ │ │ │ │ * _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o
│ │ │ │ │ * _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │ o _t_o_r_r_e_n_t___h_a_n_d_l_e_(_)
│ │ │ │ │ o _a_d_d___p_i_e_c_e_(_)
│ │ │ │ │ o _r_e_a_d___p_i_e_c_e_(_)
│ │ │ │ │ o _h_a_v_e___p_i_e_c_e_(_)
│ │ │ │ │ o _p_o_s_t___p_e_e_r___i_n_f_o_(_)_ _g_e_t___p_e_e_r___i_n_f_o_(_)
│ │ │ │ │ - o _s_t_a_t_u_s_(_)_ _p_o_s_t___s_t_a_t_u_s_(_)
│ │ │ │ │ - o _p_o_s_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)_ _g_e_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)
│ │ │ │ │ - o _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_s_(_)
│ │ │ │ │ + o _p_o_s_t___s_t_a_t_u_s_(_)_ _s_t_a_t_u_s_(_)
│ │ │ │ │ + o _g_e_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)_ _p_o_s_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)
│ │ │ │ │ + o _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_s_(_)_ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)
│ │ │ │ │ o _p_o_s_t___f_i_l_e___p_r_o_g_r_e_s_s_(_)_ _f_i_l_e___p_r_o_g_r_e_s_s_(_)
│ │ │ │ │ o _f_i_l_e___s_t_a_t_u_s_(_)
│ │ │ │ │ o _c_l_e_a_r___e_r_r_o_r_(_)
│ │ │ │ │ - o _p_o_s_t___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ + o _t_r_a_c_k_e_r_s_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ o _a_d_d___u_r_l___s_e_e_d_(_)_ _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)_ _u_r_l___s_e_e_d_s_(_)
│ │ │ │ │ - o _h_t_t_p___s_e_e_d_s_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ + o _h_t_t_p___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │ o _s_e_t___m_e_t_a_d_a_t_a_(_)
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ - o _r_e_s_u_m_e_(_)_ _p_a_u_s_e_(_)
│ │ │ │ │ + o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)
│ │ │ │ │ o _u_n_s_e_t___f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)
│ │ │ │ │ o _f_l_u_s_h___c_a_c_h_e_(_)
│ │ │ │ │ o _f_o_r_c_e___r_e_c_h_e_c_k_(_)
│ │ │ │ │ o _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ o _n_e_e_d___s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ - o _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)
│ │ │ │ │ - _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)
│ │ │ │ │ + o _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)
│ │ │ │ │ + _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)
│ │ │ │ │ o _q_u_e_u_e___p_o_s_i_t_i_o_n___s_e_t_(_)
│ │ │ │ │ o _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e_(_)
│ │ │ │ │ - o _t_o_r_r_e_n_t___f_i_l_e_(_)_ _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │ + o _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)_ _t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ o _p_i_e_c_e___l_a_y_e_r_s_(_)
│ │ │ │ │ o _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)_ _p_o_s_t___p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)
│ │ │ │ │ o _p_i_e_c_e___p_r_i_o_r_i_t_y_(_)_ _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)_ _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ - o _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)_ _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ + o _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)_ _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)
│ │ │ │ │ o _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ o _s_c_r_a_p_e___t_r_a_c_k_e_r_(_)
│ │ │ │ │ - o _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _u_p_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ + o _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)_ _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ o _c_o_n_n_e_c_t___p_e_e_r_(_)
│ │ │ │ │ o _c_l_e_a_r___p_e_e_r_s_(_)
│ │ │ │ │ - o _m_a_x___u_p_l_o_a_d_s_(_)_ _s_e_t___m_a_x___u_p_l_o_a_d_s_(_)
│ │ │ │ │ + o _s_e_t___m_a_x___u_p_l_o_a_d_s_(_)_ _m_a_x___u_p_l_o_a_d_s_(_)
│ │ │ │ │ o _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │ o _m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │ o _i_d_(_)
│ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │ o _u_s_e_r_d_a_t_a_(_)
│ │ │ │ │ o _i_n___s_e_s_s_i_o_n_(_)
│ │ │ │ │ * _h_a_s_h___v_a_l_u_e_(_)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ bblloocckk__iinnffoo ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │ holds the state of a block in a piece. Who we requested it from and how far
│ │ │ │ │ along we are at downloading it.
│ │ │ │ │ struct block_info
│ │ │ │ │ {
│ │ │ │ │ - void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │ + void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │
│ │ │ │ │ enum block_state_t
│ │ │ │ │ {
│ │ │ │ │ none,
│ │ │ │ │ requested,
│ │ │ │ │ writing,
│ │ │ │ │ finished,
│ │ │ │ │ @@ -77,17 +77,17 @@
│ │ │ │ │
│ │ │ │ │ unsigned bytes_progress:15;
│ │ │ │ │ unsigned block_size:15;
│ │ │ │ │ unsigned state:2;
│ │ │ │ │ unsigned num_peers:14;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppeeeerr(()) ppeeeerr(()) **********
│ │ │ │ │ -void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ +********** ppeeeerr(()) sseett__ppeeeerr(()) **********
│ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │ +void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ The peer is the ip address of the peer this block was downloaded from.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eennuumm bblloocckk__ssttaattee__tt **********
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ |_nn_aa_mm_ee_ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |none |0 |This block has not been downloaded or requested form any |
│ │ │ │ │ @@ -181,114 +181,114 @@
│ │ │ │ │ ttoorrrreenntt__hhaannddllee () noexcept = default;
│ │ │ │ │ void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t
│ │ │ │ │ flags = {}) const;
│ │ │ │ │ void aadddd__ppiieeccee (piece_index_t piece, std::vector data,
│ │ │ │ │ add_piece_flags_t flags = {}) const;
│ │ │ │ │ void rreeaadd__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ - void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │ - void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ + void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ - std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ - void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ + void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │ - void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ + void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ + std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │ flags = {}) const;
│ │ │ │ │ + void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ + void ffiillee__pprrooggrreessss (std::vector& progress,
│ │ │ │ │ +file_progress_flags_t flags = {}) const;
│ │ │ │ │ std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ const;
│ │ │ │ │ void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ - void ffiillee__pprrooggrreessss (std::vector& progress,
│ │ │ │ │ -file_progress_flags_t flags = {}) const;
│ │ │ │ │ std::vector ffiillee__ssttaattuuss () const;
│ │ │ │ │ void cclleeaarr__eerrrroorr () const;
│ │ │ │ │ + void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ - void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ std::vector ttrraacckkeerrss () const;
│ │ │ │ │ - void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ + void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ + void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ std::set uurrll__sseeeeddss () const;
│ │ │ │ │ - void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ void aadddd__eexxtteennssiioonn (
│ │ │ │ │ std::function(torrent_handle const&,
│ │ │ │ │ client_data_t)> const& ext
│ │ │ │ │ , client_data_t userdata = client_data_t{});
│ │ │ │ │ bool sseett__mmeettaaddaattaa (span metadata) const;
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ - void rreessuummee () const;
│ │ │ │ │ void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ + void rreessuummee () const;
│ │ │ │ │ + void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ torrent_flags_t ffllaaggss () const;
│ │ │ │ │ void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ - void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ void fflluusshh__ccaacchhee () const;
│ │ │ │ │ void ffoorrccee__rreecchheecckk () const;
│ │ │ │ │ void ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags = {}) const;
│ │ │ │ │ - bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │ - queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ + bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ - void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ + void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ + queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ │ + void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ + , std::string const& private_key
│ │ │ │ │ + , std::string const& dh_params);
│ │ │ │ │ void sseett__ssssll__cceerrttiiffiiccaattee (std::string const& certificate
│ │ │ │ │ , std::string const& private_key
│ │ │ │ │ , std::string const& dh_params
│ │ │ │ │ , std::string const& passphrase = "");
│ │ │ │ │ - void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ - , std::string const& private_key
│ │ │ │ │ - , std::string const& dh_params);
│ │ │ │ │ - std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │ + std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │ - void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ + void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ + void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ + std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces)
│ │ │ │ │ const;
│ │ │ │ │ - std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ │ const;
│ │ │ │ │ - void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ - download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ - void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │ + void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ + download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │ + void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t =
│ │ │ │ │ {}) const;
│ │ │ │ │ - void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ void ssccrraappee__ttrraacckkeerr (int idx = -1) const;
│ │ │ │ │ - int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ + int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ void ccoonnnneecctt__ppeeeerr (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │ │ , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │ │ void cclleeaarr__ppeeeerrss ();
│ │ │ │ │ void sseett__mmaaxx__uuppllooaaddss (int max_uploads) const;
│ │ │ │ │ int mmaaxx__uuppllooaaddss () const;
│ │ │ │ │ - int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │ void sseett__mmaaxx__ccoonnnneeccttiioonnss (int max_connections) const;
│ │ │ │ │ + int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │ void mmoovvee__ssttoorraaggee (std::string const& save_path
│ │ │ │ │ , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │ │ ) const;
│ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_name) const;
│ │ │ │ │ info_hash_t iinnffoo__hhaasshheess () const;
│ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │ bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │ - bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │ bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ │ + bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │ std::uint32_t iidd () const;
│ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │ client_data_t uusseerrddaattaa () const;
│ │ │ │ │ bool iinn__sseessssiioonn () const;
│ │ │ │ │
│ │ │ │ │ static constexpr add_piece_flags_t oovveerrwwrriittee__eexxiissttiinngg = 0_bit;
│ │ │ │ │ static constexpr status_flags_t qquueerryy__ddiissttrriibbuutteedd__ccooppiieess = 0_bit;
│ │ │ │ │ @@ -355,29 +355,29 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** hhaavvee__ppiieeccee(()) **********
│ │ │ │ │ bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ Returns true if this piece has been completely downloaded and written to disk,
│ │ │ │ │ and false otherwise.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppoosstt__ppeeeerr__iinnffoo(()) ggeett__ppeeeerr__iinnffoo(()) **********
│ │ │ │ │ -void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │ +void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ Query information about connected peers for this torrent. If the _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │ is invalid, it will throw a system_error exception.
│ │ │ │ │ post_peer_info() is asynchronous and will trigger the posting of a
│ │ │ │ │ _p_e_e_r___i_n_f_o___a_l_e_r_t. The _a_l_e_r_t contain a list of _p_e_e_r___i_n_f_o objects, one for each
│ │ │ │ │ connected peer.
│ │ │ │ │ get_peer_info() is synchronous and takes a reference to a vector that will be
│ │ │ │ │ cleared and filled with one _e_n_t_r_y for each peer connected to this torrent,
│ │ │ │ │ given the handle is valid. Each _e_n_t_r_y in the vector contains information about
│ │ │ │ │ that particular peer. See _p_e_e_r___i_n_f_o.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssttaattuuss(()) ppoosstt__ssttaattuuss(()) **********
│ │ │ │ │ -void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +********** ppoosstt__ssttaattuuss(()) ssttaattuuss(()) **********
│ │ │ │ │ torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ status() will return a structure with information about the status of this
│ │ │ │ │ torrent. If the _t_o_r_r_e_n_t___h_a_n_d_l_e is invalid, it will throw system_error
│ │ │ │ │ exception. See _t_o_r_r_e_n_t___s_t_a_t_u_s. The flags argument filters what information is
│ │ │ │ │ returned in the _t_o_r_r_e_n_t___s_t_a_t_u_s. Some information in there is relatively
│ │ │ │ │ expensive to calculate, and if you're not interested in it (and see performance
│ │ │ │ │ issues), you can filter them out.
│ │ │ │ │ The status() function will block until the internal libtorrent thread responds
│ │ │ │ │ @@ -385,28 +385,28 @@
│ │ │ │ │ It will trigger posting of a _s_t_a_t_e___u_p_d_a_t_e___a_l_e_r_t with a single _t_o_r_r_e_n_t___s_t_a_t_u_s
│ │ │ │ │ object for this torrent.
│ │ │ │ │ In order to get regular updates for torrents whose status changes, consider
│ │ │ │ │ calling session::post_torrent_updates()`` instead.
│ │ │ │ │ By default everything is included. The flags you can use to decide what to
│ │ │ │ │ iinncclluuddee are defined in this class.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppoosstt__ddoowwnnllooaadd__qquueeuuee(()) ggeett__ddoowwnnllooaadd__qquueeuuee(()) **********
│ │ │ │ │ -std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ -void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ +********** ggeett__ddoowwnnllooaadd__qquueeuuee(()) ppoosstt__ddoowwnnllooaadd__qquueeuuee(()) **********
│ │ │ │ │ void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │ +void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ +std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ post_download_queue() triggers a download_queue_alert to be posted.
│ │ │ │ │ get_download_queue() is a synchronous call and returns a vector with
│ │ │ │ │ information about pieces that are partially downloaded or not downloaded but
│ │ │ │ │ partially requested. See _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o for the fields in the returned
│ │ │ │ │ vector.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppiieeccee__ddeeaaddlliinnee(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) **********
│ │ │ │ │ -void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ +********** cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) sseett__ppiieeccee__ddeeaaddlliinnee(()) **********
│ │ │ │ │ void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │ flags = {}) const;
│ │ │ │ │ +void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ This function sets or resets the deadline associated with a specific piece
│ │ │ │ │ index (index). libtorrent will attempt to download this entire piece before the
│ │ │ │ │ deadline expires. This is not necessarily possible, but pieces with a more
│ │ │ │ │ recent deadline will always be prioritized over pieces with a deadline further
│ │ │ │ │ ahead in time. The deadline (and flags) of a piece can be changed by calling
│ │ │ │ │ this function again.
│ │ │ │ │ @@ -416,19 +416,19 @@
│ │ │ │ │ deadline is the number of milliseconds until this piece should be completed.
│ │ │ │ │ reset_piece_deadline removes the deadline from the piece. If it hasn't already
│ │ │ │ │ been downloaded, it will no longer be considered a priority.
│ │ │ │ │ clear_piece_deadlines() removes deadlines on all pieces in the torrent. As if
│ │ │ │ │ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_) was called on all pieces.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppoosstt__ffiillee__pprrooggrreessss(()) ffiillee__pprrooggrreessss(()) **********
│ │ │ │ │ +void ffiillee__pprrooggrreessss (std::vector& progress, file_progress_flags_t
│ │ │ │ │ +flags = {}) const;
│ │ │ │ │ std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ const;
│ │ │ │ │ void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ -void ffiillee__pprrooggrreessss (std::vector& progress, file_progress_flags_t
│ │ │ │ │ -flags = {}) const;
│ │ │ │ │ This function fills in the supplied vector, or returns a vector, with the
│ │ │ │ │ number of bytes downloaded of each file in this torrent. The progress values
│ │ │ │ │ are ordered the same as the files in the _t_o_r_r_e_n_t___i_n_f_o.
│ │ │ │ │ This operation is not very cheap. Its complexity is OO((nn ++ mmjj)). Where nn is the
│ │ │ │ │ number of files, mm is the number of currently downloading pieces and jj is the
│ │ │ │ │ number of blocks in a piece.
│ │ │ │ │ The flags parameter can be used to specify the granularity of the file
│ │ │ │ │ @@ -449,19 +449,19 @@
│ │ │ │ │ See _o_p_e_n___f_i_l_e___s_t_a_t_e
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** cclleeaarr__eerrrroorr(()) **********
│ │ │ │ │ void cclleeaarr__eerrrroorr () const;
│ │ │ │ │ If the torrent is in an error state (i.e. torrent_status::error is non-empty),
│ │ │ │ │ this will clear the error and start the torrent again.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppoosstt__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) rreeppllaaccee__ttrraacckkeerrss(()) **********
│ │ │ │ │ +********** ttrraacckkeerrss(()) rreeppllaaccee__ttrraacckkeerrss(()) ppoosstt__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ +void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ -void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ std::vector ttrraacckkeerrss () const;
│ │ │ │ │ -void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ +void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ trackers() returns the list of trackers for this torrent. The announce _e_n_t_r_y
│ │ │ │ │ contains both a string url which specify the announce url for the tracker as
│ │ │ │ │ well as an _i_n_t tier, which is specifies the order in which this tracker is
│ │ │ │ │ tried. If you want libtorrent to use another list of trackers for this torrent,
│ │ │ │ │ you can use replace_trackers() which takes a list of the same form as the one
│ │ │ │ │ returned from trackers() and will replace it. If you want an immediate effect,
│ │ │ │ │ you have to call _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_). See _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ @@ -471,26 +471,26 @@
│ │ │ │ │ is, it doesn't do anything. If it's not in the current set of trackers, it will
│ │ │ │ │ insert it in the tier specified in the _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ The updated set of trackers will be saved in the resume data, and when a
│ │ │ │ │ torrent is started with resume data, the trackers from the resume data will
│ │ │ │ │ replace the original ones.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aadddd__uurrll__sseeeedd(()) rreemmoovvee__uurrll__sseeeedd(()) uurrll__sseeeeddss(()) **********
│ │ │ │ │ +void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ std::set uurrll__sseeeeddss () const;
│ │ │ │ │ -void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ add_url_seed() adds another url to the torrent's list of url seeds. If the
│ │ │ │ │ given url already exists in that list, the call has no effect. The torrent will
│ │ │ │ │ connect to the server and try to download pieces from it, unless it's paused,
│ │ │ │ │ queued, checking or seeding. remove_url_seed() removes the given url if it
│ │ │ │ │ exists already. url_seeds() return a set of the url seeds currently in this
│ │ │ │ │ torrent. Note that URLs that fails may be removed automatically from the list.
│ │ │ │ │ See _h_t_t_p_ _s_e_e_d_i_n_g for more information.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhttttpp__sseeeeddss(()) rreemmoovvee__hhttttpp__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ +********** hhttttpp__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) rreemmoovvee__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ These functions are identical as the *_url_seed() variants, but they operate on
│ │ │ │ │ _B_E_P_ _1_7 web seeds instead of _B_E_P_ _1_9.
│ │ │ │ │ See _h_t_t_p_ _s_e_e_d_i_n_g for more information.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -524,17 +524,17 @@
│ │ │ │ │ and false afterward.
│ │ │ │ │ Clients should only use _i_s___v_a_l_i_d_(_) to determine if the result of session::
│ │ │ │ │ find_torrent() was successful.
│ │ │ │ │ Unlike other member functions which return a value, _i_s___v_a_l_i_d_(_) completes
│ │ │ │ │ immediately, without blocking on a result from the network thread. Also unlike
│ │ │ │ │ other functions, it never throws the system_error exception.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** rreessuummee(()) ppaauussee(()) **********
│ │ │ │ │ -void rreessuummee () const;
│ │ │ │ │ +********** ppaauussee(()) rreessuummee(()) **********
│ │ │ │ │ void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ +void rreessuummee () const;
│ │ │ │ │ pause(), and resume() will disconnect all peers and reconnect all peers
│ │ │ │ │ respectively. When a torrent is paused, it will however remember all share
│ │ │ │ │ ratios to all peers and remember all potential (not connected) peers. Torrents
│ │ │ │ │ may be paused automatically if there is a file error (e.g. disk full) or
│ │ │ │ │ something similar. See _f_i_l_e___e_r_r_o_r___a_l_e_r_t.
│ │ │ │ │ For possible values of the flags parameter, see pause_flags_t.
│ │ │ │ │ To know if a torrent is paused or not, call torrent_handle::flags() and check
│ │ │ │ │ @@ -542,18 +542,18 @@
│ │ │ │ │ Note
│ │ │ │ │ Torrents that are auto-managed may be automatically resumed again. It does not
│ │ │ │ │ make sense to pause an auto-managed torrent without making it not auto-managed
│ │ │ │ │ first. Torrents are auto-managed by default when added to the _s_e_s_s_i_o_n. For more
│ │ │ │ │ information, see _q_u_e_u_i_n_g.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** uunnsseett__ffllaaggss(()) sseett__ffllaaggss(()) ffllaaggss(()) **********
│ │ │ │ │ +void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ torrent_flags_t ffllaaggss () const;
│ │ │ │ │ void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ -void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ sets and gets the torrent state flags. See _t_o_r_r_e_n_t___f_l_a_g_s___t. The set_flags
│ │ │ │ │ overload that take a mask will affect all flags part of the mask, and set their
│ │ │ │ │ values to what the flags argument is set to. This allows clearing and setting
│ │ │ │ │ flags in a single function call. The set_flags overload that just takes flags,
│ │ │ │ │ sets all the specified flags and leave any other flags unchanged. unset_flags
│ │ │ │ │ clears the specified flags, while leaving any other flags unchanged.
│ │ │ │ │ Theseed_modeflag is special, it can only be cleared once the torrent has been
│ │ │ │ │ @@ -663,34 +663,34 @@
│ │ │ │ │ Note how outstanding_resume_data is a global counter in this example. This is
│ │ │ │ │ deliberate, otherwise there is a race condition for torrents that was just
│ │ │ │ │ asked to save their resume data, they posted the _a_l_e_r_t, but it has not been
│ │ │ │ │ received yet. Those torrents would report that they don't need to save resume
│ │ │ │ │ data again, and skipped by the initial loop, and thwart the counter otherwise.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nneeeedd__ssaavvee__rreessuummee__ddaattaa(()) **********
│ │ │ │ │ -bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │ +bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ This function returns true if anything that is stored in the resume data has
│ │ │ │ │ changed since the last time resume data was saved. The overload that takes
│ │ │ │ │ flags let you ask if specific categories of properties have changed. These
│ │ │ │ │ flags have the same behavior as in the _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) call.
│ │ │ │ │ This is a bblloocckkiinngg call. It will wait for a response from libtorrent's main
│ │ │ │ │ thread. A way to avoid blocking is to instead call _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) directly,
│ │ │ │ │ specifying the conditions under which resume data should be saved.
│ │ │ │ │ Note
│ │ │ │ │ A torrent's resume data is considered saved as soon as the
│ │ │ │ │ _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t is posted. It is important to make sure this _a_l_e_r_t is
│ │ │ │ │ received and handled in order for this function to be meaningful.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** qquueeuuee__ppoossiittiioonn__uupp(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) qquueeuuee__ppoossiittiioonn__ttoopp(())
│ │ │ │ │ -qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn(()) **********
│ │ │ │ │ -queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ +********** qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn__uupp(()) qquueeuuee__ppoossiittiioonn__ttoopp(())
│ │ │ │ │ +qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) **********
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ +queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ Every torrent that is added is assigned a queue position exactly one greater
│ │ │ │ │ than the greatest queue position of all existing torrents. Torrents that are
│ │ │ │ │ being seeded have -1 as their queue position, since they're no longer in line
│ │ │ │ │ to be downloaded.
│ │ │ │ │ When a torrent is removed or turns into a seed, all torrents with greater queue
│ │ │ │ │ positions have their positions decreased to fill in the space in the sequence.
│ │ │ │ │ @@ -706,21 +706,21 @@
│ │ │ │ │ ********** qquueeuuee__ppoossiittiioonn__sseett(()) **********
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ │ updates the position in the queue for this torrent. The relative order of all
│ │ │ │ │ other torrents remain intact but their numerical queue position shifts to make
│ │ │ │ │ space for this torrent's new position
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr(()) sseett__ssssll__cceerrttiiffiiccaattee(()) **********
│ │ │ │ │ +void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ + , std::string const& private_key
│ │ │ │ │ + , std::string const& dh_params);
│ │ │ │ │ void sseett__ssssll__cceerrttiiffiiccaattee (std::string const& certificate
│ │ │ │ │ , std::string const& private_key
│ │ │ │ │ , std::string const& dh_params
│ │ │ │ │ , std::string const& passphrase = "");
│ │ │ │ │ -void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ - , std::string const& private_key
│ │ │ │ │ - , std::string const& dh_params);
│ │ │ │ │ For SSL torrents, use this to specify a path to a .pem file to use as this
│ │ │ │ │ client's certificate. The certificate must be signed by the certificate in the
│ │ │ │ │ .torrent file to be valid.
│ │ │ │ │ The _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_) overload takes the actual certificate, private
│ │ │ │ │ key and DH params as strings, rather than paths to files.
│ │ │ │ │ cert is a path to the (signed) certificate in .pem format corresponding to this
│ │ │ │ │ torrent.
│ │ │ │ │ @@ -734,17 +734,17 @@
│ │ │ │ │ Note that when a torrent first starts up, and it needs a certificate, it will
│ │ │ │ │ suspend connecting to any peers until it has one. It's typically desirable to
│ │ │ │ │ resume the torrent after setting the SSL certificate.
│ │ │ │ │ If you receive a _t_o_r_r_e_n_t___n_e_e_d___c_e_r_t___a_l_e_r_t, you need to call this to provide a
│ │ │ │ │ valid cert. If you don't have a cert you won't be allowed to connect to any
│ │ │ │ │ peers.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ttoorrrreenntt__ffiillee(()) ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess(()) **********
│ │ │ │ │ -std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ +********** ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess(()) ttoorrrreenntt__ffiillee(()) **********
│ │ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │ +std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ _t_o_r_r_e_n_t___f_i_l_e_(_) returns a pointer to the _t_o_r_r_e_n_t___i_n_f_o object associated with
│ │ │ │ │ this torrent. The _t_o_r_r_e_n_t___i_n_f_o object may be a copy of the internal object. If
│ │ │ │ │ the torrent doesn't have metadata, the pointer will not be initialized (i.e. a
│ │ │ │ │ nullptr). The torrent may be in a state without metadata only if it was started
│ │ │ │ │ without a .torrent file, e.g. by being added by magnet link.
│ │ │ │ │ Note that the _t_o_r_r_e_n_t___i_n_f_o object returned here may be a different instance
│ │ │ │ │ than the one added to the _s_e_s_s_i_o_n, with different attributes like piece layers,
│ │ │ │ │ @@ -771,32 +771,32 @@
│ │ │ │ │ ********** ppiieeccee__llaayyeerrss(()) **********
│ │ │ │ │ std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │ returns the piece layers for all files in the torrent. If this is a v1 torrent
│ │ │ │ │ (and doesn't have any piece layers) it returns an empty vector. This is a
│ │ │ │ │ blocking call that will synchronize with the libtorrent network thread.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__aavvaaiillaabbiilliittyy(()) ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy(()) **********
│ │ │ │ │ -void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ +void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ The piece availability is the number of peers that we are connected that has
│ │ │ │ │ advertised having a particular piece. This is the information that libtorrent
│ │ │ │ │ uses in order to prefer picking rare pieces.
│ │ │ │ │ post_piece_availability() will trigger a _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y___a_l_e_r_t to be posted.
│ │ │ │ │ piece_availability() fills the specified std::vector with the availability
│ │ │ │ │ for each piece in this torrent. libtorrent does not keep track of availability
│ │ │ │ │ for seeds, so if the torrent is seeding the availability for all pieces is
│ │ │ │ │ reported as 0.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__pprriioorriittyy(()) pprriioorriittiizzee__ppiieecceess(()) ggeett__ppiieeccee__pprriioorriittiieess(()) **********
│ │ │ │ │ -void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) const;
│ │ │ │ │ +void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ +void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) const;
│ │ │ │ │ download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ │ -void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ These functions are used to set and get the priority of individual pieces. By
│ │ │ │ │ default all pieces have priority 4. That means that the random rarest first
│ │ │ │ │ algorithm is effectively active for all pieces. You may however change the
│ │ │ │ │ priority of individual pieces. There are 8 priority levels. 0 means not to
│ │ │ │ │ download the piece at all. Otherwise, lower priority values means less likely
│ │ │ │ │ to be picked. Piece priority takes precedence over piece availability. Every
│ │ │ │ │ piece with priority 7 will be attempted to be picked before a priority 6 piece
│ │ │ │ │ @@ -816,18 +816,18 @@
│ │ │ │ │ where the piece index or priority is out of range, are not allowed.
│ │ │ │ │ get_piece_priorities returns a vector with one element for each piece in the
│ │ │ │ │ torrent. Each element is the current priority of that piece.
│ │ │ │ │ It's possible to cancel the effect of ffiillee priorities by setting the priorities
│ │ │ │ │ for the affected pieces. Care has to be taken when mixing usage of file- and
│ │ │ │ │ piece priorities.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** pprriioorriittiizzee__ffiilleess(()) ffiillee__pprriioorriittyy(()) ggeett__ffiillee__pprriioorriittiieess(()) **********
│ │ │ │ │ -download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ -void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ +********** ggeett__ffiillee__pprriioorriittiieess(()) ffiillee__pprriioorriittyy(()) pprriioorriittiizzee__ffiilleess(()) **********
│ │ │ │ │ void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │ +void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ +download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ index must be in the range [0, number_of_files).
│ │ │ │ │ file_priority() queries or sets the priority of file index.
│ │ │ │ │ prioritize_files() takes a vector that has at as many elements as there are
│ │ │ │ │ files in the torrent. Each _e_n_t_r_y is the priority of that file. The function
│ │ │ │ │ sets the priorities of all the pieces in the torrent based on the vector.
│ │ │ │ │ get_file_priorities() returns a vector with the priorities of all files.
│ │ │ │ │ @@ -849,17 +849,17 @@
│ │ │ │ │ the piece priorities.
│ │ │ │ │ Moving data from a file into the part file is currently not supported. If a
│ │ │ │ │ file has its priority set to 0 aafftteerr it has already been created, it will not
│ │ │ │ │ be moved into the partfile.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) ffoorrccee__llssdd__aannnnoouunnccee(()) **********
│ │ │ │ │ void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │ +void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t = {})
│ │ │ │ │ const;
│ │ │ │ │ -void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ force_reannounce() will force this torrent to do another tracker request, to
│ │ │ │ │ receive new peers. The seconds argument specifies how many seconds from now to
│ │ │ │ │ issue the tracker announces.
│ │ │ │ │ If the tracker's min_interval has not passed since the last announce, the
│ │ │ │ │ forced announce will be scheduled to happen immediately as the min_interval
│ │ │ │ │ expires. This is to honor trackers minimum re-announce interval settings.
│ │ │ │ │ The tracker_index argument specifies which tracker to re-announce. If set to -
│ │ │ │ │ @@ -877,20 +877,20 @@
│ │ │ │ │ A scrape request queries the tracker for statistics such as total number of
│ │ │ │ │ incomplete peers, complete peers, number of downloads etc.
│ │ │ │ │ This request will specifically update the num_complete and num_incomplete
│ │ │ │ │ fields in the _t_o_r_r_e_n_t___s_t_a_t_u_s struct once it completes. When it completes, it
│ │ │ │ │ will generate a _s_c_r_a_p_e___r_e_p_l_y___a_l_e_r_t. If it fails, it will generate a
│ │ │ │ │ _s_c_r_a_p_e___f_a_i_l_e_d___a_l_e_r_t.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddoowwnnllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(())
│ │ │ │ │ +********** sseett__uuppllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(())
│ │ │ │ │ **********
│ │ │ │ │ -int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ +int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ set_upload_limit will limit the upload bandwidth used by this particular
│ │ │ │ │ torrent to the limit you set. It is given as the number of bytes per second the
│ │ │ │ │ torrent is allowed to upload. set_download_limit works the same way but for
│ │ │ │ │ download bandwidth instead of upload bandwidth. Note that setting a higher
│ │ │ │ │ limit on a torrent then the global limit (settings_pack::upload_rate_limit)
│ │ │ │ │ will not override the global rate limit. The torrent can never upload more than
│ │ │ │ │ the global rate limit.
│ │ │ │ │ @@ -913,26 +913,26 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** cclleeaarr__ppeeeerrss(()) **********
│ │ │ │ │ void cclleeaarr__ppeeeerrss ();
│ │ │ │ │ This will disconnect all peers and clear the peer list for this torrent. New
│ │ │ │ │ peers will have to be acquired before resuming, from trackers, DHT or local
│ │ │ │ │ service discovery, for example.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** mmaaxx__uuppllooaaddss(()) sseett__mmaaxx__uuppllooaaddss(()) **********
│ │ │ │ │ +********** sseett__mmaaxx__uuppllooaaddss(()) mmaaxx__uuppllooaaddss(()) **********
│ │ │ │ │ void sseett__mmaaxx__uuppllooaaddss (int max_uploads) const;
│ │ │ │ │ int mmaaxx__uuppllooaaddss () const;
│ │ │ │ │ set_max_uploads() sets the maximum number of peers that's unchoked at the same
│ │ │ │ │ time on this torrent. If you set this to -1, there will be no limit. This
│ │ │ │ │ defaults to infinite. The primary setting controlling this is the global
│ │ │ │ │ unchoke slots limit, set by unchoke_slots_limit in _s_e_t_t_i_n_g_s___p_a_c_k.
│ │ │ │ │ max_uploads() returns the current settings.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** mmaaxx__ccoonnnneeccttiioonnss(()) sseett__mmaaxx__ccoonnnneeccttiioonnss(()) **********
│ │ │ │ │ -int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │ void sseett__mmaaxx__ccoonnnneeccttiioonnss (int max_connections) const;
│ │ │ │ │ +int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │ set_max_connections() sets the maximum number of connection this torrent will
│ │ │ │ │ open. If all connections are used up, incoming connections may be refused or
│ │ │ │ │ poor connections may be closed. This must be at least 2. The default is
│ │ │ │ │ unlimited number of connections. If -1 is given to the function, it means
│ │ │ │ │ unlimited. There is also a global limit of the number of connections, set by
│ │ │ │ │ connections_limit in _s_e_t_t_i_n_g_s___p_a_c_k.
│ │ │ │ │ max_connections() returns the current settings.
│ │ │ │ │ @@ -991,18 +991,18 @@
│ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │ returns the info-hash(es) of the torrent. If this handle is to a torrent that
│ │ │ │ │ hasn't loaded yet (for instance by being added) by a URL, the returned value is
│ │ │ │ │ undefined. The info_hash() returns the SHA-1 info-hash for v1 torrents and a
│ │ │ │ │ truncated hash for v2 torrents. For the full v2 info-hash, use info_hashes()
│ │ │ │ │ instead.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr!!==(()) ooppeerraattoorr<<(()) ooppeerraattoorr====(()) **********
│ │ │ │ │ +********** ooppeerraattoorr====(()) ooppeerraattoorr!!==(()) ooppeerraattoorr<<(()) **********
│ │ │ │ │ bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │ -bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │ bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ │ +bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │ comparison operators. The order of the torrents is unspecified but stable.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iidd(()) **********
│ │ │ │ │ std::uint32_t iidd () const;
│ │ │ │ │ returns a unique identifier for this torrent. It's not a dense index. It's not
│ │ │ │ │ preserved across sessions.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Info.html
│ │ │ │ @@ -38,35 +38,35 @@
│ │ │ │ enum type_t
│ │ │ │
│ │ │ │
│ │ │ │ load_torrent_limits
│ │ │ │ torrent_info
│ │ │ │ - torrent_info()
│ │ │ │ - ~torrent_info()
│ │ │ │ -- orig_files() files()
│ │ │ │ +- files() orig_files()
│ │ │ │ - rename_file()
│ │ │ │ - remap_files()
│ │ │ │ -- clear_trackers() trackers() add_tracker()
│ │ │ │ -- similar_torrents() collections()
│ │ │ │ -- set_web_seeds() add_url_seed() web_seeds() add_http_seed()
│ │ │ │ +- trackers() add_tracker() clear_trackers()
│ │ │ │ +- collections() similar_torrents()
│ │ │ │ +- set_web_seeds() add_http_seed() add_url_seed() web_seeds()
│ │ │ │ - total_size()
│ │ │ │ - num_pieces() piece_length()
│ │ │ │ - blocks_per_piece()
│ │ │ │ -- piece_range() last_piece() end_piece()
│ │ │ │ +- piece_range() end_piece() last_piece()
│ │ │ │ - info_hash() info_hashes()
│ │ │ │ -- v1() v2()
│ │ │ │ +- v2() v1()
│ │ │ │ - num_files()
│ │ │ │ - map_block()
│ │ │ │ - map_file()
│ │ │ │ - ssl_cert()
│ │ │ │ - is_valid()
│ │ │ │ - priv()
│ │ │ │ - is_i2p()
│ │ │ │ - piece_size()
│ │ │ │ -- hash_for_piece_ptr() hash_for_piece()
│ │ │ │ +- hash_for_piece() hash_for_piece_ptr()
│ │ │ │ - name()
│ │ │ │ - creation_date()
│ │ │ │ - creator()
│ │ │ │ - comment()
│ │ │ │ - nodes()
│ │ │ │ - add_node()
│ │ │ │ - parse_info_section()
│ │ │ │ @@ -197,69 +197,69 @@
│ │ │ │
│ │ │ │
torrent_info
│ │ │ │
Declared in "libtorrent/torrent_info.hpp"
│ │ │ │
the torrent_info class holds the information found in a .torrent file.
│ │ │ │
│ │ │ │ class torrent_info
│ │ │ │ {
│ │ │ │ - torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ - explicit torrent_info (std::string const& filename);
│ │ │ │ - torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ torrent_info (torrent_info const& t);
│ │ │ │ - explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ - torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ - torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ + explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ - torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ - torrent_info (char const* buffer, int size);
│ │ │ │ + torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ + torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ + torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ + explicit torrent_info (std::string const& filename);
│ │ │ │ torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ - explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ + torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ + torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ + torrent_info (char const* buffer, int size);
│ │ │ │ + explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ ~torrent_info ();
│ │ │ │ - file_storage const& files () const;
│ │ │ │ file_storage const& orig_files () const;
│ │ │ │ + file_storage const& files () const;
│ │ │ │ void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │ void remap_files (file_storage const& f);
│ │ │ │ - std::vector<announce_entry> const& trackers () const;
│ │ │ │ void add_tracker (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ void clear_trackers ();
│ │ │ │ + std::vector<announce_entry> const& trackers () const;
│ │ │ │ void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ - std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ std::vector<std::string> collections () const;
│ │ │ │ + std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ + void add_url_seed (std::string const& url
│ │ │ │ + , std::string const& ext_auth = std::string()
│ │ │ │ + , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │ void add_http_seed (std::string const& url
│ │ │ │ , std::string const& extern_auth = std::string()
│ │ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ - void add_url_seed (std::string const& url
│ │ │ │ - , std::string const& ext_auth = std::string()
│ │ │ │ - , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │ std::int64_t total_size () const;
│ │ │ │ - int num_pieces () const;
│ │ │ │ int piece_length () const;
│ │ │ │ + int num_pieces () const;
│ │ │ │ int blocks_per_piece () const;
│ │ │ │ piece_index_t last_piece () const;
│ │ │ │ - index_range<piece_index_t> piece_range () const;
│ │ │ │ piece_index_t end_piece () const;
│ │ │ │ - sha1_hash info_hash () const noexcept;
│ │ │ │ + index_range<piece_index_t> piece_range () const;
│ │ │ │ info_hash_t const& info_hashes () const;
│ │ │ │ - bool v2 () const;
│ │ │ │ + sha1_hash info_hash () const noexcept;
│ │ │ │ bool v1 () const;
│ │ │ │ + bool v2 () const;
│ │ │ │ int num_files () const;
│ │ │ │ std::vector<file_slice> map_block (piece_index_t const piece
│ │ │ │ , std::int64_t offset, int size) const;
│ │ │ │ peer_request map_file (file_index_t const file, std::int64_t offset, int size) const;
│ │ │ │ string_view ssl_cert () const;
│ │ │ │ bool is_valid () const;
│ │ │ │ bool priv () const;
│ │ │ │ bool is_i2p () const;
│ │ │ │ int piece_size (piece_index_t index) const;
│ │ │ │ - char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │ + char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ bool is_loaded () const;
│ │ │ │ const std::string& name () const;
│ │ │ │ std::time_t creation_date () const;
│ │ │ │ const std::string& creator () const;
│ │ │ │ const std::string& comment () const;
│ │ │ │ std::vector<std::pair<std::string, int>> const& nodes () const;
│ │ │ │ void add_node (std::pair<std::string, int> const& node);
│ │ │ │ @@ -269,27 +269,27 @@
│ │ │ │ span<char const> piece_layer (file_index_t) const;
│ │ │ │ void free_piece_layers ();
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
torrent_info()
│ │ │ │
│ │ │ │ -torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ -explicit torrent_info (std::string const& filename);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ torrent_info (torrent_info const& t);
│ │ │ │ -explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ -torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -torrent_info (char const* buffer, int size);
│ │ │ │ +torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ +torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ +torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ +explicit torrent_info (std::string const& filename);
│ │ │ │ torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ +torrent_info (char const* buffer, int size);
│ │ │ │ +explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │
│ │ │ │
The constructor that takes an info-hash will initialize the info-hash
│ │ │ │ to the given value, but leave all other fields empty. This is used
│ │ │ │ internally when downloading torrents without the metadata. The
│ │ │ │ metadata will be created by libtorrent as soon as it has been
│ │ │ │ downloaded from the swarm.
│ │ │ │
The constructor that takes a bdecode_node will create a torrent_info
│ │ │ │ @@ -318,21 +318,21 @@
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
~torrent_info()
│ │ │ │
│ │ │ │ ~torrent_info ();
│ │ │ │
│ │ │ │
frees all storage associated with this torrent_info object
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
orig_files() files()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
files() orig_files()
│ │ │ │
│ │ │ │ -file_storage const& files () const;
│ │ │ │ file_storage const& orig_files () const;
│ │ │ │ +file_storage const& files () const;
│ │ │ │
│ │ │ │
The file_storage object contains the information on how to map the
│ │ │ │ pieces to files. It is separated from the torrent_info object because
│ │ │ │ when creating torrents a storage object needs to be created without
│ │ │ │ having a torrent file. When renaming files in a storage, the storage
│ │ │ │ needs to make its own copy of the file_storage in order to make its
│ │ │ │ mapping differ from the one in the torrent file.
│ │ │ │ @@ -376,64 +376,64 @@
│ │ │ │
│ │ │ │
Remaps the file storage to a new file layout. This can be used to, for
│ │ │ │ instance, download all data in a torrent to a single file, or to a
│ │ │ │ number of fixed size sector aligned files, regardless of the number
│ │ │ │ and sizes of the files in the torrent.
│ │ │ │
The new specified file_storage must have the exact same size as
│ │ │ │ the current one.
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
clear_trackers() trackers() add_tracker()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
trackers() add_tracker() clear_trackers()
│ │ │ │
│ │ │ │ -std::vector<announce_entry> const& trackers () const;
│ │ │ │ void add_tracker (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ void clear_trackers ();
│ │ │ │ +std::vector<announce_entry> const& trackers () const;
│ │ │ │ void add_tracker (std::string const& url, int tier = 0);
│ │ │ │
│ │ │ │
add_tracker() adds a tracker to the announce-list. The tier
│ │ │ │ determines the order in which the trackers are to be tried.
│ │ │ │ The trackers() function will return a sorted vector of
│ │ │ │ announce_entry. Each announce entry contains a string, which is
│ │ │ │ the tracker url, and a tier index. The tier index is the high-level
│ │ │ │ priority. No matter which trackers that works or not, the ones with
│ │ │ │ lower tier will always be tried before the one with higher tier
│ │ │ │ number. For more information, see announce_entry.
│ │ │ │
trackers() returns all entries from announce-list.
│ │ │ │
clear_trackers() removes all trackers from announce-list.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
similar_torrents() collections()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
collections() similar_torrents()
│ │ │ │
│ │ │ │ -std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ std::vector<std::string> collections () const;
│ │ │ │ +std::vector<sha1_hash> similar_torrents () const;
│ │ │ │
│ │ │ │
These two functions are related to BEP 38 (mutable torrents). The
│ │ │ │ vectors returned from these correspond to the "similar" and
│ │ │ │ "collections" keys in the .torrent file. Both info-hashes and
│ │ │ │ collections from within the info-dict and from outside of it are
│ │ │ │ included.
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
set_web_seeds() add_url_seed() web_seeds() add_http_seed()
│ │ │ │ +
[report issue]
│ │ │ │ +
set_web_seeds() add_http_seed() add_url_seed() web_seeds()
│ │ │ │
│ │ │ │ std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ +void add_url_seed (std::string const& url
│ │ │ │ + , std::string const& ext_auth = std::string()
│ │ │ │ + , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │ void add_http_seed (std::string const& url
│ │ │ │ , std::string const& extern_auth = std::string()
│ │ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ -void add_url_seed (std::string const& url
│ │ │ │ - , std::string const& ext_auth = std::string()
│ │ │ │ - , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │
│ │ │ │
web_seeds() returns all url seeds and http seeds in the torrent.
│ │ │ │ Each entry is a web_seed_entry and may refer to either a url seed
│ │ │ │ or http seed.
│ │ │ │
add_url_seed() and add_http_seed() adds one url to the list of
│ │ │ │ url/http seeds.
│ │ │ │
set_web_seeds() replaces all web seeds with the ones specified in
│ │ │ │ @@ -458,16 +458,16 @@
│ │ │ │ the total size will be larger than the sum of all (regular) file
│ │ │ │ sizes.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
num_pieces() piece_length()
│ │ │ │
│ │ │ │ -int num_pieces () const;
│ │ │ │ int piece_length () const;
│ │ │ │ +int num_pieces () const;
│ │ │ │
│ │ │ │
piece_length() and num_pieces() returns the number of byte
│ │ │ │ for each piece and the total number of pieces, respectively. The
│ │ │ │ difference between piece_size() and piece_length() is that
│ │ │ │ piece_size() takes the piece index as argument and gives you the
│ │ │ │ exact size of that piece. It will always be the same as
│ │ │ │ piece_length() except in the case of the last piece, which may be
│ │ │ │ @@ -477,47 +477,47 @@
│ │ │ │
blocks_per_piece()
│ │ │ │
│ │ │ │ int blocks_per_piece () const;
│ │ │ │
│ │ │ │
returns the number of blocks there are in the typical piece. There
│ │ │ │ may be fewer in the last piece)
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
piece_range() last_piece() end_piece()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
piece_range() end_piece() last_piece()
│ │ │ │
│ │ │ │ piece_index_t last_piece () const;
│ │ │ │ -index_range<piece_index_t> piece_range () const;
│ │ │ │ piece_index_t end_piece () const;
│ │ │ │ +index_range<piece_index_t> piece_range () const;
│ │ │ │
│ │ │ │
last_piece() returns the index to the last piece in the torrent and
│ │ │ │ end_piece() returns the index to the one-past-end piece in the
│ │ │ │ torrent
│ │ │ │ piece_range() returns an implementation-defined type that can be
│ │ │ │ used as the container in a range-for loop. Where the values are the
│ │ │ │ indices of all pieces in the file_storage.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
info_hash() info_hashes()
│ │ │ │
│ │ │ │ -sha1_hash info_hash () const noexcept;
│ │ │ │ info_hash_t const& info_hashes () const;
│ │ │ │ +sha1_hash info_hash () const noexcept;
│ │ │ │
│ │ │ │
returns the info-hash of the torrent. For BitTorrent v2 support, use
│ │ │ │ info_hashes() to get an object that may hold both a v1 and v2
│ │ │ │ info-hash
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ +
v2() v1()
│ │ │ │
│ │ │ │ -bool v2 () const;
│ │ │ │ bool v1 () const;
│ │ │ │ +bool v2 () const;
│ │ │ │
│ │ │ │
returns whether this torrent has v1 and/or v2 metadata, respectively.
│ │ │ │ Hybrid torrents have both. These are shortcuts for
│ │ │ │ info_hashes().has_v1() and info_hashes().has_v2() calls.
│ │ │ │
[report issue]
│ │ │ │
num_files()
│ │ │ │ @@ -590,21 +590,21 @@
│ │ │ │
│ │ │ │
piece_size()
│ │ │ │
│ │ │ │ int piece_size (piece_index_t index) const;
│ │ │ │
│ │ │ │
returns the piece size of file with index. This will be the same as piece_length(),
│ │ │ │ except for the last piece, which may be shorter.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
hash_for_piece_ptr() hash_for_piece()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
hash_for_piece() hash_for_piece_ptr()
│ │ │ │
│ │ │ │ -char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │ +char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │
│ │ │ │
hash_for_piece() takes a piece-index and returns the 20-bytes
│ │ │ │ sha1-hash for that piece and info_hash() returns the 20-bytes
│ │ │ │ sha1-hash for the info-section of the torrent file.
│ │ │ │ hash_for_piece_ptr() returns a pointer to the 20 byte sha1 digest
│ │ │ │ for the piece. Note that the string is not 0-terminated.
│ │ │ │
[report issue]
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -7,35 +7,35 @@
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │ o _e_n_u_m_ _t_y_p_e___t
│ │ │ │ │ * _l_o_a_d___t_o_r_r_e_n_t___l_i_m_i_t_s
│ │ │ │ │ * _t_o_r_r_e_n_t___i_n_f_o
│ │ │ │ │ o _t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │ o _~_t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │ - o _o_r_i_g___f_i_l_e_s_(_)_ _f_i_l_e_s_(_)
│ │ │ │ │ + o _f_i_l_e_s_(_)_ _o_r_i_g___f_i_l_e_s_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ o _r_e_m_a_p___f_i_l_e_s_(_)
│ │ │ │ │ - o _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ - o _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)_ _c_o_l_l_e_c_t_i_o_n_s_(_)
│ │ │ │ │ - o _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ + o _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ + o _c_o_l_l_e_c_t_i_o_n_s_(_)_ _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)
│ │ │ │ │ + o _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)
│ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ o _n_u_m___p_i_e_c_e_s_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │ - o _p_i_e_c_e___r_a_n_g_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)_ _e_n_d___p_i_e_c_e_(_)
│ │ │ │ │ + o _p_i_e_c_e___r_a_n_g_e_(_)_ _e_n_d___p_i_e_c_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)
│ │ │ │ │ o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ - o _v_1_(_)_ _v_2_(_)
│ │ │ │ │ + o _v_2_(_)_ _v_1_(_)
│ │ │ │ │ o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │ o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │ o _m_a_p___f_i_l_e_(_)
│ │ │ │ │ o _s_s_l___c_e_r_t_(_)
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ o _p_r_i_v_(_)
│ │ │ │ │ o _i_s___i_2_p_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ - o _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e_(_)
│ │ │ │ │ + o _h_a_s_h___f_o_r___p_i_e_c_e_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)
│ │ │ │ │ o _n_a_m_e_(_)
│ │ │ │ │ o _c_r_e_a_t_i_o_n___d_a_t_e_(_)
│ │ │ │ │ o _c_r_e_a_t_o_r_(_)
│ │ │ │ │ o _c_o_m_m_e_n_t_(_)
│ │ │ │ │ o _n_o_d_e_s_(_)
│ │ │ │ │ o _a_d_d___n_o_d_e_(_)
│ │ │ │ │ o _p_a_r_s_e___i_n_f_o___s_e_c_t_i_o_n_(_)
│ │ │ │ │ @@ -120,74 +120,74 @@
│ │ │ │ │ the max number of bdecode tokens
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ttoorrrreenntt__iinnffoo ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___i_n_f_o_._h_p_p"
│ │ │ │ │ the _t_o_r_r_e_n_t___i_n_f_o class holds the information found in a .torrent file.
│ │ │ │ │ class torrent_info
│ │ │ │ │ {
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ explicit ttoorrrreenntt__iinnffoo (span
buffer, from_span_t);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ from_span_t);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │ - file_storage const& ffiilleess () const;
│ │ │ │ │ file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │ + file_storage const& ffiilleess () const;
│ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │ void rreemmaapp__ffiilleess (file_storage const& f);
│ │ │ │ │ - std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ │ void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ + std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ - std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ + std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ + void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ + , std::string const& ext_auth = std::string()
│ │ │ │ │ + , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& extern_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ - void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ - , std::string const& ext_auth = std::string()
│ │ │ │ │ - , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ - int nnuumm__ppiieecceess () const;
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ + int nnuumm__ppiieecceess () const;
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ - index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ - sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ + index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ - bool vv22 () const;
│ │ │ │ │ + sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ bool vv11 () const;
│ │ │ │ │ + bool vv22 () const;
│ │ │ │ │ int nnuumm__ffiilleess () const;
│ │ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t const piece
│ │ │ │ │ , std::int64_t offset, int size) const;
│ │ │ │ │ peer_request mmaapp__ffiillee (file_index_t const file, std::int64_t offset, int
│ │ │ │ │ size) const;
│ │ │ │ │ string_view ssssll__cceerrtt () const;
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ bool pprriivv () const;
│ │ │ │ │ bool iiss__ii22pp () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ - char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ + char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ bool iiss__llooaaddeedd () const;
│ │ │ │ │ const std::string& nnaammee () const;
│ │ │ │ │ std::time_t ccrreeaattiioonn__ddaattee () const;
│ │ │ │ │ const std::string& ccrreeaattoorr () const;
│ │ │ │ │ const std::string& ccoommmmeenntt () const;
│ │ │ │ │ std::vector> const& nnooddeess () const;
│ │ │ │ │ void aadddd__nnooddee (std::pair const& node);
│ │ │ │ │ @@ -196,29 +196,29 @@
│ │ │ │ │ bdecode_node iinnffoo (char const* key) const;
│ │ │ │ │ span iinnffoo__sseeccttiioonn () const;
│ │ │ │ │ span ppiieeccee__llaayyeerr (file_index_t) const;
│ │ │ │ │ void ffrreeee__ppiieeccee__llaayyeerrss ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ The constructor that takes an info-hash will initialize the info-hash to the
│ │ │ │ │ given value, but leave all other fields empty. This is used internally when
│ │ │ │ │ downloading torrents without the metadata. The metadata will be created by
│ │ │ │ │ libtorrent as soon as it has been downloaded from the swarm.
│ │ │ │ │ The constructor that takes a _b_d_e_c_o_d_e___n_o_d_e will create a _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ │ from the information found in the given torrent_file. The _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ │ represents a tree node in an bencoded file. To load an ordinary .torrent file
│ │ │ │ │ @@ -241,17 +241,17 @@
│ │ │ │ │ from_span_t to disambiguate the std::string overload for string literals. There
│ │ │ │ │ is an object in the libtorrent namespace of this type called from_span.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ~~ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ │ ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │ frees all storage associated with this _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oorriigg__ffiilleess(()) ffiilleess(()) **********
│ │ │ │ │ -file_storage const& ffiilleess () const;
│ │ │ │ │ +********** ffiilleess(()) oorriigg__ffiilleess(()) **********
│ │ │ │ │ file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │ +file_storage const& ffiilleess () const;
│ │ │ │ │ The _f_i_l_e___s_t_o_r_a_g_e object contains the information on how to map the pieces to
│ │ │ │ │ files. It is separated from the _t_o_r_r_e_n_t___i_n_f_o object because when creating
│ │ │ │ │ torrents a storage object needs to be created without having a torrent file.
│ │ │ │ │ When renaming files in a storage, the storage needs to make its own copy of the
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e in order to make its mapping differ from the one in the torrent
│ │ │ │ │ file.
│ │ │ │ │ orig_files() returns the original (unmodified) file storage for this torrent.
│ │ │ │ │ @@ -284,49 +284,49 @@
│ │ │ │ │ Remaps the file storage to a new file layout. This can be used to, for
│ │ │ │ │ instance, download all data in a torrent to a single file, or to a number of
│ │ │ │ │ fixed size sector aligned files, regardless of the number and sizes of the
│ │ │ │ │ files in the torrent.
│ │ │ │ │ The new specified file_storage must have the exact same size as the current
│ │ │ │ │ one.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** cclleeaarr__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ -std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ +********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ │ void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ add_tracker() adds a tracker to the announce-list. The tier determines the
│ │ │ │ │ order in which the trackers are to be tried. The trackers() function will
│ │ │ │ │ return a sorted vector of _a_n_n_o_u_n_c_e___e_n_t_r_y. Each announce _e_n_t_r_y contains a
│ │ │ │ │ string, which is the tracker url, and a tier index. The tier index is the high-
│ │ │ │ │ level priority. No matter which trackers that works or not, the ones with lower
│ │ │ │ │ tier will always be tried before the one with higher tier number. For more
│ │ │ │ │ information, see _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ trackers() returns all entries from announce-list.
│ │ │ │ │ clear_trackers() removes all trackers from announce-list.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssiimmiillaarr__ttoorrrreennttss(()) ccoolllleeccttiioonnss(()) **********
│ │ │ │ │ -std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ +********** ccoolllleeccttiioonnss(()) ssiimmiillaarr__ttoorrrreennttss(()) **********
│ │ │ │ │ std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ +std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ These two functions are related to _B_E_P_ _3_8 (mutable torrents). The vectors
│ │ │ │ │ returned from these correspond to the "similar" and "collections" keys in the
│ │ │ │ │ .torrent file. Both info-hashes and collections from within the info-dict and
│ │ │ │ │ from outside of it are included.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__wweebb__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ +********** sseett__wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) wweebb__sseeeeddss(()) **********
│ │ │ │ │ std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ +void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ + , std::string const& ext_auth = std::string()
│ │ │ │ │ + , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& extern_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ -void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ - , std::string const& ext_auth = std::string()
│ │ │ │ │ - , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │ web_seeds() returns all url seeds and http seeds in the torrent. Each _e_n_t_r_y is
│ │ │ │ │ a web_seed_entry and may refer to either a url seed or http seed.
│ │ │ │ │ add_url_seed() and add_http_seed() adds one url to the list of url/http seeds.
│ │ │ │ │ set_web_seeds() replaces all web seeds with the ones specified in the seeds
│ │ │ │ │ vector.
│ │ │ │ │ The extern_auth argument can be used for other authorization schemes than basic
│ │ │ │ │ HTTP authorization. If set, it will override any username and password found in
│ │ │ │ │ @@ -340,46 +340,46 @@
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ total_size() returns the total number of bytes the torrent-file represents.
│ │ │ │ │ Note that this is the number of pieces times the piece size (modulo the last
│ │ │ │ │ piece possibly being smaller). With pad files, the total size will be larger
│ │ │ │ │ than the sum of all (regular) file sizes.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnuumm__ppiieecceess(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ -int nnuumm__ppiieecceess () const;
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +int nnuumm__ppiieecceess () const;
│ │ │ │ │ piece_length() and num_pieces() returns the number of byte for each piece and
│ │ │ │ │ the total number of pieces, respectively. The difference between piece_size()
│ │ │ │ │ and piece_length() is that piece_size() takes the piece index as argument and
│ │ │ │ │ gives you the exact size of that piece. It will always be the same as
│ │ │ │ │ piece_length() except in the case of the last piece, which may be smaller.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bblloocckkss__ppeerr__ppiieeccee(()) **********
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ returns the number of blocks there are in the typical piece. There may be fewer
│ │ │ │ │ in the last piece)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__rraannggee(()) llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) **********
│ │ │ │ │ +********** ppiieeccee__rraannggee(()) eenndd__ppiieeccee(()) llaasstt__ppiieeccee(()) **********
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ -index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ +index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ last_piece() returns the index to the last piece in the torrent and end_piece()
│ │ │ │ │ returns the index to the one-past-end piece in the torrent piece_range()
│ │ │ │ │ returns an implementation-defined type that can be used as the container in a
│ │ │ │ │ range-for loop. Where the values are the indices of all pieces in the
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │ -sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ +sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ returns the info-hash of the torrent. For BitTorrent v2 support, use
│ │ │ │ │ info_hashes() to get an object that may hold both a v1 and v2 info-hash
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** vv11(()) vv22(()) **********
│ │ │ │ │ -bool vv22 () const;
│ │ │ │ │ +********** vv22(()) vv11(()) **********
│ │ │ │ │ bool vv11 () const;
│ │ │ │ │ +bool vv22 () const;
│ │ │ │ │ returns whether this torrent has v1 and/or v2 metadata, respectively. Hybrid
│ │ │ │ │ torrents have both. These are shortcuts for info_hashes().has_v1() and
│ │ │ │ │ info_hashes().has_v2() calls.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnuumm__ffiilleess(()) **********
│ │ │ │ │ int nnuumm__ffiilleess () const;
│ │ │ │ │ If you need index-access to files you can use the num_files() along with the
│ │ │ │ │ @@ -427,17 +427,17 @@
│ │ │ │ │ than the i2p network.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ returns the piece size of file with index. This will be the same as
│ │ │ │ │ _p_i_e_c_e___l_e_n_g_t_h_(_), except for the last piece, which may be shorter.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaasshh__ffoorr__ppiieeccee__ppttrr(()) hhaasshh__ffoorr__ppiieeccee(()) **********
│ │ │ │ │ -char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ +********** hhaasshh__ffoorr__ppiieeccee(()) hhaasshh__ffoorr__ppiieeccee__ppttrr(()) **********
│ │ │ │ │ sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ +char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ hash_for_piece() takes a piece-index and returns the 20-bytes sha1-hash for
│ │ │ │ │ that piece and info_hash() returns the 20-bytes sha1-hash for the info-section
│ │ │ │ │ of the torrent file. hash_for_piece_ptr() returns a pointer to the 20 byte sha1
│ │ │ │ │ digest for the piece. Note that the string is not 0-terminated.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnaammee(()) **********
│ │ │ │ │ const std::string& nnaammee () const;
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Trackers.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -131,18 +131,18 @@
│ │ │ │ announce_entry
│ │ │ │ Declared in "libtorrent/announce_entry.hpp"
│ │ │ │ this class holds information about one bittorrent tracker, as it
│ │ │ │ relates to a specific torrent.
│ │ │ │
│ │ │ │ struct announce_entry
│ │ │ │ {
│ │ │ │ - announce_entry ();
│ │ │ │ - ~announce_entry ();
│ │ │ │ announce_entry (announce_entry const&);
│ │ │ │ + ~announce_entry ();
│ │ │ │ explicit announce_entry (string_view u);
│ │ │ │ + announce_entry ();
│ │ │ │ announce_entry& operator= (announce_entry const&) &;
│ │ │ │
│ │ │ │ enum tracker_source
│ │ │ │ {
│ │ │ │ source_torrent,
│ │ │ │ source_client,
│ │ │ │ source_magnet_link,
│ │ │ │ @@ -159,18 +159,18 @@
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
operator=() announce_entry() ~announce_entry()
│ │ │ │
│ │ │ │ -announce_entry ();
│ │ │ │ -~announce_entry ();
│ │ │ │ announce_entry (announce_entry const&);
│ │ │ │ +~announce_entry ();
│ │ │ │ explicit announce_entry (string_view u);
│ │ │ │ +announce_entry ();
│ │ │ │ announce_entry& operator= (announce_entry const&) &;
│ │ │ │
│ │ │ │
constructs a tracker announce entry with u as the URL.
│ │ │ │
[report issue]
│ │ │ │
enum tracker_source
│ │ │ │
Declared in "libtorrent/announce_entry.hpp"
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -78,18 +78,18 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ aannnnoouunnccee__eennttrryy ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │ this class holds information about one bittorrent tracker, as it relates to a
│ │ │ │ │ specific torrent.
│ │ │ │ │ struct announce_entry
│ │ │ │ │ {
│ │ │ │ │ - aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ - ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ + ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ + aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │
│ │ │ │ │ enum tracker_source
│ │ │ │ │ {
│ │ │ │ │ source_torrent,
│ │ │ │ │ source_client,
│ │ │ │ │ source_magnet_link,
│ │ │ │ │ @@ -102,18 +102,18 @@
│ │ │ │ │ std::uint8_t ttiieerr = 0;
│ │ │ │ │ std::uint8_t ffaaiill__lliimmiitt = 0;
│ │ │ │ │ std::uint8_t source:4;
│ │ │ │ │ bool verified:1;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ooppeerraattoorr==(()) aannnnoouunnccee__eennttrryy(()) ~~aannnnoouunnccee__eennttrryy(()) **********
│ │ │ │ │ -aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ -~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ +~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ +aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ constructs a tracker announce _e_n_t_r_y with u as the URL.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eennuumm ttrraacckkeerr__ssoouurrccee **********
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ |_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Utility.html
│ │ │ │ @@ -32,37 +32,37 @@
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │
│ │ │ │ @@ -71,24 +71,24 @@
│ │ │ │
Declared in "libtorrent/bitfield.hpp"
│ │ │ │
The bitfield type stores any number of bits as a bitfield
│ │ │ │ in a heap allocated array.
│ │ │ │
│ │ │ │ struct bitfield
│ │ │ │ {
│ │ │ │ bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ - bitfield (int bits, bool val);
│ │ │ │ + explicit bitfield (int bits);
│ │ │ │ bitfield (char const* b, int bits);
│ │ │ │ - bitfield () noexcept = default;
│ │ │ │ bitfield (bitfield const& rhs);
│ │ │ │ - explicit bitfield (int bits);
│ │ │ │ + bitfield () noexcept = default;
│ │ │ │ + bitfield (int bits, bool val);
│ │ │ │ void assign (char const* b, int const bits);
│ │ │ │ - bool operator[] (int index) const noexcept;
│ │ │ │ bool get_bit (int index) const noexcept;
│ │ │ │ - void set_bit (int index) noexcept;
│ │ │ │ + bool operator[] (int index) const noexcept;
│ │ │ │ void clear_bit (int index) noexcept;
│ │ │ │ + void set_bit (int index) noexcept;
│ │ │ │ bool all_set () const noexcept;
│ │ │ │ bool none_set () const noexcept;
│ │ │ │ int size () const noexcept;
│ │ │ │ int num_words () const noexcept;
│ │ │ │ int num_bytes () const noexcept;
│ │ │ │ bool empty () const noexcept;
│ │ │ │ char* data () noexcept;
│ │ │ │ @@ -100,19 +100,19 @@
│ │ │ │ bool operator== (lt::bitfield const& rhs) const;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
bitfield()
│ │ │ │
│ │ │ │ bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ -bitfield (int bits, bool val);
│ │ │ │ +explicit bitfield (int bits);
│ │ │ │ bitfield (char const* b, int bits);
│ │ │ │ -bitfield () noexcept = default;
│ │ │ │ bitfield (bitfield const& rhs);
│ │ │ │ -explicit bitfield (int bits);
│ │ │ │ +bitfield () noexcept = default;
│ │ │ │ +bitfield (int bits, bool val);
│ │ │ │
│ │ │ │
constructs a new bitfield. The default constructor creates an empty
│ │ │ │ bitfield. bits is the size of the bitfield (specified in bits).
│ │ │ │ val is the value to initialize the bits to. If not specified
│ │ │ │ all bits are initialized to 0.
│ │ │ │
The constructor taking a pointer b and bits copies a bitfield
│ │ │ │ from the specified buffer, and bits number of bits (rounded up to
│ │ │ │ @@ -126,25 +126,25 @@
│ │ │ │
copy bitfield from buffer b of bits number of bits, rounded up to
│ │ │ │ the nearest byte boundary.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
get_bit() operator[]()
│ │ │ │
│ │ │ │ -bool operator[] (int index) const noexcept;
│ │ │ │ bool get_bit (int index) const noexcept;
│ │ │ │ +bool operator[] (int index) const noexcept;
│ │ │ │
│ │ │ │
query bit at index. Returns true if bit is 1, otherwise false.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
set_bit() clear_bit()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
clear_bit() set_bit()
│ │ │ │
│ │ │ │ -void set_bit (int index) noexcept;
│ │ │ │ void clear_bit (int index) noexcept;
│ │ │ │ +void set_bit (int index) noexcept;
│ │ │ │
│ │ │ │
set bit at index to 0 (clear_bit) or 1 (set_bit).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
all_set()
│ │ │ │
│ │ │ │ bool all_set () const noexcept;
│ │ │ │ @@ -242,41 +242,41 @@
│ │ │ │ The built-in software version of sha1-algorithm was implemented
│ │ │ │ by Steve Reid and released as public domain.
│ │ │ │ For more info, see src/sha1.cpp.
│ │ │ │
│ │ │ │ class hasher
│ │ │ │ {
│ │ │ │ hasher ();
│ │ │ │ + hasher& operator= (hasher const&) &;
│ │ │ │ hasher (hasher const&);
│ │ │ │ hasher (char const* data, int len);
│ │ │ │ explicit hasher (span<char const> data);
│ │ │ │ - hasher& operator= (hasher const&) &;
│ │ │ │ - hasher& update (char const* data, int len);
│ │ │ │ hasher& update (span<char const> data);
│ │ │ │ + hasher& update (char const* data, int len);
│ │ │ │ sha1_hash final ();
│ │ │ │ void reset ();
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
operator=() hasher()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
hasher() operator=()
│ │ │ │
│ │ │ │ +hasher& operator= (hasher const&) &;
│ │ │ │ hasher (hasher const&);
│ │ │ │ hasher (char const* data, int len);
│ │ │ │ explicit hasher (span<char const> data);
│ │ │ │ -hasher& operator= (hasher const&) &;
│ │ │ │
│ │ │ │
this is the same as default constructing followed by a call to
│ │ │ │ update(data, len).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
update()
│ │ │ │
│ │ │ │ -hasher& update (char const* data, int len);
│ │ │ │ hasher& update (span<char const> data);
│ │ │ │ +hasher& update (char const* data, int len);
│ │ │ │
│ │ │ │
append the following bytes to what is being hashed
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
final()
│ │ │ │
│ │ │ │ sha1_hash final ();
│ │ │ │ @@ -296,33 +296,33 @@
│ │ │ │
│ │ │ │
hasher256
│ │ │ │
Declared in "libtorrent/hasher.hpp"
│ │ │ │
│ │ │ │ class hasher256
│ │ │ │ {
│ │ │ │ hasher256 ();
│ │ │ │ - hasher256& operator= (hasher256 const&) &;
│ │ │ │ - explicit hasher256 (span<char const> data);
│ │ │ │ - hasher256 (hasher256 const&);
│ │ │ │ hasher256 (char const* data, int len);
│ │ │ │ + hasher256 (hasher256 const&);
│ │ │ │ + explicit hasher256 (span<char const> data);
│ │ │ │ + hasher256& operator= (hasher256 const&) &;
│ │ │ │ hasher256& update (char const* data, int len);
│ │ │ │ hasher256& update (span<char const> data);
│ │ │ │ sha256_hash final ();
│ │ │ │ void reset ();
│ │ │ │ ~hasher256 ();
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
operator=() hasher256()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
hasher256() operator=()
│ │ │ │
│ │ │ │ -hasher256& operator= (hasher256 const&) &;
│ │ │ │ -explicit hasher256 (span<char const> data);
│ │ │ │ -hasher256 (hasher256 const&);
│ │ │ │ hasher256 (char const* data, int len);
│ │ │ │ +hasher256 (hasher256 const&);
│ │ │ │ +explicit hasher256 (span<char const> data);
│ │ │ │ +hasher256& operator= (hasher256 const&) &;
│ │ │ │
│ │ │ │
this is the same as default constructing followed by a call to
│ │ │ │ update(data, len).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
update()
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,54 +3,54 @@
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _b_i_t_f_i_e_l_d
│ │ │ │ │ o _b_i_t_f_i_e_l_d_(_)
│ │ │ │ │ o _a_s_s_i_g_n_(_)
│ │ │ │ │ o _g_e_t___b_i_t_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ - o _s_e_t___b_i_t_(_)_ _c_l_e_a_r___b_i_t_(_)
│ │ │ │ │ + o _c_l_e_a_r___b_i_t_(_)_ _s_e_t___b_i_t_(_)
│ │ │ │ │ o _a_l_l___s_e_t_(_)
│ │ │ │ │ o _n_o_n_e___s_e_t_(_)
│ │ │ │ │ o _s_i_z_e_(_)
│ │ │ │ │ o _n_u_m___w_o_r_d_s_(_)
│ │ │ │ │ o _n_u_m___b_y_t_e_s_(_)
│ │ │ │ │ o _e_m_p_t_y_(_)
│ │ │ │ │ o _d_a_t_a_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _c_o_u_n_t_(_)
│ │ │ │ │ o _f_i_n_d___f_i_r_s_t___s_e_t_(_)
│ │ │ │ │ o _f_i_n_d___l_a_s_t___c_l_e_a_r_(_)
│ │ │ │ │ * _h_a_s_h_e_r
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_=_(_)_ _h_a_s_h_e_r_(_)
│ │ │ │ │ + o _h_a_s_h_e_r_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ o _u_p_d_a_t_e_(_)
│ │ │ │ │ o _f_i_n_a_l_(_)
│ │ │ │ │ o _r_e_s_e_t_(_)
│ │ │ │ │ * _h_a_s_h_e_r_2_5_6
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_=_(_)_ _h_a_s_h_e_r_2_5_6_(_)
│ │ │ │ │ + o _h_a_s_h_e_r_2_5_6_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ o _u_p_d_a_t_e_(_)
│ │ │ │ │ o _f_i_n_a_l_(_)
│ │ │ │ │ o _r_e_s_e_t_(_)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ bbiittffiieelldd ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_b_i_t_f_i_e_l_d_._h_p_p"
│ │ │ │ │ The _b_i_t_f_i_e_l_d type stores any number of bits as a _b_i_t_f_i_e_l_d in a heap allocated
│ │ │ │ │ array.
│ │ │ │ │ struct bitfield
│ │ │ │ │ {
│ │ │ │ │ bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ - bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ + explicit bbiittffiieelldd (int bits);
│ │ │ │ │ bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ - bbiittffiieelldd () noexcept = default;
│ │ │ │ │ bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ - explicit bbiittffiieelldd (int bits);
│ │ │ │ │ + bbiittffiieelldd () noexcept = default;
│ │ │ │ │ + bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ void aassssiiggnn (char const* b, int const bits);
│ │ │ │ │ - bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │ bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │ - void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ + bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │ void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ + void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ bool aallll__sseett () const noexcept;
│ │ │ │ │ bool nnoonnee__sseett () const noexcept;
│ │ │ │ │ int ssiizzee () const noexcept;
│ │ │ │ │ int nnuumm__wwoorrddss () const noexcept;
│ │ │ │ │ int nnuumm__bbyytteess () const noexcept;
│ │ │ │ │ bool eemmppttyy () const noexcept;
│ │ │ │ │ char* ddaattaa () noexcept;
│ │ │ │ │ @@ -60,39 +60,39 @@
│ │ │ │ │ int ffiinndd__ffiirrsstt__sseett () const noexcept;
│ │ │ │ │ int ffiinndd__llaasstt__cclleeaarr () const noexcept;
│ │ │ │ │ bool ooppeerraattoorr==== (lt::bitfield const& rhs) const;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bbiittffiieelldd(()) **********
│ │ │ │ │ bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ -bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ +explicit bbiittffiieelldd (int bits);
│ │ │ │ │ bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ -bbiittffiieelldd () noexcept = default;
│ │ │ │ │ bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -explicit bbiittffiieelldd (int bits);
│ │ │ │ │ +bbiittffiieelldd () noexcept = default;
│ │ │ │ │ +bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ constructs a new _b_i_t_f_i_e_l_d. The default constructor creates an empty _b_i_t_f_i_e_l_d.
│ │ │ │ │ bits is the size of the _b_i_t_f_i_e_l_d (specified in bits). val is the value to
│ │ │ │ │ initialize the bits to. If not specified all bits are initialized to 0.
│ │ │ │ │ The constructor taking a pointer b and bits copies a _b_i_t_f_i_e_l_d from the
│ │ │ │ │ specified buffer, and bits number of bits (rounded up to the nearest byte
│ │ │ │ │ boundary).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aassssiiggnn(()) **********
│ │ │ │ │ void aassssiiggnn (char const* b, int const bits);
│ │ │ │ │ copy _b_i_t_f_i_e_l_d from buffer b of bits number of bits, rounded up to the nearest
│ │ │ │ │ byte boundary.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ggeett__bbiitt(()) ooppeerraattoorr[[]](()) **********
│ │ │ │ │ -bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │ bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │ +bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │ query bit at index. Returns true if bit is 1, otherwise false.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__bbiitt(()) cclleeaarr__bbiitt(()) **********
│ │ │ │ │ -void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ +********** cclleeaarr__bbiitt(()) sseett__bbiitt(()) **********
│ │ │ │ │ void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ +void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ set bit at index to 0 (clear_bit) or 1 (set_bit).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aallll__sseett(()) **********
│ │ │ │ │ bool aallll__sseett () const noexcept;
│ │ │ │ │ returns true if all bits in the _b_i_t_f_i_e_l_d are set
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnoonnee__sseett(()) **********
│ │ │ │ │ @@ -151,35 +151,35 @@
│ │ │ │ │ If you want to reuse the _h_a_s_h_e_r object once you have created a hash, you have
│ │ │ │ │ to call reset() to reinitialize it.
│ │ │ │ │ The built-in software version of sha1-algorithm was implemented by Steve Reid
│ │ │ │ │ and released as public domain. For more info, see src/sha1.cpp.
│ │ │ │ │ class hasher
│ │ │ │ │ {
│ │ │ │ │ hhaasshheerr ();
│ │ │ │ │ + hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ hhaasshheerr (hasher const&);
│ │ │ │ │ hhaasshheerr (char const* data, int len);
│ │ │ │ │ explicit hhaasshheerr (span data);
│ │ │ │ │ - hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ - hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ hasher& uuppddaattee (span data);
│ │ │ │ │ + hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ sha1_hash ffiinnaall ();
│ │ │ │ │ void rreesseett ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr==(()) hhaasshheerr(()) **********
│ │ │ │ │ +********** hhaasshheerr(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ +hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ hhaasshheerr (hasher const&);
│ │ │ │ │ hhaasshheerr (char const* data, int len);
│ │ │ │ │ explicit hhaasshheerr (span data);
│ │ │ │ │ -hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ this is the same as default constructing followed by a call to update(data,
│ │ │ │ │ len).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** uuppddaattee(()) **********
│ │ │ │ │ -hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ hasher& uuppddaattee (span data);
│ │ │ │ │ +hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ append the following bytes to what is being hashed
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiinnaall(()) **********
│ │ │ │ │ sha1_hash ffiinnaall ();
│ │ │ │ │ returns the SHA-1 digest of the buffers previously passed to _u_p_d_a_t_e_(_) and the
│ │ │ │ │ _h_a_s_h_e_r constructor.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -189,30 +189,30 @@
│ │ │ │ │ constructed.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ hhaasshheerr225566 ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_h_a_s_h_e_r_._h_p_p"
│ │ │ │ │ class hasher256
│ │ │ │ │ {
│ │ │ │ │ hhaasshheerr225566 ();
│ │ │ │ │ - hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ - explicit hhaasshheerr225566 (span data);
│ │ │ │ │ - hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ + hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ + explicit hhaasshheerr225566 (span data);
│ │ │ │ │ + hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │ hasher256& uuppddaattee (span data);
│ │ │ │ │ sha256_hash ffiinnaall ();
│ │ │ │ │ void rreesseett ();
│ │ │ │ │ ~~hhaasshheerr225566 ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr==(()) hhaasshheerr225566(()) **********
│ │ │ │ │ -hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ -explicit hhaasshheerr225566 (span data);
│ │ │ │ │ -hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ +********** hhaasshheerr225566(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ +hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ +explicit hhaasshheerr225566 (span data);
│ │ │ │ │ +hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ this is the same as default constructing followed by a call to update(data,
│ │ │ │ │ len).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** uuppddaattee(()) **********
│ │ │ │ │ hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │ hasher256& uuppddaattee (span data);
│ │ │ │ │ append the following bytes to what is being hashed
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-ed25519.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -84,18 +84,18 @@
│ │ │ │
│ │ │ │
Verifies the signature on the given message using pk
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
ed25519_add_scalar()
│ │ │ │
Declared in "libtorrent/kademlia/ed25519.hpp"
│ │ │ │
│ │ │ │ -public_key ed25519_add_scalar (public_key const& pk
│ │ │ │ - , std::array<char, 32> const& scalar);
│ │ │ │ secret_key ed25519_add_scalar (secret_key const& sk
│ │ │ │ , std::array<char, 32> const& scalar);
│ │ │ │ +public_key ed25519_add_scalar (public_key const& pk
│ │ │ │ + , std::array<char, 32> const& scalar);
│ │ │ │
│ │ │ │
Adds a scalar to the given key pair where scalar is a 32 byte buffer
│ │ │ │ (possibly generated with ed25519_create_seed), generating a new key pair.
│ │ │ │
You can calculate the public key sum without knowing the private key and
│ │ │ │ vice versa by passing in null for the key you don't know. This is useful
│ │ │ │ when a third party (an authoritative server for example) needs to enforce
│ │ │ │ randomness on a key pair while only knowing the public key of the other
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -39,18 +39,18 @@
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_k_a_d_e_m_l_i_a_/_e_d_2_5_5_1_9_._h_p_p"
│ │ │ │ │ bool eedd2255551199__vveerriiffyy (signature const& sig
│ │ │ │ │ , span msg, public_key const& pk);
│ │ │ │ │ Verifies the signature on the given message using pk
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ eedd2255551199__aadddd__ssccaallaarr(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_k_a_d_e_m_l_i_a_/_e_d_2_5_5_1_9_._h_p_p"
│ │ │ │ │ -public_key eedd2255551199__aadddd__ssccaallaarr (public_key const& pk
│ │ │ │ │ - , std::array const& scalar);
│ │ │ │ │ secret_key eedd2255551199__aadddd__ssccaallaarr (secret_key const& sk
│ │ │ │ │ , std::array const& scalar);
│ │ │ │ │ +public_key eedd2255551199__aadddd__ssccaallaarr (public_key const& pk
│ │ │ │ │ + , std::array const& scalar);
│ │ │ │ │ Adds a scalar to the given key pair where scalar is a 32 byte buffer (possibly
│ │ │ │ │ generated withed25519_create_seed), generating a new key pair.
│ │ │ │ │ You can calculate the public key sum without knowing the private key and vice
│ │ │ │ │ versa by passing in null for the key you don't know. This is useful when a
│ │ │ │ │ third party (an authoritative server for example) needs to enforce randomness
│ │ │ │ │ on a key pair while only knowing the public key of the other side.
│ │ │ │ │ Warning: the last bit of the scalar is ignored - if comparing scalars make sure
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -25,33 +25,33 @@
│ │ │ │
│ │ │ │
Session
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
Torrent Info
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Core
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -97,16 +97,16 @@
│ │ │ │
│ │ │ │
│ │ │ │
Settings
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
DHT
│ │ │ │
│ │ │ │
│ │ │ │ @@ -115,16 +115,16 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Resume Data
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Error Codes
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,29 +3,29 @@
│ │ │ │ │ ************ rreeffeerreennccee ddooccuummeennttaattiioonn ************
│ │ │ │ │ _s_i_n_g_l_e_-_p_a_g_e_ _v_e_r_s_i_o_n
│ │ │ │ │ Session
│ │ │ │ │ _s_e_s_s_i_o_n___p_a_r_a_m_s
│ │ │ │ │ _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │ _s_e_s_s_i_o_n
│ │ │ │ │ _s_e_s_s_i_o_n___h_a_n_d_l_e
│ │ │ │ │ -_w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ -_w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)
│ │ │ │ │ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ +_w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)
│ │ │ │ │ +_w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ Torrent Info
│ │ │ │ │ _w_e_b___s_e_e_d___e_n_t_r_y
│ │ │ │ │ _l_o_a_d___t_o_r_r_e_n_t___l_i_m_i_t_s
│ │ │ │ │ _t_o_r_r_e_n_t___i_n_f_o
│ │ │ │ │ Core
│ │ │ │ │ _p_e_e_r___i_n_f_o
│ │ │ │ │ _i_n_f_o___h_a_s_h___t
│ │ │ │ │ _p_i_e_c_e___b_l_o_c_k
│ │ │ │ │ _p_e_e_r___r_e_q_u_e_s_t
│ │ │ │ │ -_l_o_a_d___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ _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_(_)
│ │ │ │ │ _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ _p_a_r_s_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ _t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_)
│ │ │ │ │ _t_r_u_n_c_a_t_e___f_i_l_e_s_(_)
│ │ │ │ │ _v_e_r_s_i_o_n_(_)
│ │ │ │ │ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ │ @@ -59,30 +59,30 @@
│ │ │ │ │ _a_n_n_o_u_n_c_e___i_n_f_o_h_a_s_h
│ │ │ │ │ _a_n_n_o_u_n_c_e___e_n_d_p_o_i_n_t
│ │ │ │ │ _a_n_n_o_u_n_c_e___e_n_t_r_y
│ │ │ │ │ Settings
│ │ │ │ │ _o_v_e_r_v_i_e_w
│ │ │ │ │ _s_e_t_t_i_n_g_s___p_a_c_k
│ │ │ │ │ _g_e_n_e_r_a_t_e___f_i_n_g_e_r_p_r_i_n_t_(_)
│ │ │ │ │ -_h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)
│ │ │ │ │ _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)
│ │ │ │ │ +_h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)
│ │ │ │ │ _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)
│ │ │ │ │ _s_e_t_t_i_n_g___b_y___n_a_m_e_(_)
│ │ │ │ │ _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ DHT
│ │ │ │ │ _d_h_t___s_t_a_t_e
│ │ │ │ │ _d_h_t___s_t_o_r_a_g_e___c_o_u_n_t_e_r_s
│ │ │ │ │ _d_h_t___s_t_o_r_a_g_e___i_n_t_e_r_f_a_c_e
│ │ │ │ │ _s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ │ _d_h_t___d_e_f_a_u_l_t___s_t_o_r_a_g_e___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │ _a_n_n_o_u_n_c_e___f_l_a_g_s___t
│ │ │ │ │ Resume Data
│ │ │ │ │ _r_e_a_d___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ -_w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a___b_u_f_(_)
│ │ │ │ │ +_w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_)
│ │ │ │ │ _w_r_i_t_e___t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ │ Error Codes
│ │ │ │ │ _s_t_o_r_a_g_e___e_r_r_o_r
│ │ │ │ │ _l_i_b_t_o_r_r_e_n_t___c_a_t_e_g_o_r_y_(_)
│ │ │ │ │ _h_t_t_p___c_a_t_e_g_o_r_y_(_)
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/single-page-ref.html
│ │ │ │ @@ -55,15 +55,15 @@
│ │ │ │
- enum error_code_enum
│ │ │ │
- session_params
│ │ │ │
│ │ │ │
- session_proxy
│ │ │ │
│ │ │ │
- session
│ │ │ │
│ │ │ │ -
- write_session_params_buf() write_session_params() read_session_params()
│ │ │ │ +
- read_session_params() write_session_params() write_session_params_buf()
│ │ │ │
- web_seed_entry
│ │ │ │
│ │ │ │
- load_torrent_limits
│ │ │ │
- torrent_info
│ │ │ │
│ │ │ │
- piece_block
│ │ │ │
- peer_request
│ │ │ │
│ │ │ │ -
- load_torrent_parsed() load_torrent_buffer() load_torrent_file()
│ │ │ │ +
- load_torrent_parsed() load_torrent_file() load_torrent_buffer()
│ │ │ │
- make_magnet_uri()
│ │ │ │
- parse_magnet_uri()
│ │ │ │
- torrent_peer_equal()
│ │ │ │
- truncate_files()
│ │ │ │
- version()
│ │ │ │
- enum socket_type_t
│ │ │ │
- enum protocol_version
│ │ │ │ @@ -202,37 +202,37 @@
│ │ │ │
- on_tick()
│ │ │ │
- get_unchoke_priority()
│ │ │ │
- load_state()
│ │ │ │
│ │ │ │
│ │ │ │
- torrent_plugin
│ │ │ │
│ │ │ │
- peer_plugin
│ │ │ │
│ │ │ │
- crypto_plugin
│ │ │ │ @@ -254,25 +254,25 @@
│ │ │ │
- end_file()
│ │ │ │
- file_range()
│ │ │ │
- total_size()
│ │ │ │
- set_num_pieces() num_pieces()
│ │ │ │
- end_piece()
│ │ │ │
- last_piece()
│ │ │ │
- piece_range()
│ │ │ │ -
- piece_length() set_piece_length()
│ │ │ │ +
- set_piece_length() piece_length()
│ │ │ │
- piece_size()
│ │ │ │
- piece_size2()
│ │ │ │
- blocks_in_piece2()
│ │ │ │
- blocks_per_piece()
│ │ │ │
- set_name() name()
│ │ │ │
- swap()
│ │ │ │
- canonicalize()
│ │ │ │ -
- file_offset() mtime() hash() pad_file_at() symlink() file_path() file_size() root_ptr() root() file_name()
│ │ │ │ +
- file_name() hash() root_ptr() file_path() file_offset() mtime() pad_file_at() root() file_size() symlink()
│ │ │ │
- file_num_pieces() file_num_blocks() file_piece_range()
│ │ │ │ -
- file_first_piece_node() file_first_block_node()
│ │ │ │ +
- file_first_block_node() file_first_piece_node()
│ │ │ │
- file_path_hash()
│ │ │ │
- all_path_hashes()
│ │ │ │
- file_flags()
│ │ │ │
- file_absolute_path()
│ │ │ │
- file_index_at_piece() file_index_at_offset()
│ │ │ │
- file_index_for_root()
│ │ │ │
- piece_index_at_file()
│ │ │ │ @@ -286,22 +286,22 @@
│ │ │ │
- posix_disk_io_constructor()
│ │ │ │
- default_disk_io_constructor()
│ │ │ │
- enum storage_mode_t
│ │ │ │
- enum status_t
│ │ │ │
- enum move_flags_t
│ │ │ │
- client_data_t
│ │ │ │
│ │ │ │
- add_torrent_params
│ │ │ │
- peer_class_info
│ │ │ │
- peer_class_type_filter
│ │ │ │
│ │ │ │
- block_info
│ │ │ │
│ │ │ │
- hash_value()
│ │ │ │ @@ -461,15 +461,15 @@
│ │ │ │
- piece_finished_alert
│ │ │ │
- request_dropped_alert
│ │ │ │
- block_timeout_alert
│ │ │ │
- block_finished_alert
│ │ │ │
- block_downloading_alert
│ │ │ │
- unwanted_block_alert
│ │ │ │
- storage_moved_alert
│ │ │ │
│ │ │ │
- storage_moved_failed_alert
│ │ │ │
│ │ │ │
- torrent_deleted_alert
│ │ │ │ @@ -593,15 +593,15 @@
│ │ │ │
- tracker_list_alert
│ │ │ │
- alert_cast()
│ │ │ │
- operation_name()
│ │ │ │
- enum operation_t
│ │ │ │
- alert_category_t
│ │ │ │
- int
│ │ │ │
- counters
│ │ │ │
│ │ │ │
- stats_metric
│ │ │ │
- session_stats_metrics()
│ │ │ │
- find_metric_idx()
│ │ │ │
- enum metric_type_t
│ │ │ │
- ip_filter
│ │ │ │ @@ -620,15 +620,15 @@
│ │ │ │
│ │ │ │
- entry
│ │ │ │
│ │ │ │ @@ -658,88 +658,88 @@
│ │ │ │
│ │ │ │
│ │ │ │
- add_files()
│ │ │ │
- set_piece_hashes()
│ │ │ │
- bitfield
│ │ │ │
│ │ │ │
- hasher
│ │ │ │
│ │ │ │
- hasher256
│ │ │ │
│ │ │ │
- torrent_status
│ │ │ │
│ │ │ │
- announce_infohash
│ │ │ │
- announce_endpoint
│ │ │ │
- announce_entry
│ │ │ │
│ │ │ │
- settings_pack
│ │ │ │
│ │ │ │
- generate_fingerprint()
│ │ │ │ -
- min_memory_usage() high_performance_seed()
│ │ │ │ -
- setting_by_name() name_for_setting()
│ │ │ │ +
- high_performance_seed() min_memory_usage()
│ │ │ │ +
- name_for_setting() setting_by_name()
│ │ │ │
- default_settings()
│ │ │ │
- bdecode_node
│ │ │ │ @@ -766,15 +766,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
- sign_mutable_item()
│ │ │ │
- dht_default_storage_constructor()
│ │ │ │
- announce_flags_t
│ │ │ │
- read_resume_data()
│ │ │ │
- write_resume_data_buf() write_resume_data()
│ │ │ │ -
- write_torrent_file() write_torrent_file_buf()
│ │ │ │ +
- write_torrent_file_buf() write_torrent_file()
│ │ │ │
- write_torrent_flags_t
│ │ │ │
- ed25519_create_seed()
│ │ │ │
- ed25519_create_keypair()
│ │ │ │
- ed25519_sign()
│ │ │ │
- ed25519_verify()
│ │ │ │
- ed25519_add_scalar()
│ │ │ │
- ed25519_key_exchange()
│ │ │ │ @@ -786,16 +786,16 @@
│ │ │ │
used by storage to return errors
│ │ │ │ also includes which underlying file the
│ │ │ │ error happened on
│ │ │ │
│ │ │ │ struct storage_error
│ │ │ │ {
│ │ │ │ explicit operator bool () const;
│ │ │ │ - file_index_t file () const;
│ │ │ │ void file (file_index_t f);
│ │ │ │ + file_index_t file () const;
│ │ │ │
│ │ │ │ error_code ec;
│ │ │ │ operation_t operation;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
bool()
│ │ │ │ @@ -804,16 +804,16 @@
│ │ │ │
│ │ │ │
explicitly converts to true if this object represents an error, and
│ │ │ │ false if it does not.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
file()
│ │ │ │
│ │ │ │ -file_index_t file () const;
│ │ │ │ void file (file_index_t f);
│ │ │ │ +file_index_t file () const;
│ │ │ │
│ │ │ │
set and query the index (in the torrent) of the file this error
│ │ │ │ occurred on. This may also have special values defined in
│ │ │ │ torrent_status.
│ │ │ │
[report issue]
│ │ │ │ - ec
│ │ │ │ - the error that occurred
│ │ │ │ @@ -2130,49 +2130,49 @@
│ │ │ │ session_params
│ │ │ │ Declared in "libtorrent/session_params.hpp"
│ │ │ │ The session_params is a parameters pack for configuring the session
│ │ │ │ before it's started.
│ │ │ │
│ │ │ │ struct session_params
│ │ │ │ {
│ │ │ │ - session_params (settings_pack const& sp);
│ │ │ │ session_params ();
│ │ │ │ + session_params (settings_pack const& sp);
│ │ │ │ session_params (settings_pack&& sp);
│ │ │ │ - session_params (settings_pack const& sp
│ │ │ │ - , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ session_params (settings_pack&& sp
│ │ │ │ , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ + session_params (settings_pack const& sp
│ │ │ │ + , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │
│ │ │ │ settings_pack settings;
│ │ │ │ std::vector<std::shared_ptr<plugin>> extensions;
│ │ │ │ dht::dht_state dht_state;
│ │ │ │ dht::dht_storage_constructor_type dht_storage_constructor;
│ │ │ │ disk_io_constructor_type disk_io_constructor;
│ │ │ │ std::map<std::string, std::string> ext_state;
│ │ │ │ libtorrent::ip_filter ip_filter;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
session_params()
│ │ │ │
│ │ │ │ -session_params (settings_pack const& sp);
│ │ │ │ session_params ();
│ │ │ │ +session_params (settings_pack const& sp);
│ │ │ │ session_params (settings_pack&& sp);
│ │ │ │
│ │ │ │
This constructor can be used to start with the default plugins
│ │ │ │ (ut_metadata, ut_pex and smart_ban). Pass a settings_pack to set the
│ │ │ │ initial settings when the session starts.
│ │ │ │
[report issue]
│ │ │ │
session_params()
│ │ │ │
│ │ │ │ -session_params (settings_pack const& sp
│ │ │ │ - , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ session_params (settings_pack&& sp
│ │ │ │ , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ +session_params (settings_pack const& sp
│ │ │ │ + , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │
│ │ │ │
This constructor helps to configure the set of initial plugins
│ │ │ │ to be added to the session before it's started.
│ │ │ │
[report issue]
│ │ │ │ - settings
│ │ │ │ - The settings to configure the session with
│ │ │ │
│ │ │ │ @@ -2216,31 +2216,31 @@
│ │ │ │
session_proxy destructor will block however, until the underlying
session
│ │ │ │ is done shutting down.
│ │ │ │
│ │ │ │ struct session_proxy
│ │ │ │ {
│ │ │ │ session_proxy (session_proxy&&) noexcept;
│ │ │ │ session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ - session_proxy& operator= (session_proxy const&) &;
│ │ │ │ - ~session_proxy ();
│ │ │ │ session_proxy ();
│ │ │ │ session_proxy (session_proxy const&);
│ │ │ │ + session_proxy& operator= (session_proxy const&) &;
│ │ │ │ + ~session_proxy ();
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
~session_proxy() operator=() session_proxy()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
operator=() ~session_proxy() session_proxy()
│ │ │ │
│ │ │ │ session_proxy (session_proxy&&) noexcept;
│ │ │ │ session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ -session_proxy& operator= (session_proxy const&) &;
│ │ │ │ -~session_proxy ();
│ │ │ │ session_proxy ();
│ │ │ │ session_proxy (session_proxy const&);
│ │ │ │ +session_proxy& operator= (session_proxy const&) &;
│ │ │ │ +~session_proxy ();
│ │ │ │
│ │ │ │
default constructor, does not refer to any session
│ │ │ │ implementation object.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
│ │ │ │
session
│ │ │ │ @@ -2254,52 +2254,52 @@
│ │ │ │
session_handle::apply_settings() member function. To change one or more
│ │ │ │ configuration options, create a
settings_pack. object and fill it with
│ │ │ │ the settings to be set and pass it in to
session::apply_settings().
│ │ │ │
see apply_settings().
│ │ │ │
│ │ │ │ struct session : session_handle
│ │ │ │ {
│ │ │ │ - session (session_params const& params, session_flags_t flags);
│ │ │ │ - session ();
│ │ │ │ - session (session_params&& params, session_flags_t flags);
│ │ │ │ explicit session (session_params const& params);
│ │ │ │ + session (session_params&& params, session_flags_t flags);
│ │ │ │ + session (session_params const& params, session_flags_t flags);
│ │ │ │ explicit session (session_params&& params);
│ │ │ │ - session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ - session (session_params&& params, io_context& ios);
│ │ │ │ + session ();
│ │ │ │ session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ + session (session_params&& params, io_context& ios);
│ │ │ │ session (session_params const& params, io_context& ios);
│ │ │ │ + session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ ~session ();
│ │ │ │ session_proxy abort ();
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
session()
│ │ │ │
│ │ │ │ -session (session_params const& params, session_flags_t flags);
│ │ │ │ -session ();
│ │ │ │ -session (session_params&& params, session_flags_t flags);
│ │ │ │ explicit session (session_params const& params);
│ │ │ │ +session (session_params&& params, session_flags_t flags);
│ │ │ │ +session (session_params const& params, session_flags_t flags);
│ │ │ │ explicit session (session_params&& params);
│ │ │ │ +session ();
│ │ │ │
│ │ │ │
Constructs the session objects which acts as the container of torrents.
│ │ │ │ In order to avoid a race condition between starting the session and
│ │ │ │ configuring it, you can pass in a session_params object. Its settings
│ │ │ │ will take effect before the session starts up.
│ │ │ │
The overloads taking flags can be used to start a session in
│ │ │ │ paused mode (by passing in session::paused). Note that
│ │ │ │ add_default_plugins do not have an affect on constructors that
│ │ │ │ take a session_params object. It already contains the plugins to use.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
session()
│ │ │ │
│ │ │ │ -session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ -session (session_params&& params, io_context& ios);
│ │ │ │ session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +session (session_params&& params, io_context& ios);
│ │ │ │ session (session_params const& params, io_context& ios);
│ │ │ │ +session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │
│ │ │ │
Overload of the constructor that takes an external io_context to run
│ │ │ │ the session object on. This is primarily useful for tests that may want
│ │ │ │ to run multiple sessions on a single io_context, or low resource
│ │ │ │ systems where additional threads are expensive and sharing an
│ │ │ │ io_context with other events is fine.
│ │ │ │
│ │ │ │ @@ -2362,69 +2362,69 @@
│ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ std::vector<torrent_status>
get_torrent_status (
│ │ │ │ std::function<bool(torrent_status const&)> const& pred
│ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ void
post_torrent_updates (status_flags_t flags = status_flags_t::all());
│ │ │ │ void
post_session_stats ();
│ │ │ │ void
post_dht_stats ();
│ │ │ │ - void
set_dht_state (dht::dht_state const& st);
│ │ │ │ void
set_dht_state (dht::dht_state&& st);
│ │ │ │ + void
set_dht_state (dht::dht_state const& st);
│ │ │ │ torrent_handle
find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ std::vector<torrent_handle>
get_torrents () const;
│ │ │ │ - torrent_handle
add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │ - void
async_add_torrent (add_torrent_params&& params);
│ │ │ │ + torrent_handle
add_torrent (add_torrent_params&& params);
│ │ │ │ torrent_handle
add_torrent (add_torrent_params const& params);
│ │ │ │ + void
async_add_torrent (add_torrent_params&& params);
│ │ │ │ + torrent_handle
add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │ torrent_handle
add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ void
async_add_torrent (add_torrent_params const& params);
│ │ │ │ - torrent_handle
add_torrent (add_torrent_params&& params);
│ │ │ │ void
pause ();
│ │ │ │ - bool
is_paused () const;
│ │ │ │ void
resume ();
│ │ │ │ + bool
is_paused () const;
│ │ │ │ bool
is_dht_running () const;
│ │ │ │ void
set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ │ void
add_dht_node (std::pair<std::string, int> const& node);
│ │ │ │ void
dht_get_item (sha1_hash const& target);
│ │ │ │ void
dht_get_item (std::array<char, 32> key
│ │ │ │ , std::string salt = std::string());
│ │ │ │ sha1_hash
dht_put_item (entry data);
│ │ │ │ void
dht_put_item (std::array<char, 32> key
│ │ │ │ , std::function<void(entry&, std::array<char, 64>&
│ │ │ │ , std::int64_t&, std::string const&)> cb
│ │ │ │ , std::string salt = std::string());
│ │ │ │ - void
dht_get_peers (sha1_hash const& info_hash);
│ │ │ │ void
dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │ + void
dht_get_peers (sha1_hash const& info_hash);
│ │ │ │ void
dht_live_nodes (sha1_hash const& nid);
│ │ │ │ void
dht_sample_infohashes (udp::endpoint const& ep, sha1_hash const& target);
│ │ │ │ void
dht_direct_request (udp::endpoint const& ep, entry const& e, client_data_t userdata = {});
│ │ │ │ - void
add_extension (std::shared_ptr<plugin> ext);
│ │ │ │ void
add_extension (std::function<std::shared_ptr<torrent_plugin>(
│ │ │ │ torrent_handle const&, client_data_t)> ext);
│ │ │ │ + void
add_extension (std::shared_ptr<plugin> ext);
│ │ │ │ ip_filter
get_ip_filter () const;
│ │ │ │ void
set_ip_filter (ip_filter f);
│ │ │ │ void
set_port_filter (port_filter const& f);
│ │ │ │ + unsigned short
listen_port () const;
│ │ │ │ bool
is_listening () const;
│ │ │ │ unsigned short
ssl_listen_port () const;
│ │ │ │ - unsigned short
listen_port () const;
│ │ │ │ - void
set_peer_class_filter (ip_filter const& f);
│ │ │ │ ip_filter
get_peer_class_filter () const;
│ │ │ │ - void
set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │ + void
set_peer_class_filter (ip_filter const& f);
│ │ │ │ peer_class_type_filter
get_peer_class_type_filter () const;
│ │ │ │ + void
set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │ peer_class_t
create_peer_class (char const* name);
│ │ │ │ void
delete_peer_class (peer_class_t cid);
│ │ │ │ peer_class_info
get_peer_class (peer_class_t cid) const;
│ │ │ │ void
set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ void
remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ │ void
apply_settings (settings_pack const&);
│ │ │ │ - settings_pack
get_settings () const;
│ │ │ │ void
apply_settings (settings_pack&&);
│ │ │ │ + settings_pack
get_settings () const;
│ │ │ │ alert*
wait_for_alert (time_duration max_wait);
│ │ │ │ void
pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ void
set_alert_notify (std::function<void()> const& fun);
│ │ │ │ - void
delete_port_mapping (port_mapping_t handle);
│ │ │ │ std::vector<port_mapping_t>
add_port_mapping (portmap_protocol t, int external_port, int local_port);
│ │ │ │ + void
delete_port_mapping (port_mapping_t handle);
│ │ │ │ void
reopen_network_sockets (reopen_network_flags_t options = reopen_map_ports);
│ │ │ │ std::shared_ptr<aux::session_impl>
native_handle () const;
│ │ │ │
│ │ │ │ static constexpr save_state_flags_t
save_settings = 0_bit;
│ │ │ │ static constexpr save_state_flags_t
save_dht_state = 2_bit;
│ │ │ │ static constexpr save_state_flags_t
save_extension_state = 11_bit;
│ │ │ │ static constexpr save_state_flags_t
save_ip_filter = 12_bit;
│ │ │ │ @@ -2537,24 +2537,24 @@
│ │ │ │ void
post_dht_stats ();
│ │ │ │
│ │ │ │
This will cause a dht_stats_alert to be posted.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
set_dht_state()
│ │ │ │
│ │ │ │ -void set_dht_state (dht::dht_state const& st);
│ │ │ │ void set_dht_state (dht::dht_state&& st);
│ │ │ │ +void set_dht_state (dht::dht_state const& st);
│ │ │ │
│ │ │ │
set the DHT state for the session. This will be taken into account the
│ │ │ │ next time the DHT is started, as if it had been passed in via the
│ │ │ │ session_params on startup.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
get_torrents() find_torrent()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
find_torrent() get_torrents()
│ │ │ │
│ │ │ │ torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ std::vector<torrent_handle> get_torrents () const;
│ │ │ │
│ │ │ │
find_torrent() looks for a torrent with the given info-hash. In
│ │ │ │ case there is such a torrent in the session, a torrent_handle to that
│ │ │ │ torrent is returned. In case the torrent cannot be found, an invalid
│ │ │ │ @@ -2564,20 +2564,20 @@
│ │ │ │
get_torrents() returns a vector of torrent_handles to all the
│ │ │ │ torrents currently in the session.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_torrent() async_add_torrent()
│ │ │ │
│ │ │ │ -torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │ -void async_add_torrent (add_torrent_params&& params);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ +void async_add_torrent (add_torrent_params&& params);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │ torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ void async_add_torrent (add_torrent_params const& params);
│ │ │ │ -torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │
│ │ │ │
You add torrents through the add_torrent() function where you give an
│ │ │ │ object with all the parameters. The add_torrent() overloads will block
│ │ │ │ until the torrent has been added (or failed to be added) and returns
│ │ │ │ an error code and a torrent_handle. In order to add torrents more
│ │ │ │ efficiently, consider using async_add_torrent() which returns
│ │ │ │ immediately, without waiting for the torrent to add. Notification of
│ │ │ │ @@ -2597,23 +2597,23 @@
│ │ │ │ want to control are torrent_flags::paused and
│ │ │ │ torrent_flags::auto_managed. In order to add a magnet link that will
│ │ │ │ just download the metadata, but no payload, set the
│ │ │ │ torrent_flags::upload_mode flag.
│ │ │ │
Special consideration has to be taken when adding hybrid torrents
│ │ │ │ (i.e. torrents that are BitTorrent v2 torrents that are backwards
│ │ │ │ compatible with v1). For more details, see BitTorrent v2 torrents.
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
pause() resume() is_paused()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
is_paused() pause() resume()
│ │ │ │
│ │ │ │ void pause ();
│ │ │ │ -bool is_paused () const;
│ │ │ │ void resume ();
│ │ │ │ +bool is_paused () const;
│ │ │ │
│ │ │ │
Pausing the session has the same effect as pausing every torrent in
│ │ │ │ it, except that torrents will not be resumed by the auto-manage
│ │ │ │ mechanism. Resuming will restore the torrents to their previous paused
│ │ │ │ state. i.e. the session pause state is separate from the torrent pause
│ │ │ │ state. A torrent is inactive if it is paused or if the session is
│ │ │ │ paused.
│ │ │ │ @@ -2721,21 +2721,21 @@
│ │ │ │ with the function object's context and make the function entirely
│ │ │ │ self-contained. The only reason data blob's value is computed
│ │ │ │ via a function instead of just passing in the new value is to avoid
│ │ │ │ race conditions. If you want to
update the value in the DHT, you
│ │ │ │ must first retrieve it, then modify it, then write it back. The way
│ │ │ │ the DHT works, it is natural to always do a lookup before storing and
│ │ │ │ calling the callback in between is convenient.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
dht_get_peers() dht_announce()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
dht_announce() dht_get_peers()
│ │ │ │
│ │ │ │ -void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │ void dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │ +void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │
│ │ │ │
dht_get_peers() will issue a DHT get_peer request to the DHT for the
│ │ │ │ specified info-hash. The response (the peers) will be posted back in a
│ │ │ │ dht_get_peers_reply_alert.
│ │ │ │
dht_announce() will issue a DHT announce request to the DHT to the
│ │ │ │ specified info-hash, advertising the specified port. If the port is
│ │ │ │ left at its default, 0, the port will be implied by the DHT message's
│ │ │ │ @@ -2779,17 +2779,17 @@
│ │ │ │ with the response (if any) and the userdata pointer passed in here.
│ │ │ │ Since this alert is a response to an explicit call, it will always be
│ │ │ │ posted, regardless of the alert mask.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_extension()
│ │ │ │
│ │ │ │ -void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │ void add_extension (std::function<std::shared_ptr<torrent_plugin>(
│ │ │ │ torrent_handle const&, client_data_t)> ext);
│ │ │ │ +void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │
│ │ │ │
This function adds an extension to this session. The argument is a
│ │ │ │ function object that is called with a torrent_handle and which should
│ │ │ │ return a std::shared_ptr<torrent_plugin>. To write custom
│ │ │ │ plugins, see libtorrent plugins. For the typical bittorrent client
│ │ │ │ all of these extensions should be added. The main plugins implemented
│ │ │ │ in libtorrent are:
│ │ │ │ @@ -2817,18 +2817,18 @@
│ │ │ │ that sends bad data with very high accuracy. Should
│ │ │ │ eliminate most problems on poisoned torrents.
│ │ │ │
│ │ │ │
│ │ │ │ ses.add_extension(<::create_smart_ban_plugin);
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
set_ip_filter() get_ip_filter()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_ip_filter() set_ip_filter()
│ │ │ │
│ │ │ │ ip_filter get_ip_filter () const;
│ │ │ │ void set_ip_filter (ip_filter f);
│ │ │ │
│ │ │ │
Sets a filter that will be used to reject and accept incoming as well
│ │ │ │ as outgoing connections based on their originating ip address. The
│ │ │ │ default filter will allow connections to any ip address. To build a
│ │ │ │ @@ -2842,37 +2842,37 @@
│ │ │ │
│ │ │ │ void set_port_filter (port_filter const& f);
│ │ │ │
│ │ │ │
apply port_filter f to incoming and outgoing peers. a port filter
│ │ │ │ will reject making outgoing peer connections to certain remote ports.
│ │ │ │ The main intention is to be able to avoid triggering certain
│ │ │ │ anti-virus software by connecting to SMTP, FTP ports.
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
is_listening() listen_port() ssl_listen_port()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
ssl_listen_port() is_listening() listen_port()
│ │ │ │
│ │ │ │ +unsigned short listen_port () const;
│ │ │ │ bool is_listening () const;
│ │ │ │ unsigned short ssl_listen_port () const;
│ │ │ │ -unsigned short listen_port () const;
│ │ │ │
│ │ │ │
is_listening() will tell you whether or not the session has
│ │ │ │ successfully opened a listening port. If it hasn't, this function will
│ │ │ │ return false, and then you can set a new
│ │ │ │ settings_pack::listen_interfaces to try another interface and port to
│ │ │ │ bind to.
│ │ │ │
listen_port() returns the port we ended up listening on.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
set_peer_class_filter() get_peer_class_filter()
│ │ │ │
│ │ │ │ -void set_peer_class_filter (ip_filter const& f);
│ │ │ │ ip_filter get_peer_class_filter () const;
│ │ │ │ +void set_peer_class_filter (ip_filter const& f);
│ │ │ │
│ │ │ │
Sets the peer class filter for this session. All new peer connections
│ │ │ │ will take this into account and be added to the peer classes specified
│ │ │ │ by this filter, based on the peer's IP address.
│ │ │ │
The ip-filter essentially maps an IP -> uint32. Each bit in that 32
│ │ │ │ bit integer represents a peer class. The least significant bit
│ │ │ │ represents class 0, the next bit class 1 and so on.
│ │ │ │ @@ -2892,21 +2892,21 @@
│ │ │ │ 32 bits in the IP range mapping. Only the set bits matter; no peer
│ │ │ │ class will be removed from a peer as a result of this call, peer
│ │ │ │ classes are only added.
│ │ │ │
The peer_class argument cannot be greater than 31. The bitmasks
│ │ │ │ representing peer classes in the peer_class_filter are 32 bits.
│ │ │ │
The get_peer_class_filter() function returns the current filter.
│ │ │ │
For more information, see peer classes.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
set_peer_class_type_filter() get_peer_class_type_filter()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_peer_class_type_filter() set_peer_class_type_filter()
│ │ │ │
│ │ │ │ -void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │ peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │ +void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │
│ │ │ │
Sets and gets the peer class type filter. This is controls automatic
│ │ │ │ peer class assignments to peers based on what kind of socket it is.
│ │ │ │
It does not only support assigning peer classes, it also supports
│ │ │ │ removing peer classes based on socket type.
│ │ │ │
The order of these rules being applied are:
│ │ │ │
│ │ │ │ @@ -2999,22 +2999,22 @@
│ │ │ │ handle.save_resume_data();
│ │ │ │ Note that when a queued or downloading torrent is removed, its position
│ │ │ │ in the download queue is vacated and every subsequent torrent in the
│ │ │ │ queue has their queue positions updated. This can potentially cause a
│ │ │ │ large state_update to be posted. When removing all torrents, it is
│ │ │ │ advised to remove them from the back of the queue, to minimize the
│ │ │ │ shifting.
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
│ │ │ │ -
get_settings() apply_settings()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
apply_settings() get_settings()
│ │ │ │
│ │ │ │ void apply_settings (settings_pack const&);
│ │ │ │ -settings_pack get_settings () const;
│ │ │ │ void apply_settings (settings_pack&&);
│ │ │ │ +settings_pack get_settings () const;
│ │ │ │
│ │ │ │
Applies the settings specified by the settings_pack s. This is an
│ │ │ │ asynchronous operation that will return immediately and actually apply
│ │ │ │ the settings to the main thread of libtorrent some time later.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │ @@ -3078,16 +3078,16 @@
│ │ │ │
alert::type() but can also be queries from a concrete type via
│ │ │ │
T::alert_type, as a static constant.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
delete_port_mapping() add_port_mapping()
│ │ │ │
│ │ │ │ -void delete_port_mapping (port_mapping_t handle);
│ │ │ │ std::vector<port_mapping_t> add_port_mapping (portmap_protocol t, int external_port, int local_port);
│ │ │ │ +void delete_port_mapping (port_mapping_t handle);
│ │ │ │
│ │ │ │
add_port_mapping adds one or more port forwards on UPnP and/or NAT-PMP,
│ │ │ │ whichever is enabled. A mapping is created for each listen socket
│ │ │ │ in the session. The return values are all handles referring to the
│ │ │ │ port mappings that were just created. Pass them to delete_port_mapping()
│ │ │ │ to remove them.
│ │ │ │
[report issue]
│ │ │ │ @@ -3153,30 +3153,30 @@
│ │ │ │
[report issue]
│ │ │ │ - reopen_map_ports
│ │ │ │ - This option indicates if the ports are mapped using natpmp
│ │ │ │ and upnp. If mapping was already made, they are deleted and added
│ │ │ │ again. This only works if natpmp and/or upnp are configured to be
│ │ │ │ enable.
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ +
[report issue]
│ │ │ │ -
│ │ │ │ -
write_session_params_buf() write_session_params() read_session_params()
│ │ │ │ +
│ │ │ │ +
read_session_params() write_session_params() write_session_params_buf()
│ │ │ │
Declared in "libtorrent/session_params.hpp"
│ │ │ │
│ │ │ │ -entry write_session_params (session_params const& sp
│ │ │ │ - , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ std::vector<char> write_session_params_buf (session_params const& sp
│ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ -session_params read_session_params (span<char const> buf
│ │ │ │ +entry write_session_params (session_params const& sp
│ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ session_params read_session_params (bdecode_node const& e
│ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ +session_params read_session_params (span<char const> buf
│ │ │ │ + , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │
│ │ │ │
These functions serialize and de-serialize a session_params object to and
│ │ │ │ from bencoded form. The session_params object is used to initialize a new
│ │ │ │ session using the state from a previous one (or by programmatically configure
│ │ │ │ the session up-front).
│ │ │ │ The flags parameter can be used to only save and load certain aspects of the
│ │ │ │ session's state.
│ │ │ │ @@ -3304,69 +3304,69 @@
│ │ │ │
│ │ │ │
torrent_info
│ │ │ │
Declared in "libtorrent/torrent_info.hpp"
│ │ │ │
the torrent_info class holds the information found in a .torrent file.
│ │ │ │
│ │ │ │ class torrent_info
│ │ │ │ {
│ │ │ │ - torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ - explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ - torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ - explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ - torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ torrent_info (torrent_info const& t);
│ │ │ │ + torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ + torrent_info (char const* buffer, int size);
│ │ │ │ explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ - torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ - torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ + explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ explicit torrent_info (std::string const& filename);
│ │ │ │ - torrent_info (char const* buffer, int size);
│ │ │ │ - torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ + torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ + torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ + torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ + torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ + explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ + torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ ~torrent_info ();
│ │ │ │ file_storage const& files () const;
│ │ │ │ file_storage const& orig_files () const;
│ │ │ │ void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │ void remap_files (file_storage const& f);
│ │ │ │ - void clear_trackers ();
│ │ │ │ - void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ std::vector<announce_entry> const& trackers () const;
│ │ │ │ void add_tracker (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ - std::vector<std::string> collections () const;
│ │ │ │ + void clear_trackers ();
│ │ │ │ + void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ - void add_http_seed (std::string const& url
│ │ │ │ - , std::string const& extern_auth = std::string()
│ │ │ │ - , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ - std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ + std::vector<std::string> collections () const;
│ │ │ │ void add_url_seed (std::string const& url
│ │ │ │ , std::string const& ext_auth = std::string()
│ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │ + void add_http_seed (std::string const& url
│ │ │ │ + , std::string const& extern_auth = std::string()
│ │ │ │ + , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ + std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ std::int64_t total_size () const;
│ │ │ │ - int num_pieces () const;
│ │ │ │ int piece_length () const;
│ │ │ │ + int num_pieces () const;
│ │ │ │ int blocks_per_piece () const;
│ │ │ │ - piece_index_t end_piece () const;
│ │ │ │ - index_range<piece_index_t> piece_range () const;
│ │ │ │ piece_index_t last_piece () const;
│ │ │ │ + index_range<piece_index_t> piece_range () const;
│ │ │ │ + piece_index_t end_piece () const;
│ │ │ │ info_hash_t const& info_hashes () const;
│ │ │ │ sha1_hash info_hash () const noexcept;
│ │ │ │ - bool v1 () const;
│ │ │ │ bool v2 () const;
│ │ │ │ + bool v1 () const;
│ │ │ │ int num_files () const;
│ │ │ │ std::vector<file_slice> map_block (piece_index_t const piece
│ │ │ │ , std::int64_t offset, int size) const;
│ │ │ │ peer_request map_file (file_index_t const file, std::int64_t offset, int size) const;
│ │ │ │ string_view ssl_cert () const;
│ │ │ │ bool is_valid () const;
│ │ │ │ bool priv () const;
│ │ │ │ bool is_i2p () const;
│ │ │ │ int piece_size (piece_index_t index) const;
│ │ │ │ - char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │ + char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ bool is_loaded () const;
│ │ │ │ const std::string& name () const;
│ │ │ │ std::time_t creation_date () const;
│ │ │ │ const std::string& creator () const;
│ │ │ │ const std::string& comment () const;
│ │ │ │ std::vector<std::pair<std::string, int>> const& nodes () const;
│ │ │ │ void add_node (std::pair<std::string, int> const& node);
│ │ │ │ @@ -3376,27 +3376,27 @@
│ │ │ │ span<char const> piece_layer (file_index_t) const;
│ │ │ │ void free_piece_layers ();
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
torrent_info()
│ │ │ │
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ torrent_info (torrent_info const& t);
│ │ │ │ +torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ +torrent_info (char const* buffer, int size);
│ │ │ │ explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ -torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ +explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ explicit torrent_info (std::string const& filename);
│ │ │ │ -torrent_info (char const* buffer, int size);
│ │ │ │ -torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ +torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │
│ │ │ │
The constructor that takes an info-hash will initialize the info-hash
│ │ │ │ to the given value, but leave all other fields empty. This is used
│ │ │ │ internally when downloading torrents without the metadata. The
│ │ │ │ metadata will be created by libtorrent as soon as it has been
│ │ │ │ downloaded from the swarm.
│ │ │ │
The constructor that takes a bdecode_node will create a torrent_info
│ │ │ │ @@ -3483,64 +3483,64 @@
│ │ │ │
│ │ │ │
Remaps the file storage to a new file layout. This can be used to, for
│ │ │ │ instance, download all data in a torrent to a single file, or to a
│ │ │ │ number of fixed size sector aligned files, regardless of the number
│ │ │ │ and sizes of the files in the torrent.
│ │ │ │
The new specified file_storage must have the exact same size as
│ │ │ │ the current one.
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
add_tracker() trackers() clear_trackers()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
clear_trackers() trackers() add_tracker()
│ │ │ │
│ │ │ │ -void clear_trackers ();
│ │ │ │ -void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ std::vector<announce_entry> const& trackers () const;
│ │ │ │ void add_tracker (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ +void clear_trackers ();
│ │ │ │ +void add_tracker (std::string const& url, int tier = 0);
│ │ │ │
│ │ │ │
add_tracker() adds a tracker to the announce-list. The tier
│ │ │ │ determines the order in which the trackers are to be tried.
│ │ │ │ The trackers() function will return a sorted vector of
│ │ │ │ announce_entry. Each announce entry contains a string, which is
│ │ │ │ the tracker url, and a tier index. The tier index is the high-level
│ │ │ │ priority. No matter which trackers that works or not, the ones with
│ │ │ │ lower tier will always be tried before the one with higher tier
│ │ │ │ number. For more information, see announce_entry.
│ │ │ │
trackers() returns all entries from announce-list.
│ │ │ │
clear_trackers() removes all trackers from announce-list.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
similar_torrents() collections()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
collections() similar_torrents()
│ │ │ │
│ │ │ │ -std::vector<std::string> collections () const;
│ │ │ │ std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ +std::vector<std::string> collections () const;
│ │ │ │
│ │ │ │
These two functions are related to BEP 38 (mutable torrents). The
│ │ │ │ vectors returned from these correspond to the "similar" and
│ │ │ │ "collections" keys in the .torrent file. Both info-hashes and
│ │ │ │ collections from within the info-dict and from outside of it are
│ │ │ │ included.
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
add_url_seed() set_web_seeds() web_seeds() add_http_seed()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
web_seeds() add_url_seed() set_web_seeds() add_http_seed()
│ │ │ │
│ │ │ │ -void add_http_seed (std::string const& url
│ │ │ │ - , std::string const& extern_auth = std::string()
│ │ │ │ - , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ -std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ void add_url_seed (std::string const& url
│ │ │ │ , std::string const& ext_auth = std::string()
│ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ │ +void add_http_seed (std::string const& url
│ │ │ │ + , std::string const& extern_auth = std::string()
│ │ │ │ + , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ │ void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │
│ │ │ │
web_seeds() returns all url seeds and http seeds in the torrent.
│ │ │ │ Each entry is a web_seed_entry and may refer to either a url seed
│ │ │ │ or http seed.
│ │ │ │
add_url_seed() and add_http_seed() adds one url to the list of
│ │ │ │ url/http seeds.
│ │ │ │
set_web_seeds() replaces all web seeds with the ones specified in
│ │ │ │ @@ -3565,16 +3565,16 @@
│ │ │ │ the total size will be larger than the sum of all (regular) file
│ │ │ │ sizes.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
piece_length() num_pieces()
│ │ │ │
│ │ │ │ -int num_pieces () const;
│ │ │ │ int piece_length () const;
│ │ │ │ +int num_pieces () const;
│ │ │ │
│ │ │ │
piece_length() and num_pieces() returns the number of byte
│ │ │ │ for each piece and the total number of pieces, respectively. The
│ │ │ │ difference between piece_size() and piece_length() is that
│ │ │ │ piece_size() takes the piece index as argument and gives you the
│ │ │ │ exact size of that piece. It will always be the same as
│ │ │ │ piece_length() except in the case of the last piece, which may be
│ │ │ │ @@ -3583,48 +3583,48 @@
│ │ │ │
│ │ │ │
blocks_per_piece()
│ │ │ │
│ │ │ │ int blocks_per_piece () const;
│ │ │ │
│ │ │ │
returns the number of blocks there are in the typical piece. There
│ │ │ │ may be fewer in the last piece)
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
end_piece() piece_range() last_piece()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
piece_range() last_piece() end_piece()
│ │ │ │
│ │ │ │ -piece_index_t end_piece () const;
│ │ │ │ -index_range<piece_index_t> piece_range () const;
│ │ │ │ piece_index_t last_piece () const;
│ │ │ │ +index_range<piece_index_t> piece_range () const;
│ │ │ │ +piece_index_t end_piece () const;
│ │ │ │
│ │ │ │
last_piece() returns the index to the last piece in the torrent and
│ │ │ │ end_piece() returns the index to the one-past-end piece in the
│ │ │ │ torrent
│ │ │ │ piece_range() returns an implementation-defined type that can be
│ │ │ │ used as the container in a range-for loop. Where the values are the
│ │ │ │ indices of all pieces in the file_storage.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
info_hashes() info_hash()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
info_hash() info_hashes()
│ │ │ │
│ │ │ │ info_hash_t const& info_hashes () const;
│ │ │ │ sha1_hash info_hash () const noexcept;
│ │ │ │
│ │ │ │
returns the info-hash of the torrent. For BitTorrent v2 support, use
│ │ │ │ info_hashes() to get an object that may hold both a v1 and v2
│ │ │ │ info-hash
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
v1() v2()
│ │ │ │
│ │ │ │ -bool v1 () const;
│ │ │ │ bool v2 () const;
│ │ │ │ +bool v1 () const;
│ │ │ │
│ │ │ │
returns whether this torrent has v1 and/or v2 metadata, respectively.
│ │ │ │ Hybrid torrents have both. These are shortcuts for
│ │ │ │ info_hashes().has_v1() and info_hashes().has_v2() calls.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
num_files()
│ │ │ │ @@ -3697,21 +3697,21 @@
│ │ │ │
│ │ │ │
piece_size()
│ │ │ │
│ │ │ │ int piece_size (piece_index_t index) const;
│ │ │ │
│ │ │ │
returns the piece size of file with index. This will be the same as piece_length(),
│ │ │ │ except for the last piece, which may be shorter.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
hash_for_piece_ptr() hash_for_piece()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
hash_for_piece() hash_for_piece_ptr()
│ │ │ │
│ │ │ │ -char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │ sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │ │ +char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ │
│ │ │ │
hash_for_piece() takes a piece-index and returns the 20-bytes
│ │ │ │ sha1-hash for that piece and info_hash() returns the 20-bytes
│ │ │ │ sha1-hash for the info-section of the torrent file.
│ │ │ │ hash_for_piece_ptr() returns a pointer to the 20 byte sha1 digest
│ │ │ │ for the piece. Note that the string is not 0-terminated.
│ │ │ │
[report issue]
│ │ │ │ @@ -4444,32 +4444,32 @@
│ │ │ │
- The byte offset within that piece where the range starts.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │ - length
│ │ │ │ - The size of the range, in bytes.
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │
│ │ │ │ -
│ │ │ │ -
load_torrent_parsed() load_torrent_buffer() load_torrent_file()
│ │ │ │ +
│ │ │ │ +
load_torrent_parsed() load_torrent_file() load_torrent_buffer()
│ │ │ │
Declared in "libtorrent/load_torrent.hpp"
│ │ │ │
│ │ │ │ -add_torrent_params load_torrent_parsed (
│ │ │ │ - bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -add_torrent_params load_torrent_buffer (
│ │ │ │ - span<char const> buffer, load_torrent_limits const& cfg);
│ │ │ │ -add_torrent_params load_torrent_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_file (
│ │ │ │ + std::string const& filename);
│ │ │ │ +add_torrent_params load_torrent_parsed (
│ │ │ │ + bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ add_torrent_params load_torrent_parsed (
│ │ │ │ bdecode_node const& torrent_file);
│ │ │ │ add_torrent_params load_torrent_buffer (
│ │ │ │ + span<char const> buffer, load_torrent_limits const& cfg);
│ │ │ │ +add_torrent_params load_torrent_buffer (
│ │ │ │ span<char const> buffer);
│ │ │ │
│ │ │ │
These functions load the content of a .torrent file into an
│ │ │ │ add_torrent_params object.
│ │ │ │ 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).
│ │ │ │ @@ -4482,17 +4482,17 @@
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
make_magnet_uri()
│ │ │ │
Declared in "libtorrent/magnet_uri.hpp"
│ │ │ │
│ │ │ │ -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);
│ │ │ │ +std::string make_magnet_uri (torrent_info const& info);
│ │ │ │
│ │ │ │
Generates a magnet URI from the specified torrent.
│ │ │ │
Several fields from the add_torrent_params objects are recorded in the
│ │ │ │ magnet link. In order to not include them, they have to be cleared before
│ │ │ │ calling make_magnet_uri(). These fields are used:
│ │ │ │
│ │ │ │ ti, info_hashes, url_seeds, dht_nodes,
│ │ │ │ @@ -5336,19 +5336,19 @@
│ │ │ │ Torrent plugins are associated with a single torrent and have a number
│ │ │ │ of functions called at certain events. Many of its functions have the
│ │ │ │ ability to change or override the default libtorrent behavior.
│ │ │ │
│ │ │ │ struct torrent_plugin
│ │ │ │ {
│ │ │ │ virtual std::shared_ptr<peer_plugin> new_connection (peer_connection_handle const&);
│ │ │ │ - virtual void on_piece_pass (piece_index_t);
│ │ │ │ virtual void on_piece_failed (piece_index_t);
│ │ │ │ + virtual void on_piece_pass (piece_index_t);
│ │ │ │ virtual void tick ();
│ │ │ │ - virtual bool on_pause ();
│ │ │ │ virtual bool on_resume ();
│ │ │ │ + virtual bool on_pause ();
│ │ │ │ virtual void on_files_checked ();
│ │ │ │ virtual void on_state (torrent_status::state_t);
│ │ │ │ virtual void on_add_peer (tcp::endpoint const&,
│ │ │ │ peer_source_flags_t, add_peer_flags_t);
│ │ │ │
│ │ │ │ static constexpr add_peer_flags_t first_time = 1_bit;
│ │ │ │ static constexpr add_peer_flags_t filtered = 2_bit;
│ │ │ │ @@ -5367,41 +5367,41 @@
│ │ │ │ are supposed to return an instance of your peer_plugin class. Which in
│ │ │ │ turn will have its hook functions called on event specific to that peer.
│ │ │ │ The peer_connection_handle will be valid as long as the shared_ptr
│ │ │ │ is being held by the torrent object. So, it is generally a good idea to not
│ │ │ │ keep a shared_ptr to your own peer_plugin. If you want to keep references
│ │ │ │ to it, use weak_ptr.
│ │ │ │ If this function throws an exception, the connection will be closed.
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
│ │ │ │ -
on_piece_pass() on_piece_failed()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_piece_failed() on_piece_pass()
│ │ │ │
│ │ │ │ -virtual void on_piece_pass (piece_index_t);
│ │ │ │ virtual void on_piece_failed (piece_index_t);
│ │ │ │ +virtual void on_piece_pass (piece_index_t);
│ │ │ │
│ │ │ │
These hooks are called when a piece passes the hash check or fails the hash
│ │ │ │ check, respectively. The index is the piece index that was downloaded.
│ │ │ │ It is possible to access the list of peers that participated in sending the
│ │ │ │ piece through the torrent and the piece_picker.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
tick()
│ │ │ │
│ │ │ │ virtual void tick ();
│ │ │ │
│ │ │ │
This hook is called approximately once per second. It is a way of making it
│ │ │ │ easy for plugins to do timed events, for sending messages or whatever.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
on_resume() on_pause()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_pause() on_resume()
│ │ │ │
│ │ │ │ -virtual bool on_pause ();
│ │ │ │ virtual bool on_resume ();
│ │ │ │ +virtual bool on_pause ();
│ │ │ │
│ │ │ │
These hooks are called when the torrent is paused and resumed respectively.
│ │ │ │ The return value indicates if the event was handled. A return value of
│ │ │ │ true indicates that it was handled, and no other plugin after this one
│ │ │ │ will have this hook function called, and the standard handler will also not be
│ │ │ │ invoked. So, returning true effectively overrides the standard behavior of
│ │ │ │ pause or resume.
│ │ │ │ @@ -5466,51 +5466,51 @@
│ │ │ │ {
│ │ │ │ virtual string_view
type () const;
│ │ │ │ virtual void
add_handshake (entry&);
│ │ │ │ virtual void
on_disconnect (error_code const&);
│ │ │ │ virtual void
on_connected ();
│ │ │ │ virtual bool
on_handshake (span<char const>);
│ │ │ │ virtual bool
on_extension_handshake (bdecode_node const&);
│ │ │ │ - virtual bool
on_bitfield (bitfield const&
/*bitfield*/);
│ │ │ │ - virtual bool
on_choke ();
│ │ │ │ - virtual bool
on_dont_have (piece_index_t);
│ │ │ │ - virtual bool
on_have_none ();
│ │ │ │ - virtual bool
on_allowed_fast (piece_index_t);
│ │ │ │ virtual bool
on_have (piece_index_t);
│ │ │ │ - virtual bool
on_not_interested ();
│ │ │ │ virtual bool
on_interested ();
│ │ │ │ + virtual bool
on_dont_have (piece_index_t);
│ │ │ │ + virtual bool
on_choke ();
│ │ │ │ + virtual bool
on_allowed_fast (piece_index_t);
│ │ │ │ + virtual bool
on_unchoke ();
│ │ │ │ virtual bool
on_have_all ();
│ │ │ │ + virtual bool
on_have_none ();
│ │ │ │ + virtual bool
on_not_interested ();
│ │ │ │ + virtual bool
on_bitfield (bitfield const&
/*bitfield*/);
│ │ │ │ virtual bool
on_request (peer_request const&);
│ │ │ │ - virtual bool
on_unchoke ();
│ │ │ │ virtual bool
on_piece (peer_request const&
/*piece*/
│ │ │ │ , span<char const>
/*buf*/);
│ │ │ │ + virtual bool
on_reject (peer_request const&);
│ │ │ │ virtual bool
on_suggest (piece_index_t);
│ │ │ │ virtual bool
on_cancel (peer_request const&);
│ │ │ │ - virtual bool
on_reject (peer_request const&);
│ │ │ │ virtual void
sent_reject_request (peer_request const&);
│ │ │ │ - virtual void
sent_suggest (piece_index_t);
│ │ │ │ - virtual void
sent_have_none ();
│ │ │ │ - virtual void
sent_cancel (peer_request const&);
│ │ │ │ - virtual void
sent_have_all ();
│ │ │ │ virtual void
sent_request (peer_request const&);
│ │ │ │ + virtual void
sent_have_none ();
│ │ │ │ virtual void
sent_choke ();
│ │ │ │ + virtual void
sent_have_all ();
│ │ │ │ + virtual void
sent_suggest (piece_index_t);
│ │ │ │ + virtual void
sent_cancel (peer_request const&);
│ │ │ │ virtual void
sent_allow_fast (piece_index_t);
│ │ │ │ - virtual void
sent_piece (peer_request const&);
│ │ │ │ - virtual void
sent_unchoke ();
│ │ │ │ - virtual void
sent_not_interested ();
│ │ │ │ virtual void
sent_interested ();
│ │ │ │ + virtual void
sent_unchoke ();
│ │ │ │ virtual void
sent_have (piece_index_t);
│ │ │ │ + virtual void
sent_piece (peer_request const&);
│ │ │ │ + virtual void
sent_not_interested ();
│ │ │ │ virtual void
sent_payload (int
/* bytes */);
│ │ │ │ virtual bool
can_disconnect (error_code const&
/*ec*/);
│ │ │ │ virtual bool
on_extended (int
/*length*/, int
/*msg*/,
│ │ │ │ span<char const>
/*body*/);
│ │ │ │ virtual bool
on_unknown_message (int
/*length*/, int
/*msg*/,
│ │ │ │ span<char const>
/*body*/);
│ │ │ │ - virtual void
on_piece_pass (piece_index_t);
│ │ │ │ virtual void
on_piece_failed (piece_index_t);
│ │ │ │ + virtual void
on_piece_pass (piece_index_t);
│ │ │ │ virtual void
tick ();
│ │ │ │ virtual bool
write_request (peer_request const&);
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
type()
│ │ │ │
│ │ │ │ @@ -5560,39 +5560,39 @@
│ │ │ │ virtual bool on_extension_handshake (bdecode_node const&);
│ │ │ │
│ │ │ │
called when the extension handshake from the other end is received
│ │ │ │ if this returns false, it means that this extension isn't
│ │ │ │ supported by this peer. It will result in this peer_plugin
│ │ │ │ being removed from the peer_connection and destructed.
│ │ │ │ this is not called for web seeds
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
on_choke() on_interested() on_have() on_have_none() on_unchoke() on_allowed_fast() on_not_interested() on_have_all() on_request() on_bitfield() on_dont_have()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_interested() on_dont_have() on_unchoke() on_choke() on_bitfield() on_have_all() on_allowed_fast() on_request() on_not_interested() on_have() on_have_none()
│ │ │ │
│ │ │ │ -virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ -virtual bool on_choke ();
│ │ │ │ -virtual bool on_dont_have (piece_index_t);
│ │ │ │ -virtual bool on_have_none ();
│ │ │ │ -virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ virtual bool on_have (piece_index_t);
│ │ │ │ -virtual bool on_not_interested ();
│ │ │ │ virtual bool on_interested ();
│ │ │ │ +virtual bool on_dont_have (piece_index_t);
│ │ │ │ +virtual bool on_choke ();
│ │ │ │ +virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ +virtual bool on_unchoke ();
│ │ │ │ virtual bool on_have_all ();
│ │ │ │ +virtual bool on_have_none ();
│ │ │ │ +virtual bool on_not_interested ();
│ │ │ │ +virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ virtual bool on_request (peer_request const&);
│ │ │ │ -virtual bool on_unchoke ();
│ │ │ │
│ │ │ │
returning true from any of the message handlers
│ │ │ │ indicates that the plugin has handled the message.
│ │ │ │ it will break the plugin chain traversing and not let
│ │ │ │ anyone else handle the message, including the default
│ │ │ │ handler.
│ │ │ │
[report issue]
│ │ │ │ @@ -5604,27 +5604,27 @@
│ │ │ │
│ │ │ │
This function is called when the peer connection is receiving
│ │ │ │ a piece. buf points (non-owning pointer) to the data in an
│ │ │ │ internal immutable disk buffer. The length of the data is specified
│ │ │ │ in the length member of the piece parameter.
│ │ │ │ returns true to indicate that the piece is handled and the
│ │ │ │ rest of the logic should be ignored.
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
sent_have() sent_unchoke() sent_interested() sent_not_interested() sent_piece()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
sent_not_interested() sent_have() sent_piece() sent_unchoke() sent_interested()
│ │ │ │
│ │ │ │ -virtual void sent_piece (peer_request const&);
│ │ │ │ -virtual void sent_unchoke ();
│ │ │ │ -virtual void sent_not_interested ();
│ │ │ │ virtual void sent_interested ();
│ │ │ │ +virtual void sent_unchoke ();
│ │ │ │ virtual void sent_have (piece_index_t);
│ │ │ │ +virtual void sent_piece (peer_request const&);
│ │ │ │ +virtual void sent_not_interested ();
│ │ │ │
│ │ │ │
called after a choke message has been sent to the peer
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
sent_payload()
│ │ │ │
│ │ │ │ virtual void sent_payload (int /* bytes */);
│ │ │ │ @@ -5660,21 +5660,21 @@
│ │ │ │
│ │ │ │
on_unknown_message()
│ │ │ │
│ │ │ │ virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ │ span<char const> /*body*/);
│ │ │ │
│ │ │ │
this is not called for web seeds
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
on_piece_pass() on_piece_failed()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
on_piece_failed() on_piece_pass()
│ │ │ │
│ │ │ │ -virtual void on_piece_pass (piece_index_t);
│ │ │ │ virtual void on_piece_failed (piece_index_t);
│ │ │ │ +virtual void on_piece_pass (piece_index_t);
│ │ │ │
│ │ │ │
called when a piece that this peer participated in either
│ │ │ │ fails or passes the hash_check
│ │ │ │
[report issue]
│ │ │ │
tick()
│ │ │ │
│ │ │ │ @@ -5731,46 +5731,46 @@
│ │ │ │ {
│ │ │ │ explicit peer_connection_handle (std::weak_ptr<peer_connection> impl);
│ │ │ │ connection_type type () const;
│ │ │ │ void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │ peer_plugin const* find_plugin (string_view type) const;
│ │ │ │ bool is_seed () const;
│ │ │ │ bool upload_only () const;
│ │ │ │ - peer_id const& pid () const;
│ │ │ │ bool has_piece (piece_index_t i) const;
│ │ │ │ + peer_id const& pid () const;
│ │ │ │ bool is_interesting () const;
│ │ │ │ bool is_choked () const;
│ │ │ │ bool is_peer_interested () const;
│ │ │ │ bool has_peer_choked () const;
│ │ │ │ void maybe_unchoke_this_peer ();
│ │ │ │ void choke_this_peer ();
│ │ │ │ void get_peer_info (peer_info& p) const;
│ │ │ │ torrent_handle associated_torrent () const;
│ │ │ │ - tcp::endpoint local_endpoint () const;
│ │ │ │ tcp::endpoint const& remote () const;
│ │ │ │ - void disconnect (error_code const& ec, operation_t op
│ │ │ │ - , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ + tcp::endpoint local_endpoint () const;
│ │ │ │ + bool is_connecting () const;
│ │ │ │ bool is_disconnecting () const;
│ │ │ │ bool is_outgoing () const;
│ │ │ │ - bool is_connecting () const;
│ │ │ │ - bool ignore_unchoke_slots () const;
│ │ │ │ + void disconnect (error_code const& ec, operation_t op
│ │ │ │ + , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ bool on_local_network () const;
│ │ │ │ + bool ignore_unchoke_slots () const;
│ │ │ │ bool failed () const;
│ │ │ │ + bool should_log (peer_log_alert::direction_t direction) const;
│ │ │ │ void peer_log (peer_log_alert::direction_t direction
│ │ │ │ , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT(4,5);
│ │ │ │ - bool should_log (peer_log_alert::direction_t direction) const;
│ │ │ │ bool can_disconnect (error_code const& ec) const;
│ │ │ │ bool has_metadata () const;
│ │ │ │ bool in_handshake () const;
│ │ │ │ void send_buffer (char const* begin, int size);
│ │ │ │ time_point time_of_last_unchoke () const;
│ │ │ │ std::time_t last_seen_complete () const;
│ │ │ │ - bool operator== (peer_connection_handle const& o) const;
│ │ │ │ - bool operator!= (peer_connection_handle const& o) const;
│ │ │ │ bool operator< (peer_connection_handle const& o) const;
│ │ │ │ + bool operator!= (peer_connection_handle const& o) const;
│ │ │ │ + bool operator== (peer_connection_handle const& o) const;
│ │ │ │ std::shared_ptr<peer_connection> native_handle () const;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
bt_peer_connection_handle
│ │ │ │
Declared in "libtorrent/peer_connection_handle.hpp"
│ │ │ │ @@ -5780,16 +5780,16 @@
│ │ │ │
│ │ │ │ struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │ {
│ │ │ │ explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ │ bool support_extensions () const;
│ │ │ │ bool packet_finished () const;
│ │ │ │ bool supports_encryption () const;
│ │ │ │ - void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ + void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ std::shared_ptr<bt_peer_connection> native_handle () const;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
create_ut_pex_plugin()
│ │ │ │
Declared in "libtorrent/extensions/ut_pex.hpp"
│ │ │ │ @@ -5873,64 +5873,64 @@
│ │ │ │ {
│ │ │ │ bool
is_valid () const;
│ │ │ │ void
reserve (int num_files);
│ │ │ │ void
add_file (std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}
│ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ - void
add_file_borrow (error_code& ec, string_view filename
│ │ │ │ + void
add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ + , file_flags_t file_flags = {}
│ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ + , char const* root_hash = nullptr);
│ │ │ │ + void
add_file_borrow (string_view filename
│ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ - void
add_file_borrow (string_view filename
│ │ │ │ + void
add_file_borrow (error_code& ec, string_view filename
│ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ - void
add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ - , file_flags_t file_flags = {}
│ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ - , char const* root_hash = nullptr);
│ │ │ │ void
rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │ std::vector<file_slice>
map_block (piece_index_t piece, std::int64_t offset
│ │ │ │ , std::int64_t size) const;
│ │ │ │ peer_request
map_file (file_index_t file, std::int64_t offset, int size) const;
│ │ │ │ int
num_files () const noexcept;
│ │ │ │ file_index_t
end_file () const noexcept;
│ │ │ │ index_range<file_index_t>
file_range () const noexcept;
│ │ │ │ std::int64_t
total_size () const;
│ │ │ │ int
num_pieces () const;
│ │ │ │ void
set_num_pieces (int n);
│ │ │ │ piece_index_t
end_piece () const;
│ │ │ │ piece_index_t
last_piece () const;
│ │ │ │ index_range<piece_index_t>
piece_range () const noexcept;
│ │ │ │ - int
piece_length () const;
│ │ │ │ void
set_piece_length (int l);
│ │ │ │ + int
piece_length () const;
│ │ │ │ int
piece_size (piece_index_t index) const;
│ │ │ │ int
piece_size2 (piece_index_t index) const;
│ │ │ │ int
blocks_in_piece2 (piece_index_t index) const;
│ │ │ │ int
blocks_per_piece () const;
│ │ │ │ - void
set_name (std::string const& n);
│ │ │ │ std::string const&
name () const;
│ │ │ │ + void
set_name (std::string const& n);
│ │ │ │ void
swap (file_storage& ti) noexcept;
│ │ │ │ void
canonicalize ();
│ │ │ │ - std::int64_t
file_offset (file_index_t index) const;
│ │ │ │ string_view
file_name (file_index_t index) const;
│ │ │ │ + std::int64_t
file_offset (file_index_t index) const;
│ │ │ │ std::time_t
mtime (file_index_t index) const;
│ │ │ │ - bool
pad_file_at (file_index_t index) const;
│ │ │ │ - std::int64_t
file_size (file_index_t index) const;
│ │ │ │ - sha1_hash
hash (file_index_t index) const;
│ │ │ │ - char const*
root_ptr (file_index_t const index) const;
│ │ │ │ + std::string
file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ std::string
symlink (file_index_t index) const;
│ │ │ │ + sha1_hash
hash (file_index_t index) const;
│ │ │ │ + std::int64_t
file_size (file_index_t index) const;
│ │ │ │ + bool
pad_file_at (file_index_t index) const;
│ │ │ │ sha256_hash
root (file_index_t index) const;
│ │ │ │ - std::string
file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ - int
file_num_pieces (file_index_t index) const;
│ │ │ │ + char const*
root_ptr (file_index_t const index) const;
│ │ │ │ int
file_num_blocks (file_index_t index) const;
│ │ │ │ index_range<piece_index_t::diff_type>
file_piece_range (file_index_t) const;
│ │ │ │ + int
file_num_pieces (file_index_t index) const;
│ │ │ │ int
file_first_block_node (file_index_t index) const;
│ │ │ │ int
file_first_piece_node (file_index_t index) const;
│ │ │ │ std::uint32_t
file_path_hash (file_index_t index, std::string const& save_path) const;
│ │ │ │ void
all_path_hashes (std::unordered_set<std::uint32_t>& table) const;
│ │ │ │ file_flags_t
file_flags (file_index_t index) const;
│ │ │ │ bool
file_absolute_path (file_index_t index) const;
│ │ │ │ file_index_t
file_index_at_piece (piece_index_t piece) const;
│ │ │ │ @@ -5969,28 +5969,28 @@
│ │ │ │
│ │ │ │
add_file() add_file_borrow()
│ │ │ │
│ │ │ │ void add_file (std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}
│ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ -void add_file_borrow (error_code& ec, string_view filename
│ │ │ │ +void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ + , file_flags_t file_flags = {}
│ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ + , char const* root_hash = nullptr);
│ │ │ │ +void add_file_borrow (string_view filename
│ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ -void add_file_borrow (string_view filename
│ │ │ │ +void add_file_borrow (error_code& ec, string_view filename
│ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ -void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ - , file_flags_t file_flags = {}
│ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ - , char const* root_hash = nullptr);
│ │ │ │
│ │ │ │
Adds a file to the file storage. The add_file_borrow version
│ │ │ │ expects that filename is the file name (without a path) of
│ │ │ │ the file that's being added.
│ │ │ │ This memory is borrowed, i.e. it is the caller's
│ │ │ │ responsibility to make sure it stays valid throughout the lifetime
│ │ │ │ of this file_storage object or any copy of it. The same thing applies
│ │ │ │ @@ -6122,21 +6122,21 @@
│ │ │ │
piece_range()
│ │ │ │
│ │ │ │ index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │
│ │ │ │
returns an implementation-defined type that can be used as the
│ │ │ │ container in a range-for loop. Where the values are the indices of all
│ │ │ │ pieces in the file_storage.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
piece_length() set_piece_length()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_piece_length() piece_length()
│ │ │ │
│ │ │ │ -int piece_length () const;
│ │ │ │ void set_piece_length (int l);
│ │ │ │ +int piece_length () const;
│ │ │ │
│ │ │ │
set and get the size of each piece in this torrent. It must be a power of two
│ │ │ │ and at least 16 kiB.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
piece_size()
│ │ │ │
│ │ │ │ @@ -6170,16 +6170,16 @@
│ │ │ │ returns the number of blocks there are in the typical piece. There
│ │ │ │ may be fewer in the last piece)
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
set_name() name()
│ │ │ │
│ │ │ │ -void set_name (std::string const& n);
│ │ │ │ std::string const& name () const;
│ │ │ │ +void set_name (std::string const& n);
│ │ │ │
│ │ │ │
set and get the name of this torrent. For multi-file torrents, this is also
│ │ │ │ the name of the root directory all the files are stored in.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
swap()
│ │ │ │
│ │ │ │ @@ -6190,37 +6190,37 @@
│ │ │ │
│ │ │ │
canonicalize()
│ │ │ │
│ │ │ │ void canonicalize ();
│ │ │ │
│ │ │ │
arrange files and padding to match the canonical form required
│ │ │ │ by BEP 52
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
file_offset() mtime() hash() pad_file_at() symlink() file_path() file_size() root_ptr() root() file_name()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
file_name() hash() root_ptr() file_path() file_offset() mtime() pad_file_at() root() file_size() symlink()
│ │ │ │
│ │ │ │ -std::int64_t file_offset (file_index_t index) const;
│ │ │ │ string_view file_name (file_index_t index) const;
│ │ │ │ +std::int64_t file_offset (file_index_t index) const;
│ │ │ │ std::time_t mtime (file_index_t index) const;
│ │ │ │ -bool pad_file_at (file_index_t index) const;
│ │ │ │ -std::int64_t file_size (file_index_t index) const;
│ │ │ │ -sha1_hash hash (file_index_t index) const;
│ │ │ │ -char const* root_ptr (file_index_t const index) const;
│ │ │ │ +std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ std::string symlink (file_index_t index) const;
│ │ │ │ +sha1_hash hash (file_index_t index) const;
│ │ │ │ +std::int64_t file_size (file_index_t index) const;
│ │ │ │ +bool pad_file_at (file_index_t index) const;
│ │ │ │ sha256_hash root (file_index_t index) const;
│ │ │ │ -std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ +char const* root_ptr (file_index_t const index) const;
│ │ │ │
│ │ │ │
These functions are used to query attributes of files at
│ │ │ │ a given index.
│ │ │ │
The hash() is a SHA-1 hash of the file, or 0 if none was
│ │ │ │ provided in the torrent file. This can potentially be used to
│ │ │ │ join a bittorrent network with other file sharing networks.
│ │ │ │
root() returns the SHA-256 merkle tree root of the specified file,
│ │ │ │ @@ -6244,28 +6244,28 @@
│ │ │ │ index (given the piece size).
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
file_num_pieces() file_num_blocks() file_piece_range()
│ │ │ │
│ │ │ │ -int file_num_pieces (file_index_t index) const;
│ │ │ │ int file_num_blocks (file_index_t index) const;
│ │ │ │ index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │ +int file_num_pieces (file_index_t index) const;
│ │ │ │
│ │ │ │
Returns the number of pieces or blocks the file at index spans,
│ │ │ │ under the assumption that the file is aligned to the start of a piece.
│ │ │ │ This is only meaningful for v2 torrents, where files are guaranteed
│ │ │ │ such alignment.
│ │ │ │ These numbers are used to size and navigate the merkle hash tree for
│ │ │ │ each file.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
file_first_piece_node() file_first_block_node()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
file_first_block_node() file_first_piece_node()
│ │ │ │
│ │ │ │ int file_first_block_node (file_index_t index) const;
│ │ │ │ int file_first_piece_node (file_index_t index) const;
│ │ │ │
│ │ │ │
index of first piece node in the merkle tree
│ │ │ │
[report issue]
│ │ │ │ @@ -6558,40 +6558,40 @@
│ │ │ │ requiring the same type be requested out of it as was assigned to it.
│ │ │ │
│ │ │ │ struct client_data_t
│ │ │ │ {
│ │ │ │ client_data_t () = default;
│ │ │ │ explicit client_data_t (T* v);
│ │ │ │ client_data_t& operator= (T* v);
│ │ │ │ - explicit operator T () const;
│ │ │ │ T* get () const;
│ │ │ │ - operator void* () const = delete;
│ │ │ │ + explicit operator T () const;
│ │ │ │ operator void const* () const = delete;
│ │ │ │ - client_data_t& operator= (void const*) = delete;
│ │ │ │ client_data_t& operator= (void*) = delete;
│ │ │ │ + operator void* () const = delete;
│ │ │ │ + client_data_t& operator= (void const*) = delete;
│ │ │ │
│ │ │ │ template <typename T, typename U = typename std::enable_if<std::is_pointer<T>::value>::type>
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
client_data_t()
│ │ │ │
│ │ │ │ client_data_t () = default;
│ │ │ │
│ │ │ │
construct a nullptr client data
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
const*() operator=() void*()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
operator=() const*() void*()
│ │ │ │
│ │ │ │ -operator void* () const = delete;
│ │ │ │ operator void const* () const = delete;
│ │ │ │ -client_data_t& operator= (void const*) = delete;
│ │ │ │ client_data_t& operator= (void*) = delete;
│ │ │ │ +operator void* () const = delete;
│ │ │ │ +client_data_t& operator= (void const*) = delete;
│ │ │ │
│ │ │ │
we don't allow type-unsafe operations
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_torrent_params
│ │ │ │
Declared in "libtorrent/add_torrent_params.hpp"
│ │ │ │ @@ -6976,18 +6976,18 @@
│ │ │ │
Declared in "libtorrent/peer_class_type_filter.hpp"
│ │ │ │
peer_class_type_filter is a simple container for rules for adding and subtracting
│ │ │ │ peer-classes from peers. It is applied after the peer class filter is applied (which
│ │ │ │ is based on the peer's IP address).
│ │ │ │
│ │ │ │ struct peer_class_type_filter
│ │ │ │ {
│ │ │ │ - void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ - void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ + void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ + void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ std::uint32_t apply (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │ friend bool operator== (peer_class_type_filter const& lhs
│ │ │ │ , peer_class_type_filter const& rhs);
│ │ │ │
│ │ │ │ enum socket_type_t
│ │ │ │ {
│ │ │ │ tcp_socket,
│ │ │ │ @@ -6995,30 +6995,30 @@
│ │ │ │ ssl_tcp_socket,
│ │ │ │ ssl_utp_socket,
│ │ │ │ i2p_socket,
│ │ │ │ num_socket_types,
│ │ │ │ };
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
add() remove()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
remove() add()
│ │ │ │
│ │ │ │ -void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ +void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │
│ │ │ │
add() and remove() adds and removes a peer class to be added
│ │ │ │ to new peers based on socket type.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
disallow() allow()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
allow() disallow()
│ │ │ │
│ │ │ │ -void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ +void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │
│ │ │ │
disallow() and allow() adds and removes a peer class to be
│ │ │ │ removed from new peers based on socket type.
│ │ │ │
The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ │ peer classes in the peer_class_type_filter are 32 bits.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │ @@ -7079,16 +7079,16 @@
│ │ │ │
block_info
│ │ │ │
Declared in "libtorrent/torrent_handle.hpp"
│ │ │ │
holds the state of a block in a piece. Who we requested
│ │ │ │ it from and how far along we are at downloading it.
│ │ │ │
│ │ │ │ struct block_info
│ │ │ │ {
│ │ │ │ - void set_peer (tcp::endpoint const& ep);
│ │ │ │ tcp::endpoint peer () const;
│ │ │ │ + void set_peer (tcp::endpoint const& ep);
│ │ │ │
│ │ │ │ enum block_state_t
│ │ │ │ {
│ │ │ │ none,
│ │ │ │ requested,
│ │ │ │ writing,
│ │ │ │ finished,
│ │ │ │ @@ -7100,16 +7100,16 @@
│ │ │ │ unsigned num_peers:14;
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
peer() set_peer()
│ │ │ │
│ │ │ │ -void set_peer (tcp::endpoint const& ep);
│ │ │ │ tcp::endpoint peer () const;
│ │ │ │ +void set_peer (tcp::endpoint const& ep);
│ │ │ │
│ │ │ │
The peer is the ip address of the peer this block was downloaded from.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
enum block_state_t
│ │ │ │
Declared in "libtorrent/torrent_handle.hpp"
│ │ │ │
│ │ │ │ @@ -7252,106 +7252,106 @@
│ │ │ │ {
│ │ │ │ friend std::size_t hash_value (torrent_handle const& th);
│ │ │ │ torrent_handle () noexcept = default;
│ │ │ │ void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │ void read_piece (piece_index_t piece) const;
│ │ │ │ bool have_piece (piece_index_t piece) const;
│ │ │ │ - void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ void post_peer_info () const;
│ │ │ │ - torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ + void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ - void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ + torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ void post_download_queue () const;
│ │ │ │ - void clear_piece_deadlines () const;
│ │ │ │ + void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ + void clear_piece_deadlines () const;
│ │ │ │ void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ - std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ + std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ std::vector<open_file_state> file_status () const;
│ │ │ │ void clear_error () const;
│ │ │ │ - std::vector<announce_entry> trackers () const;
│ │ │ │ - void add_tracker (announce_entry const&) const;
│ │ │ │ void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ + void add_tracker (announce_entry const&) const;
│ │ │ │ + std::vector<announce_entry> trackers () const;
│ │ │ │ void post_trackers () const;
│ │ │ │ - void remove_url_seed (std::string const& url) const;
│ │ │ │ void add_url_seed (std::string const& url) const;
│ │ │ │ + void remove_url_seed (std::string const& url) const;
│ │ │ │ std::set<std::string> url_seeds () const;
│ │ │ │ - std::set<std::string> http_seeds () const;
│ │ │ │ - void remove_http_seed (std::string const& url) const;
│ │ │ │ void add_http_seed (std::string const& url) const;
│ │ │ │ + void remove_http_seed (std::string const& url) const;
│ │ │ │ + std::set<std::string> http_seeds () const;
│ │ │ │ void add_extension (
│ │ │ │ std::function<std::shared_ptr<torrent_plugin>(torrent_handle const&, client_data_t)> const& ext
│ │ │ │ , client_data_t userdata = client_data_t{});
│ │ │ │ bool set_metadata (span<char const> metadata) const;
│ │ │ │ bool is_valid () const;
│ │ │ │ void resume () const;
│ │ │ │ void pause (pause_flags_t flags = {}) const;
│ │ │ │ - void unset_flags (torrent_flags_t flags) const;
│ │ │ │ torrent_flags_t flags () const;
│ │ │ │ - void set_flags (torrent_flags_t flags) const;
│ │ │ │ void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ + void set_flags (torrent_flags_t flags) const;
│ │ │ │ + void unset_flags (torrent_flags_t flags) const;
│ │ │ │ void flush_cache () const;
│ │ │ │ void force_recheck () const;
│ │ │ │ void save_resume_data (resume_data_flags_t flags = {}) const;
│ │ │ │ - bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ bool need_save_resume_data () const;
│ │ │ │ - void queue_position_down () const;
│ │ │ │ - void queue_position_up () const;
│ │ │ │ + bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ void queue_position_bottom () const;
│ │ │ │ queue_position_t queue_position () const;
│ │ │ │ + void queue_position_down () const;
│ │ │ │ + void queue_position_up () const;
│ │ │ │ void queue_position_top () const;
│ │ │ │ void queue_position_set (queue_position_t p) const;
│ │ │ │ - void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ - , std::string const& private_key
│ │ │ │ - , std::string const& dh_params);
│ │ │ │ void set_ssl_certificate (std::string const& certificate
│ │ │ │ , std::string const& private_key
│ │ │ │ , std::string const& dh_params
│ │ │ │ , std::string const& passphrase = "");
│ │ │ │ - std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ + void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ + , std::string const& private_key
│ │ │ │ + , std::string const& dh_params);
│ │ │ │ std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │ + std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ std::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │ void piece_availability (std::vector<int>& avail) const;
│ │ │ │ void post_piece_availability () const;
│ │ │ │ - void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ - std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ - void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ + void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ + void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ + std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ + std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ + download_priority_t file_priority (file_index_t index) const;
│ │ │ │ void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │ void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ - download_priority_t file_priority (file_index_t index) const;
│ │ │ │ - std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ + void force_dht_announce () const;
│ │ │ │ void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ void force_lsd_announce () const;
│ │ │ │ - void force_dht_announce () const;
│ │ │ │ void scrape_tracker (int idx = -1) const;
│ │ │ │ - int download_limit () const;
│ │ │ │ - void set_download_limit (int limit) const;
│ │ │ │ void set_upload_limit (int limit) const;
│ │ │ │ int upload_limit () const;
│ │ │ │ + void set_download_limit (int limit) const;
│ │ │ │ + int download_limit () const;
│ │ │ │ void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │ , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │ void clear_peers ();
│ │ │ │ int max_uploads () const;
│ │ │ │ void set_max_uploads (int max_uploads) const;
│ │ │ │ - void set_max_connections (int max_connections) const;
│ │ │ │ int max_connections () const;
│ │ │ │ + void set_max_connections (int max_connections) const;
│ │ │ │ void move_storage (std::string const& save_path
│ │ │ │ , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │ ) const;
│ │ │ │ void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │ - sha1_hash info_hash () const;
│ │ │ │ info_hash_t info_hashes () const;
│ │ │ │ + sha1_hash info_hash () const;
│ │ │ │ bool operator!= (const torrent_handle& h) const;
│ │ │ │ - bool operator== (const torrent_handle& h) const;
│ │ │ │ bool operator< (const torrent_handle& h) const;
│ │ │ │ + bool operator== (const torrent_handle& h) const;
│ │ │ │ std::uint32_t id () const;
│ │ │ │ std::shared_ptr<torrent> native_handle () const;
│ │ │ │ client_data_t userdata () const;
│ │ │ │ bool in_session () const;
│ │ │ │
│ │ │ │ static constexpr add_piece_flags_t overwrite_existing = 0_bit;
│ │ │ │ static constexpr status_flags_t query_distributed_copies = 0_bit;
│ │ │ │ @@ -7434,16 +7434,16 @@
│ │ │ │ Returns true if this piece has been completely downloaded and written
│ │ │ │ to disk, and false otherwise.
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
get_peer_info() post_peer_info()
│ │ │ │
│ │ │ │ -void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ void post_peer_info () const;
│ │ │ │ +void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │
│ │ │ │
Query information about connected peers for this torrent. If the
│ │ │ │ torrent_handle is invalid, it will throw a system_error exception.
│ │ │ │
post_peer_info() is asynchronous and will trigger the posting of
│ │ │ │ a peer_info_alert. The alert contain a list of peer_info objects, one
│ │ │ │ for each connected peer.
│ │ │ │
get_peer_info() is synchronous and takes a reference to a vector
│ │ │ │ @@ -7452,16 +7452,16 @@
│ │ │ │ the vector contains information about that particular peer. See
│ │ │ │ peer_info.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
status() post_status()
│ │ │ │
│ │ │ │ -torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │
│ │ │ │
status() will return a structure with information about the status
│ │ │ │ of this torrent. If the torrent_handle is invalid, it will throw
│ │ │ │ system_error exception. See torrent_status. The flags
│ │ │ │ argument filters what information is returned in the torrent_status.
│ │ │ │ Some information in there is relatively expensive to calculate, and if
│ │ │ │ you're not interested in it (and see performance issues), you can
│ │ │ │ @@ -7476,33 +7476,33 @@
│ │ │ │
By default everything is included. The flags you can use to decide
│ │ │ │ what to include are defined in this class.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
post_download_queue() get_download_queue()
│ │ │ │
│ │ │ │ -void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ void post_download_queue () const;
│ │ │ │ +void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │
│ │ │ │
post_download_queue() triggers a download_queue_alert to be
│ │ │ │ posted.
│ │ │ │ get_download_queue() is a synchronous call and returns a vector
│ │ │ │ with information about pieces that are partially downloaded or not
│ │ │ │ downloaded but partially requested. See partial_piece_info for the
│ │ │ │ fields in the returned vector.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
set_piece_deadline() clear_piece_deadlines() reset_piece_deadline()
│ │ │ │
│ │ │ │ -void clear_piece_deadlines () const;
│ │ │ │ void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ +void clear_piece_deadlines () const;
│ │ │ │
│ │ │ │
This function sets or resets the deadline associated with a specific
│ │ │ │ piece index (index). libtorrent will attempt to download this
│ │ │ │ entire piece before the deadline expires. This is not necessarily
│ │ │ │ possible, but pieces with a more recent deadline will always be
│ │ │ │ prioritized over pieces with a deadline further ahead in time. The
│ │ │ │ deadline (and flags) of a piece can be changed by calling this
│ │ │ │ @@ -7513,22 +7513,22 @@
│ │ │ │
deadline is the number of milliseconds until this piece should be
│ │ │ │ completed.
│ │ │ │
reset_piece_deadline removes the deadline from the piece. If it
│ │ │ │ hasn't already been downloaded, it will no longer be considered a
│ │ │ │ priority.
│ │ │ │
clear_piece_deadlines() removes deadlines on all pieces in
│ │ │ │ the torrent. As if reset_piece_deadline() was called on all pieces.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
post_file_progress() file_progress()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
file_progress() post_file_progress()
│ │ │ │
│ │ │ │ void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ -std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ +std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │
│ │ │ │
This function fills in the supplied vector, or returns a vector, with
│ │ │ │ the number of bytes downloaded of each file in this torrent. The
│ │ │ │ progress values are ordered the same as the files in the
│ │ │ │ torrent_info.
│ │ │ │
This operation is not very cheap. Its complexity is O(n + mj).
│ │ │ │ Where n is the number of files, m is the number of currently
│ │ │ │ @@ -7557,24 +7557,24 @@
│ │ │ │
│ │ │ │
clear_error()
│ │ │ │
│ │ │ │ void clear_error () const;
│ │ │ │
│ │ │ │
If the torrent is in an error state (i.e. torrent_status::error is
│ │ │ │ non-empty), this will clear the error and start the torrent again.
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
replace_trackers() trackers() add_tracker() post_trackers()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
post_trackers() trackers() replace_trackers() add_tracker()
│ │ │ │
│ │ │ │ -std::vector<announce_entry> trackers () const;
│ │ │ │ -void add_tracker (announce_entry const&) const;
│ │ │ │ void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ +void add_tracker (announce_entry const&) const;
│ │ │ │ +std::vector<announce_entry> trackers () const;
│ │ │ │ void post_trackers () const;
│ │ │ │
│ │ │ │
trackers() returns the list of trackers for this torrent. The
│ │ │ │ announce entry contains both a string url which specify the
│ │ │ │ announce url for the tracker as well as an int tier, which is
│ │ │ │ specifies the order in which this tracker is tried. If you want
│ │ │ │ libtorrent to use another list of trackers for this torrent, you can
│ │ │ │ @@ -7593,36 +7593,36 @@
│ │ │ │ data will replace the original ones.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_url_seed() url_seeds() remove_url_seed()
│ │ │ │
│ │ │ │ -void remove_url_seed (std::string const& url) const;
│ │ │ │ void add_url_seed (std::string const& url) const;
│ │ │ │ +void remove_url_seed (std::string const& url) const;
│ │ │ │ std::set<std::string> url_seeds () const;
│ │ │ │
│ │ │ │
add_url_seed() adds another url to the torrent's list of url
│ │ │ │ seeds. If the given url already exists in that list, the call has no
│ │ │ │ effect. The torrent will connect to the server and try to download
│ │ │ │ pieces from it, unless it's paused, queued, checking or seeding.
│ │ │ │ remove_url_seed() removes the given url if it exists already.
│ │ │ │ url_seeds() return a set of the url seeds currently in this
│ │ │ │ torrent. Note that URLs that fails may be removed automatically from
│ │ │ │ the list.
│ │ │ │
See http seeding for more information.
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
http_seeds() add_http_seed() remove_http_seed()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
add_http_seed() remove_http_seed() http_seeds()
│ │ │ │
│ │ │ │ -std::set<std::string> http_seeds () const;
│ │ │ │ -void remove_http_seed (std::string const& url) const;
│ │ │ │ void add_http_seed (std::string const& url) const;
│ │ │ │ +void remove_http_seed (std::string const& url) const;
│ │ │ │ +std::set<std::string> http_seeds () const;
│ │ │ │
│ │ │ │
These functions are identical as the *_url_seed() variants, but
│ │ │ │ they operate on BEP 17 web seeds instead of BEP 19.
│ │ │ │
See http seeding for more information.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_extension()
│ │ │ │ @@ -7689,24 +7689,24 @@
│ │ │ │
│ │ │ │
Note
│ │ │ │
Torrents that are auto-managed may be automatically resumed again. It
│ │ │ │ does not make sense to pause an auto-managed torrent without making it
│ │ │ │ not auto-managed first. Torrents are auto-managed by default when added
│ │ │ │ to the session. For more information, see queuing.
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
unset_flags() flags() set_flags()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
flags() unset_flags() set_flags()
│ │ │ │
│ │ │ │ -void unset_flags (torrent_flags_t flags) const;
│ │ │ │ torrent_flags_t flags () const;
│ │ │ │ -void set_flags (torrent_flags_t flags) const;
│ │ │ │ void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ +void set_flags (torrent_flags_t flags) const;
│ │ │ │ +void unset_flags (torrent_flags_t flags) const;
│ │ │ │
│ │ │ │
sets and gets the torrent state flags. See torrent_flags_t.
│ │ │ │ The set_flags overload that take a mask will affect all
│ │ │ │ flags part of the mask, and set their values to what the
│ │ │ │ flags argument is set to. This allows clearing and
│ │ │ │ setting flags in a single function call.
│ │ │ │ The set_flags overload that just takes flags, sets all
│ │ │ │ @@ -7843,16 +7843,16 @@
│ │ │ │ report that they don't need to save resume data again, and skipped by
│ │ │ │ the initial loop, and thwart the counter otherwise.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
need_save_resume_data()
│ │ │ │
│ │ │ │ -bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ bool need_save_resume_data () const;
│ │ │ │ +bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │
│ │ │ │
This function returns true if anything that is stored in the resume
│ │ │ │ data has changed since the last time resume data was saved.
│ │ │ │ The overload that takes flags let you ask if specific categories
│ │ │ │ of properties have changed. These flags have the same behavior as in
│ │ │ │ the save_resume_data() call.
│ │ │ │
This is a blocking call. It will wait for a response from
│ │ │ │ @@ -7862,26 +7862,26 @@
│ │ │ │
│ │ │ │
Note
│ │ │ │
A torrent's resume data is considered saved as soon as the
│ │ │ │ save_resume_data_alert is posted. It is important to make sure this
│ │ │ │ alert is received and handled in order for this function to be
│ │ │ │ meaningful.
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
queue_position() queue_position_top() queue_position_bottom() queue_position_down() queue_position_up()
│ │ │ │ +
[report issue]
│ │ │ │ +
queue_position_bottom() queue_position_top() queue_position() queue_position_down() queue_position_up()
│ │ │ │
│ │ │ │ -void queue_position_down () const;
│ │ │ │ -void queue_position_up () const;
│ │ │ │ void queue_position_bottom () const;
│ │ │ │ queue_position_t queue_position () const;
│ │ │ │ +void queue_position_down () const;
│ │ │ │ +void queue_position_up () const;
│ │ │ │ void queue_position_top () const;
│ │ │ │
│ │ │ │
Every torrent that is added is assigned a queue position exactly one
│ │ │ │ greater than the greatest queue position of all existing torrents.
│ │ │ │ Torrents that are being seeded have -1 as their queue position, since
│ │ │ │ they're no longer in line to be downloaded.
│ │ │ │
When a torrent is removed or turns into a seed, all torrents with
│ │ │ │ @@ -7901,26 +7901,26 @@
│ │ │ │
queue_position_set()
│ │ │ │
│ │ │ │ void queue_position_set (queue_position_t p) const;
│ │ │ │
│ │ │ │
updates the position in the queue for this torrent. The relative order
│ │ │ │ of all other torrents remain intact but their numerical queue position
│ │ │ │ shifts to make space for this torrent's new position
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
set_ssl_certificate() set_ssl_certificate_buffer()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
set_ssl_certificate_buffer() set_ssl_certificate()
│ │ │ │
│ │ │ │ -void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ - , std::string const& private_key
│ │ │ │ - , std::string const& dh_params);
│ │ │ │ void set_ssl_certificate (std::string const& certificate
│ │ │ │ , std::string const& private_key
│ │ │ │ , std::string const& dh_params
│ │ │ │ , std::string const& passphrase = "");
│ │ │ │ +void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ │ + , std::string const& private_key
│ │ │ │ + , std::string const& dh_params);
│ │ │ │
│ │ │ │
For SSL torrents, use this to specify a path to a .pem file to use as
│ │ │ │ this client's certificate. The certificate must be signed by the
│ │ │ │ certificate in the .torrent file to be valid.
│ │ │ │
The set_ssl_certificate_buffer() overload takes the actual certificate,
│ │ │ │ private key and DH params as strings, rather than paths to files.
│ │ │ │
cert is a path to the (signed) certificate in .pem format
│ │ │ │ @@ -7936,21 +7936,21 @@
│ │ │ │
Note that when a torrent first starts up, and it needs a certificate,
│ │ │ │ it will suspend connecting to any peers until it has one. It's
│ │ │ │ typically desirable to resume the torrent after setting the SSL
│ │ │ │ certificate.
│ │ │ │
If you receive a torrent_need_cert_alert, you need to call this to
│ │ │ │ provide a valid cert. If you don't have a cert you won't be allowed to
│ │ │ │ connect to any peers.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
torrent_file() torrent_file_with_hashes()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
torrent_file_with_hashes() torrent_file()
│ │ │ │
│ │ │ │ -std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │ +std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │
│ │ │ │
torrent_file() returns a pointer to the torrent_info object
│ │ │ │ associated with this torrent. The torrent_info object may be a copy
│ │ │ │ of the internal object. If the torrent doesn't have metadata, the
│ │ │ │ pointer will not be initialized (i.e. a nullptr). The torrent may be
│ │ │ │ in a state without metadata only if it was started without a .torrent
│ │ │ │ file, e.g. by being added by magnet link.
│ │ │ │ @@ -8005,19 +8005,19 @@
│ │ │ │ seeding the availability for all pieces is reported as 0.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
piece_priority() prioritize_pieces() get_piece_priorities()
│ │ │ │
│ │ │ │ -void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ -std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ -void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ +void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ +void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ +std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │
│ │ │ │
These functions are used to set and get the priority of individual
│ │ │ │ pieces. By default all pieces have priority 4. That means that the
│ │ │ │ random rarest first algorithm is effectively active for all pieces.
│ │ │ │ You may however change the priority of individual pieces. There are 8
│ │ │ │ priority levels. 0 means not to download the piece at all. Otherwise,
│ │ │ │ lower priority values means less likely to be picked. Piece priority
│ │ │ │ @@ -8045,18 +8045,18 @@
│ │ │ │ usage of file- and piece priorities.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
file_priority() get_file_priorities() prioritize_files()
│ │ │ │
│ │ │ │ +std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ +download_priority_t file_priority (file_index_t index) const;
│ │ │ │ void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │ void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ -download_priority_t file_priority (file_index_t index) const;
│ │ │ │ -std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │
│ │ │ │
index must be in the range [0, number_of_files).
│ │ │ │
file_priority() queries or sets the priority of file index.
│ │ │ │
prioritize_files() takes a vector that has at as many elements as
│ │ │ │ there are files in the torrent. Each entry is the priority of that
│ │ │ │ file. The function sets the priorities of all the pieces in the
│ │ │ │ torrent based on the vector.
│ │ │ │ @@ -8079,23 +8079,23 @@
│ │ │ │
file_prio_alert.
│ │ │ │
When combining file- and piece priorities, the resume file will record
│ │ │ │ both. When loading the resume data, the file priorities will be applied
│ │ │ │ first, then the piece priorities.
│ │ │ │
Moving data from a file into the part file is currently not
│ │ │ │ supported. If a file has its priority set to 0 after it has already
│ │ │ │ been created, it will not be moved into the partfile.
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
force_dht_announce() force_lsd_announce() force_reannounce()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
force_lsd_announce() force_reannounce() force_dht_announce()
│ │ │ │
│ │ │ │ +void force_dht_announce () const;
│ │ │ │ void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ void force_lsd_announce () const;
│ │ │ │ -void force_dht_announce () const;
│ │ │ │
│ │ │ │
force_reannounce() will force this torrent to do another tracker
│ │ │ │ request, to receive new peers. The seconds argument specifies how
│ │ │ │ many seconds from now to issue the tracker announces.
│ │ │ │
If the tracker's min_interval has not passed since the last
│ │ │ │ announce, the forced announce will be scheduled to happen immediately
│ │ │ │ as the min_interval expires. This is to honor trackers minimum
│ │ │ │ @@ -8119,25 +8119,25 @@
│ │ │ │ idx is >= 0, the tracker with the specified index will scraped.
│ │ │ │
A scrape request queries the tracker for statistics such as total
│ │ │ │ number of incomplete peers, complete peers, number of downloads etc.
│ │ │ │
This request will specifically update the num_complete and
│ │ │ │ num_incomplete fields in the torrent_status struct once it
│ │ │ │ completes. When it completes, it will generate a scrape_reply_alert.
│ │ │ │ If it fails, it will generate a scrape_failed_alert.
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
set_download_limit() upload_limit() download_limit() set_upload_limit()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
download_limit() set_upload_limit() upload_limit() set_download_limit()
│ │ │ │
│ │ │ │ -int download_limit () const;
│ │ │ │ -void set_download_limit (int limit) const;
│ │ │ │ void set_upload_limit (int limit) const;
│ │ │ │ int upload_limit () const;
│ │ │ │ +void set_download_limit (int limit) const;
│ │ │ │ +int download_limit () const;
│ │ │ │
│ │ │ │
set_upload_limit will limit the upload bandwidth used by this
│ │ │ │ particular torrent to the limit you set. It is given as the number of
│ │ │ │ bytes per second the torrent is allowed to upload.
│ │ │ │ set_download_limit works the same way but for download bandwidth
│ │ │ │ instead of upload bandwidth. Note that setting a higher limit on a
│ │ │ │ torrent then the global limit
│ │ │ │ @@ -8188,16 +8188,16 @@
│ │ │ │ settings_pack.
│ │ │ │
max_uploads() returns the current settings.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
set_max_connections() max_connections()
│ │ │ │
│ │ │ │ -void set_max_connections (int max_connections) const;
│ │ │ │ int max_connections () const;
│ │ │ │ +void set_max_connections (int max_connections) const;
│ │ │ │
│ │ │ │
set_max_connections() sets the maximum number of connection this
│ │ │ │ torrent will open. If all connections are used up, incoming
│ │ │ │ connections may be refused or poor connections may be closed. This
│ │ │ │ must be at least 2. The default is unlimited number of connections. If
│ │ │ │ -1 is given to the function, it means unlimited. There is also a
│ │ │ │ global limit of the number of connections, set by
│ │ │ │ @@ -8260,37 +8260,37 @@
│ │ │ │
rename_file()
│ │ │ │
│ │ │ │ void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │
│ │ │ │
Renames the file with the given index asynchronously. The rename
│ │ │ │ operation is complete when either a file_renamed_alert or
│ │ │ │ file_rename_failed_alert is posted.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
info_hashes() info_hash()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
info_hash() info_hashes()
│ │ │ │
│ │ │ │ -sha1_hash info_hash () const;
│ │ │ │ info_hash_t info_hashes () const;
│ │ │ │ +sha1_hash info_hash () const;
│ │ │ │
│ │ │ │
returns the info-hash(es) of the torrent. If this handle is to a
│ │ │ │ torrent that hasn't loaded yet (for instance by being added) by a
│ │ │ │ URL, the returned value is undefined.
│ │ │ │ The info_hash() returns the SHA-1 info-hash for v1 torrents and a
│ │ │ │ truncated hash for v2 torrents. For the full v2 info-hash, use
│ │ │ │ info_hashes() instead.
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
operator!=() operator==() operator<()
│ │ │ │ +
operator==() operator!=() operator<()
│ │ │ │
│ │ │ │ bool operator!= (const torrent_handle& h) const;
│ │ │ │ -bool operator== (const torrent_handle& h) const;
│ │ │ │ bool operator< (const torrent_handle& h) const;
│ │ │ │ +bool operator== (const torrent_handle& h) const;
│ │ │ │
│ │ │ │
comparison operators. The order of the torrents is unspecified
│ │ │ │ but stable.
│ │ │ │
[report issue]
│ │ │ │
id()
│ │ │ │
│ │ │ │ @@ -8542,21 +8542,21 @@
│ │ │ │ the constructor. The callbacks will be run in the network thread.
│ │ │ │
│ │ │ │ struct disk_interface
│ │ │ │ {
│ │ │ │ virtual storage_holder new_torrent (storage_params const& p
│ │ │ │ , std::shared_ptr<void> const& torrent) = 0;
│ │ │ │ virtual void remove_torrent (storage_index_t) = 0;
│ │ │ │ + virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ + , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │ │ virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ │ , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ │ , std::function<void(storage_error const&)> handler
│ │ │ │ , disk_job_flags_t flags = {}) = 0;
│ │ │ │ - virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ - , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ - , disk_job_flags_t flags = {}) = 0;
│ │ │ │ virtual void async_hash (storage_index_t storage, piece_index_t piece, span<sha256_hash> v2
│ │ │ │ , disk_job_flags_t flags
│ │ │ │ , std::function<void(piece_index_t, sha1_hash const&, storage_error const&)> handler) = 0;
│ │ │ │ virtual void async_hash2 (storage_index_t storage, piece_index_t piece, int offset, disk_job_flags_t flags
│ │ │ │ , std::function<void(piece_index_t, sha256_hash const&, storage_error const&)> handler) = 0;
│ │ │ │ virtual void async_move_storage (storage_index_t storage, std::string p, move_flags_t flags
│ │ │ │ , std::function<void(status_t, std::string const&, storage_error const&)> handler) = 0;
│ │ │ │ @@ -8613,21 +8613,21 @@
│ │ │ │ delete any files from disk, just to clean up any resources associated
│ │ │ │ with the specified storage.
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
async_read() async_write()
│ │ │ │
│ │ │ │ +virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ + , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │ │ virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ │ , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ │ , std::function<void(storage_error const&)> handler
│ │ │ │ , disk_job_flags_t flags = {}) = 0;
│ │ │ │ -virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ - , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ - , disk_job_flags_t flags = {}) = 0;
│ │ │ │
│ │ │ │
perform a read or write operation from/to the specified storage
│ │ │ │ index and the specified request. When the operation completes, call
│ │ │ │ handler possibly with a disk_buffer_holder, holding the buffer with
│ │ │ │ the result. Flags may be set to affect the read operation. See
│ │ │ │ disk_job_flags_t.
│ │ │ │
The disk_observer is a callback to indicate that
│ │ │ │ @@ -8878,22 +8878,22 @@
│ │ │ │ internal libtorrent torrent object to tie the storage object allocated
│ │ │ │ for a torrent to the lifetime of the internal torrent object. When a
│ │ │ │ torrent is removed from the session, this holder is destructed and will
│ │ │ │ inform the disk object.
│ │ │ │
│ │ │ │ struct storage_holder
│ │ │ │ {
│ │ │ │ + storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ ~storage_holder ();
│ │ │ │ storage_holder () = default;
│ │ │ │ - storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ explicit operator bool () const;
│ │ │ │ operator storage_index_t () const;
│ │ │ │ void reset ();
│ │ │ │ - storage_holder& operator= (storage_holder const&) = delete;
│ │ │ │ storage_holder (storage_holder const&) = delete;
│ │ │ │ + storage_holder& operator= (storage_holder const&) = delete;
│ │ │ │ storage_holder (storage_holder&& rhs) noexcept;
│ │ │ │ storage_holder& operator= (storage_holder&& rhs) noexcept;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
disk_observer
│ │ │ │ @@ -8933,16 +8933,16 @@
│ │ │ │
The disk buffer holder acts like a unique_ptr that frees a disk buffer
│ │ │ │ when it's destructed
│ │ │ │
If this buffer holder is moved-from, default constructed or reset,
│ │ │ │ data() will return nullptr.
│ │ │ │
│ │ │ │ struct disk_buffer_holder
│ │ │ │ {
│ │ │ │ - disk_buffer_holder& operator= (disk_buffer_holder&&) & noexcept;
│ │ │ │ disk_buffer_holder (disk_buffer_holder&&) noexcept;
│ │ │ │ + disk_buffer_holder& operator= (disk_buffer_holder&&) & noexcept;
│ │ │ │ disk_buffer_holder& operator= (disk_buffer_holder const&) = delete;
│ │ │ │ disk_buffer_holder (disk_buffer_holder const&) = delete;
│ │ │ │ disk_buffer_holder (buffer_allocator_interface& alloc
│ │ │ │ , char* buf, int sz) noexcept;
│ │ │ │ disk_buffer_holder () noexcept = default;
│ │ │ │ ~disk_buffer_holder ();
│ │ │ │ char* data () const noexcept;
│ │ │ │ @@ -9019,21 +9019,21 @@
│ │ │ │ settings_interface
│ │ │ │ Declared in "libtorrent/settings_pack.hpp"
│ │ │ │ the common interface to settings_pack and the internal representation of
│ │ │ │ settings.
│ │ │ │
│ │ │ │ struct settings_interface
│ │ │ │ {
│ │ │ │ + virtual void set_str (int name, std::string val) = 0;
│ │ │ │ virtual bool has_val (int name) const = 0;
│ │ │ │ virtual void set_int (int name, int val) = 0;
│ │ │ │ - virtual void set_str (int name, std::string val) = 0;
│ │ │ │ virtual void set_bool (int name, bool val) = 0;
│ │ │ │ virtual std::string const& get_str (int name) const = 0;
│ │ │ │ - virtual bool get_bool (int name) const = 0;
│ │ │ │ virtual int get_int (int name) const = 0;
│ │ │ │ + virtual bool get_bool (int name) const = 0;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
file_open_mode_t
│ │ │ │
Declared in "libtorrent/disk_interface.hpp"
│ │ │ │
│ │ │ │ @@ -10129,26 +10129,26 @@
│ │ │ │ torrent_handle::move_storage. This is useful to synchronize with the
│ │ │ │ actual disk. The storage_path() member return the new path of the
│ │ │ │ storage.
│ │ │ │
│ │ │ │ struct storage_moved_alert final : torrent_alert
│ │ │ │ {
│ │ │ │ std::string message () const override;
│ │ │ │ - char const* old_path () const;
│ │ │ │ char const* storage_path () const;
│ │ │ │ + char const* old_path () const;
│ │ │ │
│ │ │ │ static constexpr alert_category_t static_category = alert_category::storage;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
storage_path() old_path()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
old_path() storage_path()
│ │ │ │
│ │ │ │ -char const* old_path () const;
│ │ │ │ char const* storage_path () const;
│ │ │ │ +char const* old_path () const;
│ │ │ │
│ │ │ │
the path the torrent was moved to and from, respectively.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
storage_moved_failed_alert
│ │ │ │
Declared in "libtorrent/alert_types.hpp"
│ │ │ │ @@ -11786,27 +11786,27 @@
│ │ │ │
posted in response to a call to session::dht_live_nodes(). It contains the
│ │ │ │ live nodes from the DHT routing table of one of the DHT nodes running
│ │ │ │ locally.
│ │ │ │
│ │ │ │ struct dht_live_nodes_alert final : alert
│ │ │ │ {
│ │ │ │ std::string message () const override;
│ │ │ │ - int num_nodes () const;
│ │ │ │ std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const;
│ │ │ │ + int num_nodes () const;
│ │ │ │
│ │ │ │ static constexpr alert_category_t static_category = alert_category::dht;
│ │ │ │ sha1_hash node_id;
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
nodes() num_nodes()
│ │ │ │
│ │ │ │ -int num_nodes () const;
│ │ │ │ std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const;
│ │ │ │ +int num_nodes () const;
│ │ │ │
│ │ │ │
the number of nodes in the routing table and the actual nodes.
│ │ │ │
[report issue]
│ │ │ │ - node_id
│ │ │ │ - the local DHT node's node-ID this routing table belongs to
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │ @@ -12141,16 +12141,16 @@
│ │ │ │
- list of trackers and their status for the torrent
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
alert_cast()
│ │ │ │
Declared in "libtorrent/alert.hpp"
│ │ │ │
│ │ │ │ -template <typename T> T* alert_cast (alert* a);
│ │ │ │ template <typename T> T const* alert_cast (alert const* a);
│ │ │ │ +template <typename T> T* alert_cast (alert* a);
│ │ │ │
│ │ │ │
When you get an alert, you can use alert_cast<> to attempt to cast the
│ │ │ │ pointer to a specific alert type, in order to query it for more
│ │ │ │ information.
│ │ │ │
│ │ │ │
Note
│ │ │ │
alert_cast<> can only cast to an exact alert type, not a base class
│ │ │ │ @@ -12527,25 +12527,25 @@
│ │ │ │
│ │ │ │
counters
│ │ │ │
Declared in "libtorrent/performance_counters.hpp"
│ │ │ │
│ │ │ │ struct counters
│ │ │ │ {
│ │ │ │ counters () ;
│ │ │ │ - counters (counters const&) ;
│ │ │ │ counters& operator= (counters const&) & ;
│ │ │ │ + counters (counters const&) ;
│ │ │ │ std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ std::int64_t operator[] (int i) const ;
│ │ │ │ - void blend_stats_counter (int c, std::int64_t value, int ratio) ;
│ │ │ │ void set_value (int c, std::int64_t value) ;
│ │ │ │ + void blend_stats_counter (int c, std::int64_t value, int ratio) ;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
operator[]() inc_stats_counter()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
inc_stats_counter() operator[]()
│ │ │ │
│ │ │ │ std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ std::int64_t operator[] (int i) const ;
│ │ │ │
│ │ │ │
returns the new value
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │ @@ -12632,19 +12632,19 @@
│ │ │ │ the IPv4 range, and the equivalent range covering all addresses for the
│ │ │ │ IPv6 range).
│ │ │ │
A default constructed ip_filter does not filter any address.
│ │ │ │
│ │ │ │ struct ip_filter
│ │ │ │ {
│ │ │ │ ip_filter (ip_filter&&);
│ │ │ │ - ip_filter& operator= (ip_filter const&);
│ │ │ │ - ip_filter& operator= (ip_filter&&);
│ │ │ │ - ip_filter (ip_filter const&);
│ │ │ │ ip_filter ();
│ │ │ │ ~ip_filter ();
│ │ │ │ + ip_filter (ip_filter const&);
│ │ │ │ + ip_filter& operator= (ip_filter&&);
│ │ │ │ + ip_filter& operator= (ip_filter const&);
│ │ │ │ bool empty () const;
│ │ │ │ void add_rule (address const& first, address const& last, std::uint32_t flags);
│ │ │ │ std::uint32_t access (address const& addr) const;
│ │ │ │ filter_tuple_t export_filter () const;
│ │ │ │
│ │ │ │ enum access_flags
│ │ │ │ {
│ │ │ │ @@ -12728,20 +12728,20 @@
│ │ │ │ the port filter maps non-overlapping port ranges to flags. This
│ │ │ │ is primarily used to indicate whether a range of ports should
│ │ │ │ be connected to or not. The default is to have the full port
│ │ │ │ range (0-65535) set to flag 0.
│ │ │ │
│ │ │ │ class port_filter
│ │ │ │ {
│ │ │ │ + port_filter (port_filter const&);
│ │ │ │ port_filter (port_filter&&);
│ │ │ │ port_filter& operator= (port_filter const&);
│ │ │ │ - port_filter ();
│ │ │ │ - port_filter (port_filter const&);
│ │ │ │ port_filter& operator= (port_filter&&);
│ │ │ │ ~port_filter ();
│ │ │ │ + port_filter ();
│ │ │ │ void add_rule (std::uint16_t first, std::uint16_t last, std::uint32_t flags);
│ │ │ │ std::uint32_t access (std::uint16_t port) const;
│ │ │ │
│ │ │ │ enum access_flags
│ │ │ │ {
│ │ │ │ blocked,
│ │ │ │ };
│ │ │ │ @@ -12809,46 +12809,46 @@
│ │ │ │ The entry class represents one node in a bencoded hierarchy. It works as a
│ │ │ │ variant type, it can be either a list, a dictionary (std::map), an integer
│ │ │ │ or a string.
│ │ │ │
│ │ │ │ class entry
│ │ │ │ {
│ │ │ │ data_type type () const;
│ │ │ │ - entry (dictionary_type);
│ │ │ │ entry (list_type);
│ │ │ │ - entry (integer_type);
│ │ │ │ - entry (span<char const>);
│ │ │ │ entry (preformatted_type);
│ │ │ │ + entry (span<char const>);
│ │ │ │ + entry (dictionary_type);
│ │ │ │ + entry (integer_type);
│ │ │ │ entry (U v);
│ │ │ │ entry (data_type t);
│ │ │ │ entry (bdecode_node const& n);
│ │ │ │ - entry& operator= (entry const&) &;
│ │ │ │ - entry& operator= (entry&&) & noexcept;
│ │ │ │ - entry& operator= (bdecode_node const&) &;
│ │ │ │ - entry& operator= (span<char const>) &;
│ │ │ │ entry& operator= (integer_type) &;
│ │ │ │ - entry& operator= (dictionary_type) &;
│ │ │ │ entry& operator= (list_type) &;
│ │ │ │ entry& operator= (preformatted_type) &;
│ │ │ │ + entry& operator= (dictionary_type) &;
│ │ │ │ + entry& operator= (entry&&) & noexcept;
│ │ │ │ + entry& operator= (entry const&) &;
│ │ │ │ + entry& operator= (bdecode_node const&) &;
│ │ │ │ + entry& operator= (span<char const>) &;
│ │ │ │ entry& operator= (U v) &;
│ │ │ │ - integer_type& integer ();
│ │ │ │ preformatted_type const& preformatted () const;
│ │ │ │ string_type const& string () const;
│ │ │ │ + list_type& list ();
│ │ │ │ list_type const& list () const;
│ │ │ │ - preformatted_type& preformatted ();
│ │ │ │ - integer_type const& integer () const;
│ │ │ │ dictionary_type& dict ();
│ │ │ │ dictionary_type const& dict () const;
│ │ │ │ + preformatted_type& preformatted ();
│ │ │ │ + integer_type const& integer () const;
│ │ │ │ string_type& string ();
│ │ │ │ - list_type& list ();
│ │ │ │ + integer_type& integer ();
│ │ │ │ void swap (entry& e);
│ │ │ │ - entry& operator[] (string_view key);
│ │ │ │ entry const& operator[] (string_view key) const;
│ │ │ │ - entry* find_key (string_view key);
│ │ │ │ + entry& operator[] (string_view key);
│ │ │ │ entry const* find_key (string_view key) const;
│ │ │ │ + entry* find_key (string_view key);
│ │ │ │ std::string to_string (bool single_line = false) const;
│ │ │ │
│ │ │ │ enum data_type
│ │ │ │ {
│ │ │ │ int_t,
│ │ │ │ string_t,
│ │ │ │ list_t,
│ │ │ │ @@ -12864,19 +12864,19 @@
│ │ │ │ data_type type () const;
│ │ │ │
│ │ │ │ returns the concrete type of the entry
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
entry()
│ │ │ │
│ │ │ │ -entry (dictionary_type);
│ │ │ │ entry (list_type);
│ │ │ │ -entry (integer_type);
│ │ │ │ -entry (span<char const>);
│ │ │ │ entry (preformatted_type);
│ │ │ │ +entry (span<char const>);
│ │ │ │ +entry (dictionary_type);
│ │ │ │ +entry (integer_type);
│ │ │ │
│ │ │ │
constructors directly from a specific type.
│ │ │ │ The content of the argument is copied into the
│ │ │ │ newly constructed entry
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
entry()
│ │ │ │ @@ -12892,43 +12892,43 @@
│ │ │ │
entry (bdecode_node const& n);
│ │ │ │
│ │ │ │
construct from bdecode_node parsed form (see bdecode())
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
operator=()
│ │ │ │
│ │ │ │ -entry& operator= (entry const&) &;
│ │ │ │ -entry& operator= (entry&&) & noexcept;
│ │ │ │ -entry& operator= (bdecode_node const&) &;
│ │ │ │ -entry& operator= (span<char const>) &;
│ │ │ │ entry& operator= (integer_type) &;
│ │ │ │ -entry& operator= (dictionary_type) &;
│ │ │ │ entry& operator= (list_type) &;
│ │ │ │ entry& operator= (preformatted_type) &;
│ │ │ │ +entry& operator= (dictionary_type) &;
│ │ │ │ +entry& operator= (entry&&) & noexcept;
│ │ │ │ +entry& operator= (entry const&) &;
│ │ │ │ +entry& operator= (bdecode_node const&) &;
│ │ │ │ +entry& operator= (span<char const>) &;
│ │ │ │
│ │ │ │
copies the structure of the right hand side into this
│ │ │ │ entry.
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
operator[]()
│ │ │ │
│ │ │ │ -entry& operator[] (string_view key);
│ │ │ │ entry const& operator[] (string_view key) const;
│ │ │ │ +entry& operator[] (string_view key);
│ │ │ │
│ │ │ │
All of these functions requires the entry to be a dictionary, if it
│ │ │ │ isn't they will throw system_error.
│ │ │ │
The non-const versions of the operator[] will return a reference
│ │ │ │ to either the existing element at the given key or, if there is no
│ │ │ │ element with the given key, a reference to a newly inserted element at
│ │ │ │ that key.
│ │ │ │
The const version of operator[] will only return a reference to an
│ │ │ │ existing element at the given key. If the key is not found, it will
│ │ │ │ throw system_error.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
find_key()
│ │ │ │
│ │ │ │ -entry* find_key (string_view key);
│ │ │ │ entry const* find_key (string_view key) const;
│ │ │ │ +entry* find_key (string_view key);
│ │ │ │
│ │ │ │
These functions requires the entry to be a dictionary, if it isn't
│ │ │ │ they will throw system_error.
│ │ │ │
They will look for an element at the given key in the dictionary, if
│ │ │ │ the element cannot be found, they will return nullptr. If an element
│ │ │ │ with the given key is found, the return a pointer to it.
│ │ │ │
[report issue]
│ │ │ │ @@ -13127,61 +13127,61 @@
│ │ │ │
This class holds state for creating a torrent. After having added
│ │ │ │ all information to it, call create_torrent::generate() to generate
│ │ │ │ the torrent. The entry that's returned can then be bencoded into a
│ │ │ │ .torrent file using bencode().
│ │ │ │
│ │ │ │ struct create_torrent
│ │ │ │ {
│ │ │ │ + explicit create_torrent (torrent_info const& ti);
│ │ │ │ explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ │ , create_flags_t flags = {});
│ │ │ │ - explicit create_torrent (torrent_info const& ti);
│ │ │ │ - entry generate () const;
│ │ │ │ std::vector<char> generate_buf () const;
│ │ │ │ + entry generate () const;
│ │ │ │ file_storage const& files () const;
│ │ │ │ void set_comment (char const* str);
│ │ │ │ void set_creator (char const* str);
│ │ │ │ void set_creation_date (std::time_t timestamp);
│ │ │ │ void set_hash (piece_index_t index, sha1_hash const& h);
│ │ │ │ void set_hash2 (file_index_t file, piece_index_t::diff_type piece, sha256_hash const& h);
│ │ │ │ - void add_url_seed (string_view url);
│ │ │ │ void add_http_seed (string_view url);
│ │ │ │ + void add_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);
│ │ │ │ - bool priv () const;
│ │ │ │ void set_priv (bool p);
│ │ │ │ + bool priv () 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;
│ │ │ │ - void add_collection (string_view c);
│ │ │ │ void add_similar_torrent (sha1_hash ih);
│ │ │ │ + void add_collection (string_view c);
│ │ │ │
│ │ │ │ static constexpr create_flags_t modification_time = 2_bit;
│ │ │ │ static constexpr create_flags_t symlinks = 3_bit;
│ │ │ │ static constexpr create_flags_t v2_only = 5_bit;
│ │ │ │ static constexpr create_flags_t v1_only = 6_bit;
│ │ │ │ static constexpr create_flags_t canonical_files = 7_bit;
│ │ │ │ static constexpr create_flags_t no_attributes = 8_bit;
│ │ │ │ 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
│ │ │ │ @@ -13200,16 +13200,16 @@
│ │ │ │ entire duration of the create_torrent object.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
generate() generate_buf()
│ │ │ │
│ │ │ │ -entry generate () const;
│ │ │ │ std::vector<char> generate_buf () const;
│ │ │ │ +entry generate () const;
│ │ │ │
│ │ │ │
This function will generate the .torrent file as a bencode tree, or a
│ │ │ │ bencoded into a buffer.
│ │ │ │ In order to encode the entry into a flat file, use the bencode() function.
│ │ │ │
The function returning an entry may be useful to add custom entries
│ │ │ │ to the torrent file before bencoding it and saving it to disk.
│ │ │ │
Whether the resulting torrent object is v1, v2 or hybrid depends on
│ │ │ │ @@ -13297,16 +13297,16 @@
│ │ │ │ This function will throw std::system_error if it is called on an
│ │ │ │ object constructed with the v1_only flag.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_url_seed() add_http_seed()
│ │ │ │
│ │ │ │ -void add_url_seed (string_view url);
│ │ │ │ void add_http_seed (string_view url);
│ │ │ │ +void add_url_seed (string_view url);
│ │ │ │
│ │ │ │
This adds a url seed to the torrent. You can have any number of url seeds. For a
│ │ │ │ single file torrent, this should be an HTTP url, pointing to a file with identical
│ │ │ │ content as the file of the torrent. For a multi-file torrent, it should point to
│ │ │ │ a directory containing a directory with the same name as this torrent, and all the
│ │ │ │ files of the torrent in it.
│ │ │ │
The second function, add_http_seed() adds an HTTP seed instead.
│ │ │ │ @@ -13345,16 +13345,16 @@
│ │ │ │
The string is not the path to the cert, it's the actual content of the
│ │ │ │ certificate.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
priv() set_priv()
│ │ │ │
│ │ │ │ -bool priv () const;
│ │ │ │ void set_priv (bool p);
│ │ │ │ +bool priv () const;
│ │ │ │
│ │ │ │
Sets and queries the private flag of the torrent.
│ │ │ │ Torrents with the private flag set ask the client to not use any other
│ │ │ │ sources than the tracker for peers, and to not use DHT to advertise itself publicly,
│ │ │ │ only the tracker.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │ @@ -13405,16 +13405,16 @@
│ │ │ │ last one.
piece_size() returns the size of the specified piece.
│ │ │ │ these functions are just forwarding to the associated
file_storage.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_similar_torrent() add_collection()
│ │ │ │
│ │ │ │ -void add_collection (string_view c);
│ │ │ │ void add_similar_torrent (sha1_hash ih);
│ │ │ │ +void add_collection (string_view c);
│ │ │ │
│ │ │ │
Add similar torrents (by info-hash) or collections of similar torrents.
│ │ │ │ Similar torrents are expected to share some files with this torrent.
│ │ │ │ Torrents sharing a collection name with this torrent are also expected
│ │ │ │ to share files with this torrent. A torrent may have more than one
│ │ │ │ collection and more than one similar torrents. For more information,
│ │ │ │ see BEP 38.
│ │ │ │ @@ -13503,27 +13503,27 @@
│ │ │ │ constructor.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
set_piece_hashes()
│ │ │ │
Declared in "libtorrent/create_torrent.hpp"
│ │ │ │
│ │ │ │ void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ - , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p, error_code& ec);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p);
│ │ │ │ inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ - , settings_interface const& settings
│ │ │ │ , std::function<void(piece_index_t)> const& f);
│ │ │ │ inline void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ + , settings_interface const& settings
│ │ │ │ , std::function<void(piece_index_t)> const& f);
│ │ │ │ void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ + , settings_interface const& settings
│ │ │ │ , 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
│ │ │ │ + , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ , 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:
│ │ │ │
│ │ │ │ @@ -13538,25 +13538,25 @@
│ │ │ │ bitfield
│ │ │ │ Declared in "libtorrent/bitfield.hpp"
│ │ │ │ The bitfield type stores any number of bits as a bitfield
│ │ │ │ in a heap allocated array.
│ │ │ │
│ │ │ │ struct bitfield
│ │ │ │ {
│ │ │ │ - bitfield () noexcept = default;
│ │ │ │ - bitfield (char const* b, int bits);
│ │ │ │ + explicit bitfield (int bits);
│ │ │ │ bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ - bitfield (int bits, bool val);
│ │ │ │ + bitfield (char const* b, int bits);
│ │ │ │ + bitfield () noexcept = default;
│ │ │ │ bitfield (bitfield const& rhs);
│ │ │ │ - explicit bitfield (int bits);
│ │ │ │ + bitfield (int bits, bool val);
│ │ │ │ void assign (char const* b, int const bits);
│ │ │ │ - bool operator[] (int index) const noexcept;
│ │ │ │ bool get_bit (int index) const noexcept;
│ │ │ │ - void set_bit (int index) noexcept;
│ │ │ │ + bool operator[] (int index) const noexcept;
│ │ │ │ void clear_bit (int index) noexcept;
│ │ │ │ + void set_bit (int index) noexcept;
│ │ │ │ bool all_set () const noexcept;
│ │ │ │ bool none_set () const noexcept;
│ │ │ │ int size () const noexcept;
│ │ │ │ int num_words () const noexcept;
│ │ │ │ int num_bytes () const noexcept;
│ │ │ │ bool empty () const noexcept;
│ │ │ │ char* data () noexcept;
│ │ │ │ @@ -13567,20 +13567,20 @@
│ │ │ │ int find_last_clear () const noexcept;
│ │ │ │ bool operator== (lt::bitfield const& rhs) const;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
bitfield()
│ │ │ │
│ │ │ │ -bitfield () noexcept = default;
│ │ │ │ -bitfield (char const* b, int bits);
│ │ │ │ +explicit bitfield (int bits);
│ │ │ │ bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ -bitfield (int bits, bool val);
│ │ │ │ +bitfield (char const* b, int bits);
│ │ │ │ +bitfield () noexcept = default;
│ │ │ │ bitfield (bitfield const& rhs);
│ │ │ │ -explicit bitfield (int bits);
│ │ │ │ +bitfield (int bits, bool val);
│ │ │ │
│ │ │ │
constructs a new bitfield. The default constructor creates an empty
│ │ │ │ bitfield. bits is the size of the bitfield (specified in bits).
│ │ │ │ val is the value to initialize the bits to. If not specified
│ │ │ │ all bits are initialized to 0.
│ │ │ │
The constructor taking a pointer b and bits copies a bitfield
│ │ │ │ from the specified buffer, and bits number of bits (rounded up to
│ │ │ │ @@ -13589,30 +13589,30 @@
│ │ │ │
│ │ │ │
assign()
│ │ │ │
│ │ │ │ void assign (char const* b, int const bits);
│ │ │ │
│ │ │ │
copy bitfield from buffer b of bits number of bits, rounded up to
│ │ │ │ the nearest byte boundary.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
operator[]() get_bit()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_bit() operator[]()
│ │ │ │
│ │ │ │ -bool operator[] (int index) const noexcept;
│ │ │ │ bool get_bit (int index) const noexcept;
│ │ │ │ +bool operator[] (int index) const noexcept;
│ │ │ │
│ │ │ │
query bit at index. Returns true if bit is 1, otherwise false.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
clear_bit() set_bit()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_bit() clear_bit()
│ │ │ │
│ │ │ │ -void set_bit (int index) noexcept;
│ │ │ │ void clear_bit (int index) noexcept;
│ │ │ │ +void set_bit (int index) noexcept;
│ │ │ │
│ │ │ │
set bit at index to 0 (clear_bit) or 1 (set_bit).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
all_set()
│ │ │ │
│ │ │ │ bool all_set () const noexcept;
│ │ │ │ @@ -13710,32 +13710,32 @@
│ │ │ │ The built-in software version of sha1-algorithm was implemented
│ │ │ │ by Steve Reid and released as public domain.
│ │ │ │ For more info, see src/sha1.cpp.
│ │ │ │
│ │ │ │ class hasher
│ │ │ │ {
│ │ │ │ hasher ();
│ │ │ │ - hasher& operator= (hasher const&) &;
│ │ │ │ - hasher (hasher const&);
│ │ │ │ hasher (char const* data, int len);
│ │ │ │ + hasher& operator= (hasher const&) &;
│ │ │ │ explicit hasher (span<char const> data);
│ │ │ │ + hasher (hasher const&);
│ │ │ │ hasher& update (char const* data, int len);
│ │ │ │ hasher& update (span<char const> data);
│ │ │ │ sha1_hash final ();
│ │ │ │ void reset ();
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
hasher() operator=()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
operator=() hasher()
│ │ │ │
│ │ │ │ -hasher& operator= (hasher const&) &;
│ │ │ │ -hasher (hasher const&);
│ │ │ │ hasher (char const* data, int len);
│ │ │ │ +hasher& operator= (hasher const&) &;
│ │ │ │ explicit hasher (span<char const> data);
│ │ │ │ +hasher (hasher const&);
│ │ │ │
│ │ │ │
this is the same as default constructing followed by a call to
│ │ │ │ update(data, len).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
update()
│ │ │ │
│ │ │ │ @@ -13764,33 +13764,33 @@
│ │ │ │
│ │ │ │
hasher256
│ │ │ │
Declared in "libtorrent/hasher.hpp"
│ │ │ │
│ │ │ │ class hasher256
│ │ │ │ {
│ │ │ │ hasher256 ();
│ │ │ │ + hasher256 (hasher256 const&);
│ │ │ │ + explicit hasher256 (span<char const> data);
│ │ │ │ hasher256& operator= (hasher256 const&) &;
│ │ │ │ hasher256 (char const* data, int len);
│ │ │ │ - explicit hasher256 (span<char const> data);
│ │ │ │ - hasher256 (hasher256 const&);
│ │ │ │ hasher256& update (char const* data, int len);
│ │ │ │ hasher256& update (span<char const> data);
│ │ │ │ sha256_hash final ();
│ │ │ │ void reset ();
│ │ │ │ ~hasher256 ();
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
hasher256() operator=()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
operator=() hasher256()
│ │ │ │
│ │ │ │ +hasher256 (hasher256 const&);
│ │ │ │ +explicit hasher256 (span<char const> data);
│ │ │ │ hasher256& operator= (hasher256 const&) &;
│ │ │ │ hasher256 (char const* data, int len);
│ │ │ │ -explicit hasher256 (span<char const> data);
│ │ │ │ -hasher256 (hasher256 const&);
│ │ │ │
│ │ │ │
this is the same as default constructing followed by a call to
│ │ │ │ update(data, len).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
update()
│ │ │ │
│ │ │ │ @@ -14483,17 +14483,17 @@
│ │ │ │ announce_entry
│ │ │ │ Declared in "libtorrent/announce_entry.hpp"
│ │ │ │ this class holds information about one bittorrent tracker, as it
│ │ │ │ relates to a specific torrent.
│ │ │ │
│ │ │ │ struct announce_entry
│ │ │ │ {
│ │ │ │ - announce_entry (announce_entry const&);
│ │ │ │ - explicit announce_entry (string_view u);
│ │ │ │ announce_entry& operator= (announce_entry const&) &;
│ │ │ │ + explicit announce_entry (string_view u);
│ │ │ │ + announce_entry (announce_entry const&);
│ │ │ │ ~announce_entry ();
│ │ │ │ announce_entry ();
│ │ │ │
│ │ │ │ enum tracker_source
│ │ │ │ {
│ │ │ │ source_torrent,
│ │ │ │ source_client,
│ │ │ │ @@ -14506,22 +14506,22 @@
│ │ │ │ std::vector<announce_endpoint> endpoints;
│ │ │ │ std::uint8_t tier = 0;
│ │ │ │ std::uint8_t fail_limit = 0;
│ │ │ │ std::uint8_t source:4;
│ │ │ │ bool verified:1;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -[report issue]
│ │ │ │ -
~announce_entry() announce_entry() operator=()
│ │ │ │ +
[report issue]
│ │ │ │ +
operator=() announce_entry() ~announce_entry()
│ │ │ │
│ │ │ │ -announce_entry (announce_entry const&);
│ │ │ │ -explicit announce_entry (string_view u);
│ │ │ │ announce_entry& operator= (announce_entry const&) &;
│ │ │ │ +explicit announce_entry (string_view u);
│ │ │ │ +announce_entry (announce_entry const&);
│ │ │ │ ~announce_entry ();
│ │ │ │ announce_entry ();
│ │ │ │
│ │ │ │
constructs a tracker announce entry with u as the URL.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
enum tracker_source
│ │ │ │ @@ -19098,18 +19098,18 @@
│ │ │ │ i2p_port).
│ │ │ │
│ │ │ │ struct settings_pack final : settings_interface
│ │ │ │ {
│ │ │ │ friend void apply_pack_impl (settings_pack const*
│ │ │ │ , aux::session_settings_single_thread&
│ │ │ │ , std::vector<void(aux::session_impl::*)()>*);
│ │ │ │ - void set_str (int name, std::string val) override;
│ │ │ │ void set_int (int name, int val) override;
│ │ │ │ void set_bool (int name, bool val) override;
│ │ │ │ void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ + void set_str (int name, std::string val) override;
│ │ │ │ bool has_val (int name) const override;
│ │ │ │ void clear ();
│ │ │ │ void clear (int name);
│ │ │ │ bool get_bool (int name) const override;
│ │ │ │ std::string const& get_str (int name) const override;
│ │ │ │ int get_int (int name) const override;
│ │ │ │ void for_each (Fun&& f) const;
│ │ │ │ @@ -19185,23 +19185,23 @@
│ │ │ │ socks5,
│ │ │ │ socks5_pw,
│ │ │ │ http,
│ │ │ │ http_pw,
│ │ │ │ };
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
set_str() set_bool() set_int()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
set_bool() set_str() set_int()
│ │ │ │
│ │ │ │ -void set_str (int name, std::string val) override;
│ │ │ │ void set_int (int name, int val) override;
│ │ │ │ void set_bool (int name, bool val) override;
│ │ │ │ void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ +void set_str (int name, std::string val) override;
│ │ │ │
│ │ │ │
set a configuration option in the settings_pack. name is one of
│ │ │ │ the enum values from string_types, int_types or bool_types. They must
│ │ │ │ match the respective type of the set_* function.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
has_val()
│ │ │ │ @@ -19221,19 +19221,19 @@
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
clear()
│ │ │ │
│ │ │ │ void clear (int name);
│ │ │ │
│ │ │ │
clear a specific setting from the pack
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
get_bool() get_int() get_str()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_int() get_bool() get_str()
│ │ │ │
│ │ │ │ bool get_bool (int name) const override;
│ │ │ │ std::string const& get_str (int name) const override;
│ │ │ │ int get_int (int name) const override;
│ │ │ │
│ │ │ │
queries the current configuration option from the settings_pack.
│ │ │ │ name is one of the enumeration values from string_types, int_types
│ │ │ │ @@ -19654,22 +19654,22 @@
│ │ │ │
Tribler |
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
There's an informal directory of client id's here.
│ │ │ │
The major, minor, revision and tag parameters are used to
│ │ │ │ identify the version of your client.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ -
│ │ │ │ -
setting_by_name() name_for_setting()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
name_for_setting() setting_by_name()
│ │ │ │
Declared in "libtorrent/settings_pack.hpp"
│ │ │ │
│ │ │ │ -char const* name_for_setting (int s);
│ │ │ │ int setting_by_name (string_view name);
│ │ │ │ +char const* name_for_setting (int s);
│ │ │ │
│ │ │ │
converts a setting integer (from the enums string_types, int_types or
│ │ │ │ bool_types) to a string, and vice versa.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
default_settings()
│ │ │ │
Declared in "libtorrent/settings_pack.hpp"
│ │ │ │ @@ -19714,44 +19714,44 @@
│ │ │ │ to be able to copy it as a reference for instance). For that, use the
│ │ │ │
non_owning() member function.
│ │ │ │
There are 5 different types of nodes, see type_t.
│ │ │ │
│ │ │ │ struct bdecode_node
│ │ │ │ {
│ │ │ │ bdecode_node () = default;
│ │ │ │ - bdecode_node (bdecode_node const&);
│ │ │ │ - bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ + bdecode_node (bdecode_node const&);
│ │ │ │ bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │ + bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ type_t type () const noexcept;
│ │ │ │ explicit operator bool () const noexcept;
│ │ │ │ bdecode_node non_owning () const;
│ │ │ │ std::ptrdiff_t data_offset () const noexcept;
│ │ │ │ span<char const> data_section () const noexcept;
│ │ │ │ string_view list_string_value_at (int i
│ │ │ │ , string_view default_val = string_view()) const;
│ │ │ │ + int list_size () const;
│ │ │ │ + bdecode_node list_at (int i) const;
│ │ │ │ std::int64_t list_int_value_at (int i
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ - bdecode_node list_at (int i) const;
│ │ │ │ - int list_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;
│ │ │ │ - int dict_size () const;
│ │ │ │ + bdecode_node dict_find_int (string_view key) const;
│ │ │ │ std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ - bdecode_node dict_find_list (string_view key) const;
│ │ │ │ + std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ bdecode_node dict_find (string_view key) const;
│ │ │ │ - bdecode_node dict_find_string (string_view key) const;
│ │ │ │ - bdecode_node dict_find_int (string_view key) const;
│ │ │ │ bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ + int dict_size () const;
│ │ │ │ std::int64_t dict_find_int_value (string_view key
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ + string_view dict_find_string_value (string_view key
│ │ │ │ + , string_view default_value = string_view()) const;
│ │ │ │ + bdecode_node dict_find_string (string_view key) const;
│ │ │ │ + bdecode_node dict_find_list (string_view key) const;
│ │ │ │ std::int64_t int_value () const;
│ │ │ │ - int string_length () const;
│ │ │ │ char const* string_ptr () const;
│ │ │ │ + int string_length () const;
│ │ │ │ std::ptrdiff_t string_offset () const;
│ │ │ │ string_view string_value () const;
│ │ │ │ void clear ();
│ │ │ │ void swap (bdecode_node& n);
│ │ │ │ void reserve (int tokens);
│ │ │ │ void switch_underlying_buffer (char const* buf) noexcept;
│ │ │ │ bool has_soft_error (span<char> error) const;
│ │ │ │ @@ -19768,23 +19768,23 @@
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
bdecode_node()
│ │ │ │
│ │ │ │ bdecode_node () = default;
│ │ │ │
│ │ │ │
creates a default constructed node, it will have the type none_t.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
bdecode_node() operator=()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
operator=() bdecode_node()
│ │ │ │
│ │ │ │ -bdecode_node (bdecode_node const&);
│ │ │ │ -bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ +bdecode_node (bdecode_node const&);
│ │ │ │ bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │ +bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │
│ │ │ │
For owning nodes, the copy will create a copy of the tree, but the
│ │ │ │ underlying buffer remains the same.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
type()
│ │ │ │
│ │ │ │ @@ -19816,57 +19816,57 @@
│ │ │ │
│ │ │ │
returns the buffer and length of the section in the original bencoded
│ │ │ │ buffer where this node is defined. For a dictionary for instance, this
│ │ │ │ starts with d and ends with e, and has all the content of the
│ │ │ │ dictionary in between.
│ │ │ │ the data_offset() function returns the byte-offset to this node in,
│ │ │ │ starting from the beginning of the buffer that was parsed.
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
list_int_value_at() list_size() list_string_value_at() list_at()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
list_size() list_at() list_string_value_at() list_int_value_at()
│ │ │ │
│ │ │ │ string_view list_string_value_at (int i
│ │ │ │ , string_view default_val = string_view()) const;
│ │ │ │ +int list_size () const;
│ │ │ │ +bdecode_node list_at (int i) const;
│ │ │ │ std::int64_t list_int_value_at (int i
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ -bdecode_node list_at (int i) const;
│ │ │ │ -int list_size () const;
│ │ │ │
│ │ │ │
functions with the list_ prefix operate on lists. These functions are
│ │ │ │ only valid if type() == list_t. list_at() returns the item
│ │ │ │ in the list at index i. i may not be greater than or equal to the
│ │ │ │ size of the list. size() returns the size of the list.
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
dict_find_list() dict_at() dict_find_string() dict_find_string_value() dict_at_node() dict_size() dict_find() dict_find_int_value() dict_find_int() dict_find_dict()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
dict_at_node() dict_find_list() dict_size() dict_find_string_value() dict_find_dict() dict_find_int_value() dict_find_int() dict_at() dict_find() dict_find_string()
│ │ │ │
│ │ │ │ -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;
│ │ │ │ -int dict_size () const;
│ │ │ │ +bdecode_node dict_find_int (string_view key) const;
│ │ │ │ std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ -bdecode_node dict_find_list (string_view key) const;
│ │ │ │ +std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ bdecode_node dict_find (string_view key) const;
│ │ │ │ -bdecode_node dict_find_string (string_view key) const;
│ │ │ │ -bdecode_node dict_find_int (string_view key) const;
│ │ │ │ bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ +int dict_size () const;
│ │ │ │ std::int64_t dict_find_int_value (string_view key
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ +string_view dict_find_string_value (string_view key
│ │ │ │ + , string_view default_value = string_view()) const;
│ │ │ │ +bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +bdecode_node dict_find_list (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.
│ │ │ │ @@ -19883,21 +19883,21 @@
│ │ │ │
│ │ │ │ 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_value() string_ptr() string_offset() string_length()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
string_value() string_ptr() string_length() string_offset()
│ │ │ │
│ │ │ │ -int string_length () const;
│ │ │ │ char const* string_ptr () const;
│ │ │ │ +int string_length () const;
│ │ │ │ std::ptrdiff_t string_offset () const;
│ │ │ │ string_view string_value () const;
│ │ │ │
│ │ │ │
these functions are only valid if type() == string_t. They return
│ │ │ │ the string values. Note that string_ptr() is not 0-terminated.
│ │ │ │ string_length() returns the number of bytes in the string.
│ │ │ │ string_offset() returns the byte offset from the start of the parsed
│ │ │ │ @@ -20001,18 +20001,18 @@
│ │ │ │
bdecode()
│ │ │ │
Declared in "libtorrent/bdecode.hpp"
│ │ │ │
│ │ │ │ int bdecode (char const* start, char const* end, bdecode_node& ret
│ │ │ │ , error_code& ec, int* error_pos = nullptr, int depth_limit = 100
│ │ │ │ , int token_limit = 2000000);
│ │ │ │ bdecode_node bdecode (span<char const> buffer
│ │ │ │ - , int depth_limit = 100, int token_limit = 2000000);
│ │ │ │ -bdecode_node bdecode (span<char const> buffer
│ │ │ │ , error_code& ec, int* error_pos = nullptr, int depth_limit = 100
│ │ │ │ , int token_limit = 2000000);
│ │ │ │ +bdecode_node bdecode (span<char const> buffer
│ │ │ │ + , int depth_limit = 100, int token_limit = 2000000);
│ │ │ │
│ │ │ │
This function decodes/parses bdecoded data (for example a .torrent file).
│ │ │ │ The data structure is returned in the ret argument. the buffer to parse
│ │ │ │ is specified by the start of the buffer as well as the end, i.e. one
│ │ │ │ byte past the end. If the buffer fails to parse, the function returns a
│ │ │ │ non-zero value and fills in ec with the error code. The optional
│ │ │ │ argument error_pos, if set to non-nullptr, will be set to the byte offset
│ │ │ │ @@ -20337,20 +20337,20 @@
│ │ │ │
- Specify the port number for the SSL listen socket in the DHT announce.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
read_resume_data()
│ │ │ │
Declared in "libtorrent/read_resume_data.hpp"
│ │ │ │
│ │ │ │ -add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ - , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │ add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ , int piece_limit = 0x200000);
│ │ │ │ +add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ + , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ , load_torrent_limits const& cfg = {});
│ │ │ │
│ │ │ │
these functions are used to parse resume data and populate the appropriate
│ │ │ │ fields in an add_torrent_params object. This object can then be used to add
│ │ │ │ the actual torrent_info object to and pass to session::add_torrent() or
│ │ │ │ session::async_add_torrent().
│ │ │ │ @@ -20371,24 +20371,24 @@
│ │ │ │
Declared in "libtorrent/write_resume_data.hpp"
│ │ │ │
│ │ │ │ entry write_resume_data (add_torrent_params const& atp);
│ │ │ │ std::vector<char> write_resume_data_buf (add_torrent_params const& atp);
│ │ │ │
│ │ │ │
this function turns the resume data in an add_torrent_params object
│ │ │ │ into a bencoded structure
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
write_torrent_file() write_torrent_file_buf()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
write_torrent_file_buf() write_torrent_file()
│ │ │ │
Declared in "libtorrent/write_resume_data.hpp"
│ │ │ │
│ │ │ │ +entry write_torrent_file (add_torrent_params const& atp);
│ │ │ │ std::vector<char> write_torrent_file_buf (add_torrent_params const& atp
│ │ │ │ , write_torrent_flags_t flags);
│ │ │ │ entry write_torrent_file (add_torrent_params const& atp, write_torrent_flags_t flags);
│ │ │ │ -entry write_torrent_file (add_torrent_params const& atp);
│ │ │ │
│ │ │ │
writes only the fields to create a .torrent file. This function may fail
│ │ │ │ with a std::system_error exception if:
│ │ │ │
│ │ │ │ - The add_torrent_params object passed to this function does not contain the
│ │ │ │ info dictionary (the ti field)
│ │ │ │ - The piece layers are not complete for all files that need them
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -22,87 +22,87 @@
│ │ │ │ │ * _e_n_u_m_ _s_o_c_k_s___e_r_r_o_r___c_o_d_e
│ │ │ │ │ * _e_n_u_m_ _p_c_p___e_r_r_o_r_s
│ │ │ │ │ * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ │ * _s_e_s_s_i_o_n___p_a_r_a_m_s
│ │ │ │ │ o _s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ o _s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ * _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │ - o _~_s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _s_e_s_s_i_o_n___p_r_o_x_y_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_(_)_ _~_s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _s_e_s_s_i_o_n___p_r_o_x_y_(_)
│ │ │ │ │ * _s_e_s_s_i_o_n
│ │ │ │ │ o _s_e_s_s_i_o_n_(_)
│ │ │ │ │ o _s_e_s_s_i_o_n_(_)
│ │ │ │ │ o _~_s_e_s_s_i_o_n_(_)
│ │ │ │ │ o _a_b_o_r_t_(_)
│ │ │ │ │ * _s_e_s_s_i_o_n___h_a_n_d_l_e
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ o _s_e_s_s_i_o_n___s_t_a_t_e_(_)
│ │ │ │ │ o _g_e_t___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)_ _r_e_f_r_e_s_h___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)
│ │ │ │ │ o _p_o_s_t___t_o_r_r_e_n_t___u_p_d_a_t_e_s_(_)
│ │ │ │ │ o _p_o_s_t___s_e_s_s_i_o_n___s_t_a_t_s_(_)
│ │ │ │ │ o _p_o_s_t___d_h_t___s_t_a_t_s_(_)
│ │ │ │ │ o _s_e_t___d_h_t___s_t_a_t_e_(_)
│ │ │ │ │ - o _g_e_t___t_o_r_r_e_n_t_s_(_)_ _f_i_n_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ + o _f_i_n_d___t_o_r_r_e_n_t_(_)_ _g_e_t___t_o_r_r_e_n_t_s_(_)
│ │ │ │ │ o _a_d_d___t_o_r_r_e_n_t_(_)_ _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ - o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)_ _i_s___p_a_u_s_e_d_(_)
│ │ │ │ │ + o _i_s___p_a_u_s_e_d_(_)_ _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)
│ │ │ │ │ o _i_s___d_h_t___r_u_n_n_i_n_g_(_)
│ │ │ │ │ o _s_e_t___d_h_t___s_t_o_r_a_g_e_(_)
│ │ │ │ │ o _a_d_d___d_h_t___n_o_d_e_(_)
│ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___p_u_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___p_u_t___i_t_e_m_(_)
│ │ │ │ │ - o _d_h_t___g_e_t___p_e_e_r_s_(_)_ _d_h_t___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ + o _d_h_t___a_n_n_o_u_n_c_e_(_)_ _d_h_t___g_e_t___p_e_e_r_s_(_)
│ │ │ │ │ o _d_h_t___l_i_v_e___n_o_d_e_s_(_)
│ │ │ │ │ o _d_h_t___s_a_m_p_l_e___i_n_f_o_h_a_s_h_e_s_(_)
│ │ │ │ │ o _d_h_t___d_i_r_e_c_t___r_e_q_u_e_s_t_(_)
│ │ │ │ │ o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │ - o _s_e_t___i_p___f_i_l_t_e_r_(_)_ _g_e_t___i_p___f_i_l_t_e_r_(_)
│ │ │ │ │ + o _g_e_t___i_p___f_i_l_t_e_r_(_)_ _s_e_t___i_p___f_i_l_t_e_r_(_)
│ │ │ │ │ o _s_e_t___p_o_r_t___f_i_l_t_e_r_(_)
│ │ │ │ │ - o _i_s___l_i_s_t_e_n_i_n_g_(_)_ _l_i_s_t_e_n___p_o_r_t_(_)_ _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)
│ │ │ │ │ + o _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)_ _i_s___l_i_s_t_e_n_i_n_g_(_)_ _l_i_s_t_e_n___p_o_r_t_(_)
│ │ │ │ │ o _s_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)
│ │ │ │ │ - o _s_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)
│ │ │ │ │ + o _g_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)
│ │ │ │ │ o _c_r_e_a_t_e___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ o _d_e_l_e_t_e___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ o _s_e_t___p_e_e_r___c_l_a_s_s_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ o _r_e_m_o_v_e___t_o_r_r_e_n_t_(_)
│ │ │ │ │ - o _g_e_t___s_e_t_t_i_n_g_s_(_)_ _a_p_p_l_y___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ + o _a_p_p_l_y___s_e_t_t_i_n_g_s_(_)_ _g_e_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ o _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_)_ _p_o_p___a_l_e_r_t_s_(_)
│ │ │ │ │ o _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_)_ _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_)
│ │ │ │ │ o _r_e_o_p_e_n___n_e_t_w_o_r_k___s_o_c_k_e_t_s_(_)
│ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │ - * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ + * _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)
│ │ │ │ │ * _w_e_b___s_e_e_d___e_n_t_r_y
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │ o _e_n_u_m_ _t_y_p_e___t
│ │ │ │ │ * _l_o_a_d___t_o_r_r_e_n_t___l_i_m_i_t_s
│ │ │ │ │ * _t_o_r_r_e_n_t___i_n_f_o
│ │ │ │ │ o _t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │ o _~_t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │ o _f_i_l_e_s_(_)_ _o_r_i_g___f_i_l_e_s_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ o _r_e_m_a_p___f_i_l_e_s_(_)
│ │ │ │ │ - o _a_d_d___t_r_a_c_k_e_r_(_)_ _t_r_a_c_k_e_r_s_(_)_ _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ - o _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)_ _c_o_l_l_e_c_t_i_o_n_s_(_)
│ │ │ │ │ - o _a_d_d___u_r_l___s_e_e_d_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ + o _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ + o _c_o_l_l_e_c_t_i_o_n_s_(_)_ _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)
│ │ │ │ │ + o _w_e_b___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │ - o _e_n_d___p_i_e_c_e_(_)_ _p_i_e_c_e___r_a_n_g_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)
│ │ │ │ │ - o _i_n_f_o___h_a_s_h_e_s_(_)_ _i_n_f_o___h_a_s_h_(_)
│ │ │ │ │ - o _v_2_(_)_ _v_1_(_)
│ │ │ │ │ + o _p_i_e_c_e___r_a_n_g_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)_ _e_n_d___p_i_e_c_e_(_)
│ │ │ │ │ + o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ + o _v_1_(_)_ _v_2_(_)
│ │ │ │ │ o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │ o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │ o _m_a_p___f_i_l_e_(_)
│ │ │ │ │ o _s_s_l___c_e_r_t_(_)
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ o _p_r_i_v_(_)
│ │ │ │ │ o _i_s___i_2_p_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ - o _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e_(_)
│ │ │ │ │ + o _h_a_s_h___f_o_r___p_i_e_c_e_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)
│ │ │ │ │ o _n_a_m_e_(_)
│ │ │ │ │ o _c_r_e_a_t_i_o_n___d_a_t_e_(_)
│ │ │ │ │ o _c_r_e_a_t_o_r_(_)
│ │ │ │ │ o _c_o_m_m_e_n_t_(_)
│ │ │ │ │ o _n_o_d_e_s_(_)
│ │ │ │ │ o _a_d_d___n_o_d_e_(_)
│ │ │ │ │ o _p_a_r_s_e___i_n_f_o___s_e_c_t_i_o_n_(_)
│ │ │ │ │ @@ -117,15 +117,15 @@
│ │ │ │ │ o _h_a_s___v_2_(_)_ _h_a_s___v_1_(_)_ _h_a_s_(_)
│ │ │ │ │ o _g_e_t_(_)
│ │ │ │ │ o _g_e_t___b_e_s_t_(_)
│ │ │ │ │ o _f_o_r___e_a_c_h_(_)
│ │ │ │ │ * _p_i_e_c_e___b_l_o_c_k
│ │ │ │ │ * _p_e_e_r___r_e_q_u_e_s_t
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ - * _l_o_a_d___t_o_r_r_e_n_t___p_a_r_s_e_d_(_)_ _l_o_a_d___t_o_r_r_e_n_t___b_u_f_f_e_r_(_)_ _l_o_a_d___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ + * _l_o_a_d___t_o_r_r_e_n_t___p_a_r_s_e_d_(_)_ _l_o_a_d___t_o_r_r_e_n_t___f_i_l_e_(_)_ _l_o_a_d___t_o_r_r_e_n_t___b_u_f_f_e_r_(_)
│ │ │ │ │ * _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ * _p_a_r_s_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ * _t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_)
│ │ │ │ │ * _t_r_u_n_c_a_t_e___f_i_l_e_s_(_)
│ │ │ │ │ * _v_e_r_s_i_o_n_(_)
│ │ │ │ │ * _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │ * _e_n_u_m_ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ │ @@ -151,38 +151,38 @@
│ │ │ │ │ o _o_n___a_l_e_r_t_(_)
│ │ │ │ │ o _o_n___u_n_k_n_o_w_n___t_o_r_r_e_n_t_(_)
│ │ │ │ │ o _o_n___t_i_c_k_(_)
│ │ │ │ │ o _g_e_t___u_n_c_h_o_k_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ │ o _l_o_a_d___s_t_a_t_e_(_)
│ │ │ │ │ * _t_o_r_r_e_n_t___p_l_u_g_i_n
│ │ │ │ │ o _n_e_w___c_o_n_n_e_c_t_i_o_n_(_)
│ │ │ │ │ - o _o_n___p_i_e_c_e___p_a_s_s_(_)_ _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)
│ │ │ │ │ + o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_)
│ │ │ │ │ o _t_i_c_k_(_)
│ │ │ │ │ - o _o_n___r_e_s_u_m_e_(_)_ _o_n___p_a_u_s_e_(_)
│ │ │ │ │ + o _o_n___p_a_u_s_e_(_)_ _o_n___r_e_s_u_m_e_(_)
│ │ │ │ │ o _o_n___f_i_l_e_s___c_h_e_c_k_e_d_(_)
│ │ │ │ │ o _o_n___s_t_a_t_e_(_)
│ │ │ │ │ o _o_n___a_d_d___p_e_e_r_(_)
│ │ │ │ │ * _p_e_e_r___p_l_u_g_i_n
│ │ │ │ │ o _t_y_p_e_(_)
│ │ │ │ │ o _a_d_d___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ o _o_n___d_i_s_c_o_n_n_e_c_t_(_)
│ │ │ │ │ o _o_n___c_o_n_n_e_c_t_e_d_(_)
│ │ │ │ │ o _o_n___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ o _o_n___e_x_t_e_n_s_i_o_n___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ - o _o_n___c_h_o_k_e_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___h_a_v_e_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___u_n_c_h_o_k_e_(_)
│ │ │ │ │ - _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___h_a_v_e___a_l_l_(_)_ _o_n___r_e_q_u_e_s_t_(_)
│ │ │ │ │ - _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)
│ │ │ │ │ + o _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___u_n_c_h_o_k_e_(_)_ _o_n___c_h_o_k_e_(_)_ _o_n___b_i_t_f_i_e_l_d
│ │ │ │ │ + _(_)_ _o_n___h_a_v_e___a_l_l_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ + _o_n___h_a_v_e_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)
│ │ │ │ │ o _o_n___p_i_e_c_e_(_)
│ │ │ │ │ - o _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___u_n_c_h_o_k_e_(_)_ _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)_ _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ - _s_e_n_t___p_i_e_c_e_(_)
│ │ │ │ │ + o _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___u_n_c_h_o_k_e_(_)
│ │ │ │ │ + _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ o _s_e_n_t___p_a_y_l_o_a_d_(_)
│ │ │ │ │ o _c_a_n___d_i_s_c_o_n_n_e_c_t_(_)
│ │ │ │ │ o _o_n___e_x_t_e_n_d_e_d_(_)
│ │ │ │ │ o _o_n___u_n_k_n_o_w_n___m_e_s_s_a_g_e_(_)
│ │ │ │ │ - o _o_n___p_i_e_c_e___p_a_s_s_(_)_ _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)
│ │ │ │ │ + o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_)
│ │ │ │ │ o _t_i_c_k_(_)
│ │ │ │ │ o _w_r_i_t_e___r_e_q_u_e_s_t_(_)
│ │ │ │ │ * _c_r_y_p_t_o___p_l_u_g_i_n
│ │ │ │ │ o _d_e_c_r_y_p_t_(_)
│ │ │ │ │ * _p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e
│ │ │ │ │ * _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e
│ │ │ │ │ * _c_r_e_a_t_e___u_t___p_e_x___p_l_u_g_i_n_(_)
│ │ │ │ │ @@ -200,26 +200,26 @@
│ │ │ │ │ o _e_n_d___f_i_l_e_(_)
│ │ │ │ │ o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ o _s_e_t___n_u_m___p_i_e_c_e_s_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ o _e_n_d___p_i_e_c_e_(_)
│ │ │ │ │ o _l_a_s_t___p_i_e_c_e_(_)
│ │ │ │ │ o _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ - o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ + o _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_2_(_)
│ │ │ │ │ o _b_l_o_c_k_s___i_n___p_i_e_c_e_2_(_)
│ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │ o _s_e_t___n_a_m_e_(_)_ _n_a_m_e_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _c_a_n_o_n_i_c_a_l_i_z_e_(_)
│ │ │ │ │ - o _f_i_l_e___o_f_f_s_e_t_(_)_ _m_t_i_m_e_(_)_ _h_a_s_h_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _s_y_m_l_i_n_k_(_)_ _f_i_l_e___p_a_t_h_(_)
│ │ │ │ │ - _f_i_l_e___s_i_z_e_(_)_ _r_o_o_t___p_t_r_(_)_ _r_o_o_t_(_)_ _f_i_l_e___n_a_m_e_(_)
│ │ │ │ │ + o _f_i_l_e___n_a_m_e_(_)_ _h_a_s_h_(_)_ _r_o_o_t___p_t_r_(_)_ _f_i_l_e___p_a_t_h_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _m_t_i_m_e_(_)
│ │ │ │ │ + _p_a_d___f_i_l_e___a_t_(_)_ _r_o_o_t_(_)_ _f_i_l_e___s_i_z_e_(_)_ _s_y_m_l_i_n_k_(_)
│ │ │ │ │ o _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ - o _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_)
│ │ │ │ │ + o _f_i_l_e___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_e_(_)
│ │ │ │ │ o _f_i_l_e___p_a_t_h___h_a_s_h_(_)
│ │ │ │ │ o _a_l_l___p_a_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │ o _f_i_l_e___f_l_a_g_s_(_)
│ │ │ │ │ o _f_i_l_e___a_b_s_o_l_u_t_e___p_a_t_h_(_)
│ │ │ │ │ o _f_i_l_e___i_n_d_e_x___a_t___p_i_e_c_e_(_)_ _f_i_l_e___i_n_d_e_x___a_t___o_f_f_s_e_t_(_)
│ │ │ │ │ o _f_i_l_e___i_n_d_e_x___f_o_r___r_o_o_t_(_)
│ │ │ │ │ o _p_i_e_c_e___i_n_d_e_x___a_t___f_i_l_e_(_)
│ │ │ │ │ @@ -231,20 +231,20 @@
│ │ │ │ │ * _p_o_s_i_x___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │ * _d_e_f_a_u_l_t___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │ * _e_n_u_m_ _s_t_o_r_a_g_e___m_o_d_e___t
│ │ │ │ │ * _e_n_u_m_ _s_t_a_t_u_s___t
│ │ │ │ │ * _e_n_u_m_ _m_o_v_e___f_l_a_g_s___t
│ │ │ │ │ * _c_l_i_e_n_t___d_a_t_a___t
│ │ │ │ │ o _c_l_i_e_n_t___d_a_t_a___t_(_)
│ │ │ │ │ - o _c_o_n_s_t_*_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _v_o_i_d_*_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_(_)_ _c_o_n_s_t_*_(_)_ _v_o_i_d_*_(_)
│ │ │ │ │ * _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ │ * _p_e_e_r___c_l_a_s_s___i_n_f_o
│ │ │ │ │ * _p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r
│ │ │ │ │ - o _a_d_d_(_)_ _r_e_m_o_v_e_(_)
│ │ │ │ │ - o _d_i_s_a_l_l_o_w_(_)_ _a_l_l_o_w_(_)
│ │ │ │ │ + o _r_e_m_o_v_e_(_)_ _a_d_d_(_)
│ │ │ │ │ + o _a_l_l_o_w_(_)_ _d_i_s_a_l_l_o_w_(_)
│ │ │ │ │ o _a_p_p_l_y_(_)
│ │ │ │ │ o _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │ * _b_l_o_c_k___i_n_f_o
│ │ │ │ │ o _p_e_e_r_(_)_ _s_e_t___p_e_e_r_(_)
│ │ │ │ │ o _e_n_u_m_ _b_l_o_c_k___s_t_a_t_e___t
│ │ │ │ │ * _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o
│ │ │ │ │ * _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │ @@ -252,50 +252,50 @@
│ │ │ │ │ o _a_d_d___p_i_e_c_e_(_)
│ │ │ │ │ o _r_e_a_d___p_i_e_c_e_(_)
│ │ │ │ │ o _h_a_v_e___p_i_e_c_e_(_)
│ │ │ │ │ o _g_e_t___p_e_e_r___i_n_f_o_(_)_ _p_o_s_t___p_e_e_r___i_n_f_o_(_)
│ │ │ │ │ o _s_t_a_t_u_s_(_)_ _p_o_s_t___s_t_a_t_u_s_(_)
│ │ │ │ │ o _p_o_s_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)_ _g_e_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)
│ │ │ │ │ o _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_s_(_)_ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)
│ │ │ │ │ - o _p_o_s_t___f_i_l_e___p_r_o_g_r_e_s_s_(_)_ _f_i_l_e___p_r_o_g_r_e_s_s_(_)
│ │ │ │ │ + o _f_i_l_e___p_r_o_g_r_e_s_s_(_)_ _p_o_s_t___f_i_l_e___p_r_o_g_r_e_s_s_(_)
│ │ │ │ │ o _f_i_l_e___s_t_a_t_u_s_(_)
│ │ │ │ │ o _c_l_e_a_r___e_r_r_o_r_(_)
│ │ │ │ │ - o _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ + o _p_o_s_t___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ o _a_d_d___u_r_l___s_e_e_d_(_)_ _u_r_l___s_e_e_d_s_(_)_ _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)
│ │ │ │ │ - o _h_t_t_p___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ + o _a_d_d___h_t_t_p___s_e_e_d_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _h_t_t_p___s_e_e_d_s_(_)
│ │ │ │ │ o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │ o _s_e_t___m_e_t_a_d_a_t_a_(_)
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)
│ │ │ │ │ - o _u_n_s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)
│ │ │ │ │ + o _f_l_a_g_s_(_)_ _u_n_s_e_t___f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)
│ │ │ │ │ o _f_l_u_s_h___c_a_c_h_e_(_)
│ │ │ │ │ o _f_o_r_c_e___r_e_c_h_e_c_k_(_)
│ │ │ │ │ o _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ o _n_e_e_d___s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ - o _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)
│ │ │ │ │ + o _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)
│ │ │ │ │ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)
│ │ │ │ │ o _q_u_e_u_e___p_o_s_i_t_i_o_n___s_e_t_(_)
│ │ │ │ │ - o _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_)
│ │ │ │ │ - o _t_o_r_r_e_n_t___f_i_l_e_(_)_ _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │ + o _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e_(_)
│ │ │ │ │ + o _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)_ _t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ o _p_i_e_c_e___l_a_y_e_r_s_(_)
│ │ │ │ │ o _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)_ _p_o_s_t___p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)
│ │ │ │ │ o _p_i_e_c_e___p_r_i_o_r_i_t_y_(_)_ _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)_ _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ o _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)_ _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)
│ │ │ │ │ - o _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ + o _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ o _s_c_r_a_p_e___t_r_a_c_k_e_r_(_)
│ │ │ │ │ - o _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _u_p_l_o_a_d___l_i_m_i_t_(_)_ _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ - _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ + o _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)_ _u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ + _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ o _c_o_n_n_e_c_t___p_e_e_r_(_)
│ │ │ │ │ o _c_l_e_a_r___p_e_e_r_s_(_)
│ │ │ │ │ o _s_e_t___m_a_x___u_p_l_o_a_d_s_(_)_ _m_a_x___u_p_l_o_a_d_s_(_)
│ │ │ │ │ o _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │ o _m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ - o _i_n_f_o___h_a_s_h_e_s_(_)_ _i_n_f_o___h_a_s_h_(_)
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │ + o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │ o _i_d_(_)
│ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │ o _u_s_e_r_d_a_t_a_(_)
│ │ │ │ │ o _i_n___s_e_s_s_i_o_n_(_)
│ │ │ │ │ * _h_a_s_h___v_a_l_u_e_(_)
│ │ │ │ │ * _o_p_e_n___f_i_l_e___s_t_a_t_e
│ │ │ │ │ * _d_i_s_k___i_n_t_e_r_f_a_c_e
│ │ │ │ │ @@ -376,15 +376,15 @@
│ │ │ │ │ * _p_i_e_c_e___f_i_n_i_s_h_e_d___a_l_e_r_t
│ │ │ │ │ * _r_e_q_u_e_s_t___d_r_o_p_p_e_d___a_l_e_r_t
│ │ │ │ │ * _b_l_o_c_k___t_i_m_e_o_u_t___a_l_e_r_t
│ │ │ │ │ * _b_l_o_c_k___f_i_n_i_s_h_e_d___a_l_e_r_t
│ │ │ │ │ * _b_l_o_c_k___d_o_w_n_l_o_a_d_i_n_g___a_l_e_r_t
│ │ │ │ │ * _u_n_w_a_n_t_e_d___b_l_o_c_k___a_l_e_r_t
│ │ │ │ │ * _s_t_o_r_a_g_e___m_o_v_e_d___a_l_e_r_t
│ │ │ │ │ - o _s_t_o_r_a_g_e___p_a_t_h_(_)_ _o_l_d___p_a_t_h_(_)
│ │ │ │ │ + o _o_l_d___p_a_t_h_(_)_ _s_t_o_r_a_g_e___p_a_t_h_(_)
│ │ │ │ │ * _s_t_o_r_a_g_e___m_o_v_e_d___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ │ o _f_i_l_e___p_a_t_h_(_)
│ │ │ │ │ * _t_o_r_r_e_n_t___d_e_l_e_t_e_d___a_l_e_r_t
│ │ │ │ │ * _t_o_r_r_e_n_t___d_e_l_e_t_e___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ │ * _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t
│ │ │ │ │ * _s_a_v_e___r_e_s_u_m_e___d_a_t_a___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ │ * _t_o_r_r_e_n_t___p_a_u_s_e_d___a_l_e_r_t
│ │ │ │ │ @@ -472,15 +472,15 @@
│ │ │ │ │ * _t_r_a_c_k_e_r___l_i_s_t___a_l_e_r_t
│ │ │ │ │ * _a_l_e_r_t___c_a_s_t_(_)
│ │ │ │ │ * _o_p_e_r_a_t_i_o_n___n_a_m_e_(_)
│ │ │ │ │ * _e_n_u_m_ _o_p_e_r_a_t_i_o_n___t
│ │ │ │ │ * _a_l_e_r_t___c_a_t_e_g_o_r_y___t
│ │ │ │ │ * _i_n_t
│ │ │ │ │ * _c_o_u_n_t_e_r_s
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_[_]_(_)_ _i_n_c___s_t_a_t_s___c_o_u_n_t_e_r_(_)
│ │ │ │ │ + o _i_n_c___s_t_a_t_s___c_o_u_n_t_e_r_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ * _s_t_a_t_s___m_e_t_r_i_c
│ │ │ │ │ * _s_e_s_s_i_o_n___s_t_a_t_s___m_e_t_r_i_c_s_(_)
│ │ │ │ │ * _f_i_n_d___m_e_t_r_i_c___i_d_x_(_)
│ │ │ │ │ * _e_n_u_m_ _m_e_t_r_i_c___t_y_p_e___t
│ │ │ │ │ * _i_p___f_i_l_t_e_r
│ │ │ │ │ o _e_m_p_t_y_(_)
│ │ │ │ │ o _a_d_d___r_u_l_e_(_)
│ │ │ │ │ @@ -493,15 +493,15 @@
│ │ │ │ │ o _e_n_u_m_ _a_c_c_e_s_s___f_l_a_g_s
│ │ │ │ │ * _e_n_t_r_y
│ │ │ │ │ o _t_y_p_e_(_)
│ │ │ │ │ o _e_n_t_r_y_(_)
│ │ │ │ │ o _e_n_t_r_y_(_)
│ │ │ │ │ o _e_n_t_r_y_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ - o _i_n_t_e_g_e_r_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _l_i_s_t_(_)_ _s_t_r_i_n_g_(_)_ _d_i_c_t_(_)
│ │ │ │ │ + o _s_t_r_i_n_g_(_)_ _l_i_s_t_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _i_n_t_e_g_e_r_(_)_ _d_i_c_t_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ o _f_i_n_d___k_e_y_(_)
│ │ │ │ │ o _t_o___s_t_r_i_n_g_(_)
│ │ │ │ │ o _e_n_u_m_ _d_a_t_a___t_y_p_e
│ │ │ │ │ * _o_p_e_r_a_t_o_r_<_<_(_)
│ │ │ │ │ * _b_e_n_c_o_d_e_(_)
│ │ │ │ │ @@ -527,78 +527,78 @@
│ │ │ │ │ o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ o _a_d_d___s_i_m_i_l_a_r___t_o_r_r_e_n_t_(_)_ _a_d_d___c_o_l_l_e_c_t_i_o_n_(_)
│ │ │ │ │ * _a_d_d___f_i_l_e_s_(_)
│ │ │ │ │ * _s_e_t___p_i_e_c_e___h_a_s_h_e_s_(_)
│ │ │ │ │ * _b_i_t_f_i_e_l_d
│ │ │ │ │ o _b_i_t_f_i_e_l_d_(_)
│ │ │ │ │ o _a_s_s_i_g_n_(_)
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_[_]_(_)_ _g_e_t___b_i_t_(_)
│ │ │ │ │ - o _c_l_e_a_r___b_i_t_(_)_ _s_e_t___b_i_t_(_)
│ │ │ │ │ + o _g_e_t___b_i_t_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ + o _s_e_t___b_i_t_(_)_ _c_l_e_a_r___b_i_t_(_)
│ │ │ │ │ o _a_l_l___s_e_t_(_)
│ │ │ │ │ o _n_o_n_e___s_e_t_(_)
│ │ │ │ │ o _s_i_z_e_(_)
│ │ │ │ │ o _n_u_m___w_o_r_d_s_(_)
│ │ │ │ │ o _n_u_m___b_y_t_e_s_(_)
│ │ │ │ │ o _e_m_p_t_y_(_)
│ │ │ │ │ o _d_a_t_a_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _c_o_u_n_t_(_)
│ │ │ │ │ o _f_i_n_d___f_i_r_s_t___s_e_t_(_)
│ │ │ │ │ o _f_i_n_d___l_a_s_t___c_l_e_a_r_(_)
│ │ │ │ │ * _h_a_s_h_e_r
│ │ │ │ │ - o _h_a_s_h_e_r_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_(_)_ _h_a_s_h_e_r_(_)
│ │ │ │ │ o _u_p_d_a_t_e_(_)
│ │ │ │ │ o _f_i_n_a_l_(_)
│ │ │ │ │ o _r_e_s_e_t_(_)
│ │ │ │ │ * _h_a_s_h_e_r_2_5_6
│ │ │ │ │ - o _h_a_s_h_e_r_2_5_6_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_(_)_ _h_a_s_h_e_r_2_5_6_(_)
│ │ │ │ │ o _u_p_d_a_t_e_(_)
│ │ │ │ │ o _f_i_n_a_l_(_)
│ │ │ │ │ o _r_e_s_e_t_(_)
│ │ │ │ │ * _t_o_r_r_e_n_t___s_t_a_t_u_s
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ o _e_n_u_m_ _s_t_a_t_e___t
│ │ │ │ │ * _a_n_n_o_u_n_c_e___i_n_f_o_h_a_s_h
│ │ │ │ │ * _a_n_n_o_u_n_c_e___e_n_d_p_o_i_n_t
│ │ │ │ │ * _a_n_n_o_u_n_c_e___e_n_t_r_y
│ │ │ │ │ - o _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_(_)_ _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)
│ │ │ │ │ o _e_n_u_m_ _t_r_a_c_k_e_r___s_o_u_r_c_e
│ │ │ │ │ * _s_e_t_t_i_n_g_s___p_a_c_k
│ │ │ │ │ - o _s_e_t___s_t_r_(_)_ _s_e_t___b_o_o_l_(_)_ _s_e_t___i_n_t_(_)
│ │ │ │ │ + o _s_e_t___b_o_o_l_(_)_ _s_e_t___s_t_r_(_)_ _s_e_t___i_n_t_(_)
│ │ │ │ │ o _h_a_s___v_a_l_(_)
│ │ │ │ │ o _c_l_e_a_r_(_)
│ │ │ │ │ o _c_l_e_a_r_(_)
│ │ │ │ │ - o _g_e_t___b_o_o_l_(_)_ _g_e_t___i_n_t_(_)_ _g_e_t___s_t_r_(_)
│ │ │ │ │ + o _g_e_t___i_n_t_(_)_ _g_e_t___b_o_o_l_(_)_ _g_e_t___s_t_r_(_)
│ │ │ │ │ o _e_n_u_m_ _t_y_p_e___b_a_s_e_s
│ │ │ │ │ o _e_n_u_m_ _m_m_a_p___w_r_i_t_e___m_o_d_e___t
│ │ │ │ │ o _e_n_u_m_ _s_u_g_g_e_s_t___m_o_d_e___t
│ │ │ │ │ o _e_n_u_m_ _c_h_o_k_i_n_g___a_l_g_o_r_i_t_h_m___t
│ │ │ │ │ o _e_n_u_m_ _s_e_e_d___c_h_o_k_i_n_g___a_l_g_o_r_i_t_h_m___t
│ │ │ │ │ o _e_n_u_m_ _i_o___b_u_f_f_e_r___m_o_d_e___t
│ │ │ │ │ o _e_n_u_m_ _b_a_n_d_w_i_d_t_h___m_i_x_e_d___a_l_g_o___t
│ │ │ │ │ o _e_n_u_m_ _e_n_c___p_o_l_i_c_y
│ │ │ │ │ o _e_n_u_m_ _e_n_c___l_e_v_e_l
│ │ │ │ │ o _e_n_u_m_ _p_r_o_x_y___t_y_p_e___t
│ │ │ │ │ * _g_e_n_e_r_a_t_e___f_i_n_g_e_r_p_r_i_n_t_(_)
│ │ │ │ │ - * _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)_ _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)
│ │ │ │ │ - * _s_e_t_t_i_n_g___b_y___n_a_m_e_(_)_ _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)
│ │ │ │ │ + * _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)_ _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)
│ │ │ │ │ + * _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)_ _s_e_t_t_i_n_g___b_y___n_a_m_e_(_)
│ │ │ │ │ * _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ * _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ │ o _b_d_e_c_o_d_e___n_o_d_e_(_)
│ │ │ │ │ - o _b_d_e_c_o_d_e___n_o_d_e_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_(_)_ _b_d_e_c_o_d_e___n_o_d_e_(_)
│ │ │ │ │ o _t_y_p_e_(_)
│ │ │ │ │ o _b_o_o_l_(_)
│ │ │ │ │ o _n_o_n___o_w_n_i_n_g_(_)
│ │ │ │ │ o _d_a_t_a___s_e_c_t_i_o_n_(_)_ _d_a_t_a___o_f_f_s_e_t_(_)
│ │ │ │ │ - o _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)_ _l_i_s_t___a_t_(_)
│ │ │ │ │ - o _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___a_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)
│ │ │ │ │ - _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_(_)_ _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___i_n_t_(_)_ _d_i_c_t___f_i_n_d___d_i_c_t_(_)
│ │ │ │ │ + o _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_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)
│ │ │ │ │ + o _d_i_c_t___a_t___n_o_d_e_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___s_i_z_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___d_i_c_t_(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___a_t_(_)
│ │ │ │ │ + _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)
│ │ │ │ │ o _i_n_t___v_a_l_u_e_(_)
│ │ │ │ │ - o _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)
│ │ │ │ │ + o _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___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_(_)
│ │ │ │ │ @@ -619,15 +619,15 @@
│ │ │ │ │ o _t_i_c_k_(_)
│ │ │ │ │ o _c_o_u_n_t_e_r_s_(_)
│ │ │ │ │ * _s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ │ * _d_h_t___d_e_f_a_u_l_t___s_t_o_r_a_g_e___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │ * _a_n_n_o_u_n_c_e___f_l_a_g_s___t
│ │ │ │ │ * _r_e_a_d___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ * _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a___b_u_f_(_)_ _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ - * _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_)
│ │ │ │ │ + * _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ * _w_r_i_t_e___t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ │ * _e_d_2_5_5_1_9___c_r_e_a_t_e___s_e_e_d_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___c_r_e_a_t_e___k_e_y_p_a_i_r_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___s_i_g_n_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___v_e_r_i_f_y_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___a_d_d___s_c_a_l_a_r_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___k_e_y___e_x_c_h_a_n_g_e_(_)
│ │ │ │ │ @@ -635,29 +635,29 @@
│ │ │ │ │ ************ ssttoorraaggee__eerrrroorr ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p"
│ │ │ │ │ used by storage to return errors also includes which underlying file the error
│ │ │ │ │ happened on
│ │ │ │ │ struct storage_error
│ │ │ │ │ {
│ │ │ │ │ explicit operator bbooooll () const;
│ │ │ │ │ - file_index_t ffiillee () const;
│ │ │ │ │ void ffiillee (file_index_t f);
│ │ │ │ │ + file_index_t ffiillee () const;
│ │ │ │ │
│ │ │ │ │ error_code ec;
│ │ │ │ │ operation_t operation;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bbooooll(()) **********
│ │ │ │ │ explicit operator bbooooll () const;
│ │ │ │ │ explicitly converts to true if this object represents an error, and false if it
│ │ │ │ │ does not.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee(()) **********
│ │ │ │ │ -file_index_t ffiillee () const;
│ │ │ │ │ void ffiillee (file_index_t f);
│ │ │ │ │ +file_index_t ffiillee () const;
│ │ │ │ │ set and query the index (in the torrent) of the file this error occurred on.
│ │ │ │ │ This may also have special values defined in _t_o_r_r_e_n_t___s_t_a_t_u_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ec
│ │ │ │ │ the error that occurred
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ operation
│ │ │ │ │ @@ -1236,44 +1236,44 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ sseessssiioonn__ppaarraammss ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │ The _s_e_s_s_i_o_n___p_a_r_a_m_s is a parameters pack for configuring the _s_e_s_s_i_o_n before it's
│ │ │ │ │ started.
│ │ │ │ │ struct session_params
│ │ │ │ │ {
│ │ │ │ │ - sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ sseessssiioonn__ppaarraammss ();
│ │ │ │ │ + sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ - sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │ - , std::vector> exts);
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ , std::vector> exts);
│ │ │ │ │ + sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │ + , std::vector> exts);
│ │ │ │ │
│ │ │ │ │ settings_pack settings;
│ │ │ │ │ std::vector> extensions;
│ │ │ │ │ dht::dht_state dht_state;
│ │ │ │ │ dht::dht_storage_constructor_type dht_storage_constructor;
│ │ │ │ │ disk_io_constructor_type disk_io_constructor;
│ │ │ │ │ std::map ext_state;
│ │ │ │ │ libtorrent::ip_filter ip_filter;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn__ppaarraammss(()) **********
│ │ │ │ │ -sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ sseessssiioonn__ppaarraammss ();
│ │ │ │ │ +sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ This constructor can be used to start with the default plugins (ut_metadata,
│ │ │ │ │ ut_pex and smart_ban). Pass a _s_e_t_t_i_n_g_s___p_a_c_k to set the initial settings when
│ │ │ │ │ the _s_e_s_s_i_o_n starts.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn__ppaarraammss(()) **********
│ │ │ │ │ -sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │ - , std::vector> exts);
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ , std::vector> exts);
│ │ │ │ │ +sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │ + , std::vector> exts);
│ │ │ │ │ This constructor helps to configure the set of initial plugins to be added to
│ │ │ │ │ the _s_e_s_s_i_o_n before it's started.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ settings
│ │ │ │ │ The settings to configure the _s_e_s_s_i_o_n with
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ extensions
│ │ │ │ │ @@ -1306,27 +1306,27 @@
│ │ │ │ │ _s_e_s_s_i_o_n, causing the _s_e_s_s_i_o_n destructor to not block. The _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │ destructor will block however, until the underlying _s_e_s_s_i_o_n is done shutting
│ │ │ │ │ down.
│ │ │ │ │ struct session_proxy
│ │ │ │ │ {
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ - session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ - ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ + session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ + ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ~~sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) sseessssiioonn__pprrooxxyy(()) **********
│ │ │ │ │ +********** ooppeerraattoorr==(()) ~~sseessssiioonn__pprrooxxyy(()) sseessssiioonn__pprrooxxyy(()) **********
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ -session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ -~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ +session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ +~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ default constructor, does not refer to any _s_e_s_s_i_o_n implementation object.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ sseessssiioonn ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n_._h_p_p"
│ │ │ │ │ The _s_e_s_s_i_o_n holds all state that spans multiple torrents. Among other things it
│ │ │ │ │ runs the network loop and manages all torrents. Once it's created, the _s_e_s_s_i_o_n
│ │ │ │ │ object will spawn the main thread that will do all the work. The main thread
│ │ │ │ │ @@ -1334,47 +1334,47 @@
│ │ │ │ │ You have some control over _s_e_s_s_i_o_n configuration through the session_handle::
│ │ │ │ │ apply_settings() member function. To change one or more configuration options,
│ │ │ │ │ create a _s_e_t_t_i_n_g_s___p_a_c_k. object and fill it with the settings to be set and pass
│ │ │ │ │ it in to session::apply_settings().
│ │ │ │ │ see _a_p_p_l_y___s_e_t_t_i_n_g_s_(_).
│ │ │ │ │ struct session : session_handle
│ │ │ │ │ {
│ │ │ │ │ - sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │ - sseessssiioonn ();
│ │ │ │ │ - sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ + sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ + sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │ explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ - sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │ - sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ + sseessssiioonn ();
│ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ │ + sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ + sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │ ~~sseessssiioonn ();
│ │ │ │ │ session_proxy aabboorrtt ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn(()) **********
│ │ │ │ │ -sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │ -sseessssiioonn ();
│ │ │ │ │ -sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ +sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ +sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │ explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ +sseessssiioonn ();
│ │ │ │ │ Constructs the _s_e_s_s_i_o_n objects which acts as the container of torrents. In
│ │ │ │ │ order to avoid a race condition between starting the _s_e_s_s_i_o_n and configuring
│ │ │ │ │ it, you can pass in a _s_e_s_s_i_o_n___p_a_r_a_m_s object. Its settings will take effect
│ │ │ │ │ before the _s_e_s_s_i_o_n starts up.
│ │ │ │ │ The overloads taking flags can be used to start a _s_e_s_s_i_o_n in paused mode (by
│ │ │ │ │ passing in session::paused). Note that add_default_plugins do not have an
│ │ │ │ │ affect on constructors that take a _s_e_s_s_i_o_n___p_a_r_a_m_s object. It already contains
│ │ │ │ │ the plugins to use.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn(()) **********
│ │ │ │ │ -sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │ -sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ │ +sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ +sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │ Overload of the constructor that takes an external io_context to run the
│ │ │ │ │ _s_e_s_s_i_o_n object on. This is primarily useful for tests that may want to run
│ │ │ │ │ multiple sessions on a single io_context, or low resource systems where
│ │ │ │ │ additional threads are expensive and sharing an io_context with other events is
│ │ │ │ │ fine.
│ │ │ │ │ Warning
│ │ │ │ │ The _s_e_s_s_i_o_n object does not cleanly terminate with an external io_context. The
│ │ │ │ │ @@ -1422,74 +1422,74 @@
│ │ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ │ std::vector ggeett__ttoorrrreenntt__ssttaattuuss (
│ │ │ │ │ std::function const& pred
│ │ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ │ void ppoosstt__ttoorrrreenntt__uuppddaatteess (status_flags_t flags = status_flags_t::all());
│ │ │ │ │ void ppoosstt__sseessssiioonn__ssttaattss ();
│ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss ();
│ │ │ │ │ - void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │ + void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │ std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ + void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code&
│ │ │ │ │ ec);
│ │ │ │ │ - void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ void ppaauussee ();
│ │ │ │ │ - bool iiss__ppaauusseedd () const;
│ │ │ │ │ void rreessuummee ();
│ │ │ │ │ + bool iiss__ppaauusseedd () const;
│ │ │ │ │ bool iiss__ddhhtt__rruunnnniinngg () const;
│ │ │ │ │ void sseett__ddhhtt__ssttoorraaggee (dht::dht_storage_constructor_type sc);
│ │ │ │ │ void aadddd__ddhhtt__nnooddee (std::pair const& node);
│ │ │ │ │ void ddhhtt__ggeett__iitteemm (sha1_hash const& target);
│ │ │ │ │ void ddhhtt__ggeett__iitteemm (std::array key
│ │ │ │ │ , std::string salt = std::string());
│ │ │ │ │ sha1_hash ddhhtt__ppuutt__iitteemm (entry data);
│ │ │ │ │ void ddhhtt__ppuutt__iitteemm (std::array key
│ │ │ │ │ , std::function&
│ │ │ │ │ , std::int64_t&, std::string const&)> cb
│ │ │ │ │ , std::string salt = std::string());
│ │ │ │ │ - void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ void ddhhtt__aannnnoouunnccee (sha1_hash const& info_hash, int port = 0, dht::
│ │ │ │ │ announce_flags_t flags = {});
│ │ │ │ │ + void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ void ddhhtt__lliivvee__nnooddeess (sha1_hash const& nid);
│ │ │ │ │ void ddhhtt__ssaammppllee__iinnffoohhaasshheess (udp::endpoint const& ep, sha1_hash const&
│ │ │ │ │ target);
│ │ │ │ │ void ddhhtt__ddiirreecctt__rreeqquueesstt (udp::endpoint const& ep, entry const& e,
│ │ │ │ │ client_data_t userdata = {});
│ │ │ │ │ - void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │ void aadddd__eexxtteennssiioonn (std::function(
│ │ │ │ │ torrent_handle const&, client_data_t)> ext);
│ │ │ │ │ + void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │ ip_filter ggeett__iipp__ffiilltteerr () const;
│ │ │ │ │ void sseett__iipp__ffiilltteerr (ip_filter f);
│ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ │ + unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ - unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ - void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │ ip_filter ggeett__ppeeeerr__ccllaassss__ffiilltteerr () const;
│ │ │ │ │ - void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f);
│ │ │ │ │ + void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │ peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │ + void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f);
│ │ │ │ │ peer_class_t ccrreeaattee__ppeeeerr__ccllaassss (char const* name);
│ │ │ │ │ void ddeelleettee__ppeeeerr__ccllaassss (peer_class_t cid);
│ │ │ │ │ peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const;
│ │ │ │ │ void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │ void rreemmoovvee__ttoorrrreenntt (const torrent_handle&, remove_flags_t = {});
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ - settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │ + settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │ - void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │ std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int
│ │ │ │ │ external_port, int local_port);
│ │ │ │ │ + void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │ void rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options =
│ │ │ │ │ reopen_map_ports);
│ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │
│ │ │ │ │ static constexpr save_state_flags_t ssaavvee__sseettttiinnggss = 0_bit;
│ │ │ │ │ static constexpr save_state_flags_t ssaavvee__ddhhtt__ssttaattee = 2_bit;
│ │ │ │ │ static constexpr save_state_flags_t ssaavvee__eexxtteennssiioonn__ssttaattee = 11_bit;
│ │ │ │ │ @@ -1573,37 +1573,37 @@
│ │ │ │ │ For more information, see the _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppoosstt__ddhhtt__ssttaattss(()) **********
│ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss ();
│ │ │ │ │ This will cause a _d_h_t___s_t_a_t_s___a_l_e_r_t to be posted.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__ddhhtt__ssttaattee(()) **********
│ │ │ │ │ -void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │ +void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ set the DHT state for the _s_e_s_s_i_o_n. This will be taken into account the next
│ │ │ │ │ time the DHT is started, as if it had been passed in via the _s_e_s_s_i_o_n___p_a_r_a_m_s on
│ │ │ │ │ startup.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ggeett__ttoorrrreennttss(()) ffiinndd__ttoorrrreenntt(()) **********
│ │ │ │ │ +********** ffiinndd__ttoorrrreenntt(()) ggeett__ttoorrrreennttss(()) **********
│ │ │ │ │ torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │ std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │ find_torrent() looks for a torrent with the given info-hash. In case there is
│ │ │ │ │ such a torrent in the _s_e_s_s_i_o_n, a _t_o_r_r_e_n_t___h_a_n_d_l_e to that torrent is returned. In
│ │ │ │ │ case the torrent cannot be found, an invalid _t_o_r_r_e_n_t___h_a_n_d_l_e is returned.
│ │ │ │ │ See torrent_handle::is_valid() to know if the torrent was found or not.
│ │ │ │ │ get_torrents() returns a vector of torrent_handles to all the torrents
│ │ │ │ │ currently in the _s_e_s_s_i_o_n.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aadddd__ttoorrrreenntt(()) aassyynncc__aadddd__ttoorrrreenntt(()) **********
│ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec);
│ │ │ │ │ -void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ +void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ You add torrents through the _a_d_d___t_o_r_r_e_n_t_(_) function where you give an object
│ │ │ │ │ with all the parameters. The _a_d_d___t_o_r_r_e_n_t_(_) overloads will block until the
│ │ │ │ │ torrent has been added (or failed to be added) and returns an error code and a
│ │ │ │ │ _t_o_r_r_e_n_t___h_a_n_d_l_e. In order to add torrents more efficiently, consider using
│ │ │ │ │ _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) which returns immediately, without waiting for the torrent
│ │ │ │ │ to add. Notification of the torrent being added is sent as _a_d_d___t_o_r_r_e_n_t___a_l_e_r_t.
│ │ │ │ │ The overload that does not take an error_code throws an exception on error and
│ │ │ │ │ @@ -1620,18 +1620,18 @@
│ │ │ │ │ torrent_flags::paused and torrent_flags::auto_managed. In order to add a magnet
│ │ │ │ │ link that will just download the metadata, but no payload, set the
│ │ │ │ │ torrent_flags::upload_mode flag.
│ │ │ │ │ Special consideration has to be taken when adding hybrid torrents (i.e.
│ │ │ │ │ torrents that are BitTorrent v2 torrents that are backwards compatible with
│ │ │ │ │ v1). For more details, see _B_i_t_T_o_r_r_e_n_t_ _v_2_ _t_o_r_r_e_n_t_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppaauussee(()) rreessuummee(()) iiss__ppaauusseedd(()) **********
│ │ │ │ │ +********** iiss__ppaauusseedd(()) ppaauussee(()) rreessuummee(()) **********
│ │ │ │ │ void ppaauussee ();
│ │ │ │ │ -bool iiss__ppaauusseedd () const;
│ │ │ │ │ void rreessuummee ();
│ │ │ │ │ +bool iiss__ppaauusseedd () const;
│ │ │ │ │ Pausing the _s_e_s_s_i_o_n has the same effect as pausing every torrent in it, except
│ │ │ │ │ that torrents will not be resumed by the auto-manage mechanism. Resuming will
│ │ │ │ │ restore the torrents to their previous paused state. i.e. the _s_e_s_s_i_o_n pause
│ │ │ │ │ state is separate from the torrent pause state. A torrent is inactive if it is
│ │ │ │ │ paused or if the _s_e_s_s_i_o_n is paused.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iiss__ddhhtt__rruunnnniinngg(()) **********
│ │ │ │ │ @@ -1707,18 +1707,18 @@
│ │ │ │ │ and make the function entirely self-contained. The only reason data blob's
│ │ │ │ │ value is computed via a function instead of just passing in the new value is to
│ │ │ │ │ avoid race conditions. If you want to uuppddaattee the value in the DHT, you must
│ │ │ │ │ first retrieve it, then modify it, then write it back. The way the DHT works,
│ │ │ │ │ it is natural to always do a lookup before storing and calling the callback in
│ │ │ │ │ between is convenient.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddhhtt__ggeett__ppeeeerrss(()) ddhhtt__aannnnoouunnccee(()) **********
│ │ │ │ │ -void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ +********** ddhhtt__aannnnoouunnccee(()) ddhhtt__ggeett__ppeeeerrss(()) **********
│ │ │ │ │ void ddhhtt__aannnnoouunnccee (sha1_hash const& info_hash, int port = 0, dht::
│ │ │ │ │ announce_flags_t flags = {});
│ │ │ │ │ +void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ dht_get_peers() will issue a DHT get_peer request to the DHT for the specified
│ │ │ │ │ info-hash. The response (the peers) will be posted back in a
│ │ │ │ │ _d_h_t___g_e_t___p_e_e_r_s___r_e_p_l_y___a_l_e_r_t.
│ │ │ │ │ dht_announce() will issue a DHT announce request to the DHT to the specified
│ │ │ │ │ info-hash, advertising the specified port. If the port is left at its default,
│ │ │ │ │ 0, the port will be implied by the DHT message's source port (which may improve
│ │ │ │ │ connectivity through a NAT).
│ │ │ │ │ @@ -1749,17 +1749,17 @@
│ │ │ │ │ Send an arbitrary DHT request directly to the specified endpoint. This function
│ │ │ │ │ is intended for use by plugins. When a response is received or the request
│ │ │ │ │ times out, a _d_h_t___d_i_r_e_c_t___r_e_s_p_o_n_s_e___a_l_e_r_t will be posted with the response (if
│ │ │ │ │ any) and the userdata pointer passed in here. Since this _a_l_e_r_t is a response to
│ │ │ │ │ an explicit call, it will always be posted, regardless of the _a_l_e_r_t mask.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aadddd__eexxtteennssiioonn(()) **********
│ │ │ │ │ -void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │ void aadddd__eexxtteennssiioonn (std::function(
│ │ │ │ │ torrent_handle const&, client_data_t)> ext);
│ │ │ │ │ +void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │ This function adds an extension to this _s_e_s_s_i_o_n. The argument is a function
│ │ │ │ │ object that is called with a torrent_handle and which should return a std::
│ │ │ │ │ shared_ptr. To write custom plugins, see _l_i_b_t_o_r_r_e_n_t_ _p_l_u_g_i_n_s.
│ │ │ │ │ For the typical bittorrent client all of these extensions should be added. The
│ │ │ │ │ main plugins implemented in libtorrent are:
│ │ │ │ │ uTorrent metadata
│ │ │ │ │ Allows peers to download the metadata (.torrent files) from the swarm
│ │ │ │ │ @@ -1774,15 +1774,15 @@
│ │ │ │ │ smart ban _p_l_u_g_i_n
│ │ │ │ │ A _p_l_u_g_i_n that, with a small overhead, can ban peers that sends bad data
│ │ │ │ │ with very high accuracy. Should eliminate most problems on poisoned
│ │ │ │ │ torrents.
│ │ │ │ │ #include
│ │ │ │ │ ses.add_extension(<::create_smart_ban_plugin);
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__iipp__ffiilltteerr(()) ggeett__iipp__ffiilltteerr(()) **********
│ │ │ │ │ +********** ggeett__iipp__ffiilltteerr(()) sseett__iipp__ffiilltteerr(()) **********
│ │ │ │ │ ip_filter ggeett__iipp__ffiilltteerr () const;
│ │ │ │ │ void sseett__iipp__ffiilltteerr (ip_filter f);
│ │ │ │ │ Sets a filter that will be used to reject and accept incoming as well as
│ │ │ │ │ outgoing connections based on their originating ip address. The default filter
│ │ │ │ │ will allow connections to any ip address. To build a set of rules for which
│ │ │ │ │ addresses are accepted and not, see _i_p___f_i_l_t_e_r.
│ │ │ │ │ Each time a peer is blocked because of the IP filter, a _p_e_e_r___b_l_o_c_k_e_d___a_l_e_r_t is
│ │ │ │ │ @@ -1792,27 +1792,27 @@
│ │ │ │ │ ********** sseett__ppoorrtt__ffiilltteerr(()) **********
│ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ │ apply _p_o_r_t___f_i_l_t_e_r f to incoming and outgoing peers. a port filter will reject
│ │ │ │ │ making outgoing peer connections to certain remote ports. The main intention is
│ │ │ │ │ to be able to avoid triggering certain anti-virus software by connecting to
│ │ │ │ │ SMTP, FTP ports.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iiss__lliisstteenniinngg(()) lliisstteenn__ppoorrtt(()) ssssll__lliisstteenn__ppoorrtt(()) **********
│ │ │ │ │ +********** ssssll__lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) lliisstteenn__ppoorrtt(()) **********
│ │ │ │ │ +unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ -unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ is_listening() will tell you whether or not the _s_e_s_s_i_o_n has successfully opened
│ │ │ │ │ a listening port. If it hasn't, this function will return false, and then you
│ │ │ │ │ can set a new _s_e_t_t_i_n_g_s___p_a_c_k_:_:_l_i_s_t_e_n___i_n_t_e_r_f_a_c_e_s to try another interface and
│ │ │ │ │ port to bind to.
│ │ │ │ │ listen_port() returns the port we ended up listening on.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__ppeeeerr__ccllaassss__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) **********
│ │ │ │ │ -void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │ ip_filter ggeett__ppeeeerr__ccllaassss__ffiilltteerr () const;
│ │ │ │ │ +void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │ Sets the peer class filter for this _s_e_s_s_i_o_n. All new peer connections will take
│ │ │ │ │ this into account and be added to the peer classes specified by this filter,
│ │ │ │ │ based on the peer's IP address.
│ │ │ │ │ The ip-filter essentially maps an IP -> uint32. Each bit in that 32 bit integer
│ │ │ │ │ represents a peer class. The least significant bit represents class 0, the next
│ │ │ │ │ bit class 1 and so on.
│ │ │ │ │ For more info, see _i_p___f_i_l_t_e_r.
│ │ │ │ │ @@ -1829,17 +1829,17 @@
│ │ │ │ │ in the IP range mapping. Only the set bits matter; no peer class will be
│ │ │ │ │ removed from a peer as a result of this call, peer classes are only added.
│ │ │ │ │ The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ │ │ peer classes in the peer_class_filter are 32 bits.
│ │ │ │ │ The get_peer_class_filter() function returns the current filter.
│ │ │ │ │ For more information, see _p_e_e_r_ _c_l_a_s_s_e_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) **********
│ │ │ │ │ -void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f);
│ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) **********
│ │ │ │ │ peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │ +void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f);
│ │ │ │ │ Sets and gets the ppeeeerr ccllaassss ttyyppee ffiilltteerr. This is controls automatic peer class
│ │ │ │ │ assignments to peers based on what kind of socket it is.
│ │ │ │ │ It does not only support assigning peer classes, it also supports removing peer
│ │ │ │ │ classes based on socket type.
│ │ │ │ │ The order of these rules being applied are:
│ │ │ │ │ 1. peer-class IP filter
│ │ │ │ │ 2. peer-class type filter, removing classes
│ │ │ │ │ @@ -1907,18 +1907,18 @@
│ │ │ │ │ session.remove_handle(handle); handle.save_resume_data();
│ │ │ │ │ Note that when a queued or downloading torrent is removed, its position in the
│ │ │ │ │ download queue is vacated and every subsequent torrent in the queue has their
│ │ │ │ │ queue positions updated. This can potentially cause a large state_update to be
│ │ │ │ │ posted. When removing all torrents, it is advised to remove them from the back
│ │ │ │ │ of the queue, to minimize the shifting.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ggeett__sseettttiinnggss(()) aappppllyy__sseettttiinnggss(()) **********
│ │ │ │ │ +********** aappppllyy__sseettttiinnggss(()) ggeett__sseettttiinnggss(()) **********
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ -settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │ +settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ Applies the settings specified by the _s_e_t_t_i_n_g_s___p_a_c_k s. This is an asynchronous
│ │ │ │ │ operation that will return immediately and actually apply the settings to the
│ │ │ │ │ main thread of libtorrent some time later.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__aalleerrtt__nnoottiiffyy(()) wwaaiitt__ffoorr__aalleerrtt(()) ppoopp__aalleerrttss(()) **********
│ │ │ │ │ alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │ @@ -1966,17 +1966,17 @@
│ │ │ │ │ block. It should not perform any expensive work. It really should just notify
│ │ │ │ │ the main application thread.
│ │ │ │ │ The type of an _a_l_e_r_t is returned by the polymorphic function alert::type() but
│ │ │ │ │ can also be queries from a concrete type via T::alert_type, as a static
│ │ │ │ │ constant.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ddeelleettee__ppoorrtt__mmaappppiinngg(()) aadddd__ppoorrtt__mmaappppiinngg(()) **********
│ │ │ │ │ -void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │ std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int
│ │ │ │ │ external_port, int local_port);
│ │ │ │ │ +void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │ add_port_mapping adds one or more port forwards on UPnP and/or NAT-PMP,
│ │ │ │ │ whichever is enabled. A mapping is created for each listen socket in the
│ │ │ │ │ _s_e_s_s_i_o_n. The return values are all handles referring to the port mappings that
│ │ │ │ │ were just created. Pass them to _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_) to remove them.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** rreeooppeenn__nneettwwoorrkk__ssoocckkeettss(()) **********
│ │ │ │ │ void rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options =
│ │ │ │ │ @@ -2022,25 +2022,25 @@
│ │ │ │ │ protocols used by _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ reopen_map_ports
│ │ │ │ │ This option indicates if the ports are mapped using natpmp and upnp. If
│ │ │ │ │ mapping was already made, they are deleted and added again. This only
│ │ │ │ │ works if natpmp and/or upnp are configured to be enable.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) wwrriittee__sseessssiioonn__ppaarraammss(()) rreeaadd__sseessssiioonn__ppaarraammss(())
│ │ │ │ │ +************ rreeaadd__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(())
│ │ │ │ │ ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │ -entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp
│ │ │ │ │ - , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (session_params const& sp
│ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ -session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf
│ │ │ │ │ +entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp
│ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ session_params rreeaadd__sseessssiioonn__ppaarraammss (bdecode_node const& e
│ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ +session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf
│ │ │ │ │ + , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ These functions serialize and de-serialize a session_params object to and from
│ │ │ │ │ bencoded form. The _s_e_s_s_i_o_n___p_a_r_a_m_s object is used to initialize a new _s_e_s_s_i_o_n
│ │ │ │ │ using the state from a previous one (or by programmatically configure the
│ │ │ │ │ _s_e_s_s_i_o_n up-front). The flags parameter can be used to only save and load
│ │ │ │ │ certain aspects of the session's state. The _buf suffix indicates the function
│ │ │ │ │ operates on buffer rather than the bencoded structure. The torrents in a
│ │ │ │ │ _s_e_s_s_i_o_n are not part of the _s_e_s_s_i_o_n___p_a_r_a_m_s state, they have to be restored
│ │ │ │ │ @@ -2122,74 +2122,74 @@
│ │ │ │ │ the max number of bdecode tokens
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ttoorrrreenntt__iinnffoo ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___i_n_f_o_._h_p_p"
│ │ │ │ │ the _t_o_r_r_e_n_t___i_n_f_o class holds the information found in a .torrent file.
│ │ │ │ │ class torrent_info
│ │ │ │ │ {
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ +from_span_t);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ cfg);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ -from_span_t);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │ file_storage const& ffiilleess () const;
│ │ │ │ │ file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │ void rreemmaapp__ffiilleess (file_storage const& f);
│ │ │ │ │ - void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ - void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ │ - std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ + void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ + void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ - void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ - , std::string const& extern_auth = std::string()
│ │ │ │ │ - , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │ - std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ + std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& ext_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ + void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ + , std::string const& extern_auth = std::string()
│ │ │ │ │ + , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │ void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ + std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ - int nnuumm__ppiieecceess () const;
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ + int nnuumm__ppiieecceess () const;
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ - piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ - index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ + index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ + piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ - bool vv11 () const;
│ │ │ │ │ bool vv22 () const;
│ │ │ │ │ + bool vv11 () const;
│ │ │ │ │ int nnuumm__ffiilleess () const;
│ │ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t const piece
│ │ │ │ │ , std::int64_t offset, int size) const;
│ │ │ │ │ peer_request mmaapp__ffiillee (file_index_t const file, std::int64_t offset, int
│ │ │ │ │ size) const;
│ │ │ │ │ string_view ssssll__cceerrtt () const;
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ bool pprriivv () const;
│ │ │ │ │ bool iiss__ii22pp () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ - char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ + char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ bool iiss__llooaaddeedd () const;
│ │ │ │ │ const std::string& nnaammee () const;
│ │ │ │ │ std::time_t ccrreeaattiioonn__ddaattee () const;
│ │ │ │ │ const std::string& ccrreeaattoorr () const;
│ │ │ │ │ const std::string& ccoommmmeenntt () const;
│ │ │ │ │ std::vector> const& nnooddeess () const;
│ │ │ │ │ void aadddd__nnooddee (std::pair const& node);
│ │ │ │ │ @@ -2198,29 +2198,29 @@
│ │ │ │ │ bdecode_node iinnffoo (char const* key) const;
│ │ │ │ │ span iinnffoo__sseeccttiioonn () const;
│ │ │ │ │ span ppiieeccee__llaayyeerr (file_index_t) const;
│ │ │ │ │ void ffrreeee__ppiieeccee__llaayyeerrss ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ +from_span_t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ cfg);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ -from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ The constructor that takes an info-hash will initialize the info-hash to the
│ │ │ │ │ given value, but leave all other fields empty. This is used internally when
│ │ │ │ │ downloading torrents without the metadata. The metadata will be created by
│ │ │ │ │ libtorrent as soon as it has been downloaded from the swarm.
│ │ │ │ │ The constructor that takes a _b_d_e_c_o_d_e___n_o_d_e will create a _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ │ from the information found in the given torrent_file. The _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ │ represents a tree node in an bencoded file. To load an ordinary .torrent file
│ │ │ │ │ @@ -2286,49 +2286,49 @@
│ │ │ │ │ Remaps the file storage to a new file layout. This can be used to, for
│ │ │ │ │ instance, download all data in a torrent to a single file, or to a number of
│ │ │ │ │ fixed size sector aligned files, regardless of the number and sizes of the
│ │ │ │ │ files in the torrent.
│ │ │ │ │ The new specified file_storage must have the exact same size as the current
│ │ │ │ │ one.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__ttrraacckkeerr(()) ttrraacckkeerrss(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ │ -void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ +********** cclleeaarr__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ │ +void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ add_tracker() adds a tracker to the announce-list. The tier determines the
│ │ │ │ │ order in which the trackers are to be tried. The trackers() function will
│ │ │ │ │ return a sorted vector of _a_n_n_o_u_n_c_e___e_n_t_r_y. Each announce _e_n_t_r_y contains a
│ │ │ │ │ string, which is the tracker url, and a tier index. The tier index is the high-
│ │ │ │ │ level priority. No matter which trackers that works or not, the ones with lower
│ │ │ │ │ tier will always be tried before the one with higher tier number. For more
│ │ │ │ │ information, see _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ trackers() returns all entries from announce-list.
│ │ │ │ │ clear_trackers() removes all trackers from announce-list.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssiimmiillaarr__ttoorrrreennttss(()) ccoolllleeccttiioonnss(()) **********
│ │ │ │ │ -std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ +********** ccoolllleeccttiioonnss(()) ssiimmiillaarr__ttoorrrreennttss(()) **********
│ │ │ │ │ std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ +std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ These two functions are related to _B_E_P_ _3_8 (mutable torrents). The vectors
│ │ │ │ │ returned from these correspond to the "similar" and "collections" keys in the
│ │ │ │ │ .torrent file. Both info-hashes and collections from within the info-dict and
│ │ │ │ │ from outside of it are included.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__uurrll__sseeeedd(()) sseett__wweebb__sseeeeddss(()) wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ - , std::string const& extern_auth = std::string()
│ │ │ │ │ - , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │ -std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ +********** wweebb__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) sseett__wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& ext_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ +void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ + , std::string const& extern_auth = std::string()
│ │ │ │ │ + , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │ void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ +std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ web_seeds() returns all url seeds and http seeds in the torrent. Each _e_n_t_r_y is
│ │ │ │ │ a web_seed_entry and may refer to either a url seed or http seed.
│ │ │ │ │ add_url_seed() and add_http_seed() adds one url to the list of url/http seeds.
│ │ │ │ │ set_web_seeds() replaces all web seeds with the ones specified in the seeds
│ │ │ │ │ vector.
│ │ │ │ │ The extern_auth argument can be used for other authorization schemes than basic
│ │ │ │ │ HTTP authorization. If set, it will override any username and password found in
│ │ │ │ │ @@ -2342,46 +2342,46 @@
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ total_size() returns the total number of bytes the torrent-file represents.
│ │ │ │ │ Note that this is the number of pieces times the piece size (modulo the last
│ │ │ │ │ piece possibly being smaller). With pad files, the total size will be larger
│ │ │ │ │ than the sum of all (regular) file sizes.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__lleennggtthh(()) nnuumm__ppiieecceess(()) **********
│ │ │ │ │ -int nnuumm__ppiieecceess () const;
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +int nnuumm__ppiieecceess () const;
│ │ │ │ │ piece_length() and num_pieces() returns the number of byte for each piece and
│ │ │ │ │ the total number of pieces, respectively. The difference between piece_size()
│ │ │ │ │ and piece_length() is that piece_size() takes the piece index as argument and
│ │ │ │ │ gives you the exact size of that piece. It will always be the same as
│ │ │ │ │ piece_length() except in the case of the last piece, which may be smaller.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bblloocckkss__ppeerr__ppiieeccee(()) **********
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ returns the number of blocks there are in the typical piece. There may be fewer
│ │ │ │ │ in the last piece)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** eenndd__ppiieeccee(()) ppiieeccee__rraannggee(()) llaasstt__ppiieeccee(()) **********
│ │ │ │ │ -piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ -index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ +********** ppiieeccee__rraannggee(()) llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) **********
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ +index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ +piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ last_piece() returns the index to the last piece in the torrent and end_piece()
│ │ │ │ │ returns the index to the one-past-end piece in the torrent piece_range()
│ │ │ │ │ returns an implementation-defined type that can be used as the container in a
│ │ │ │ │ range-for loop. Where the values are the indices of all pieces in the
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iinnffoo__hhaasshheess(()) iinnffoo__hhaasshh(()) **********
│ │ │ │ │ +********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ returns the info-hash of the torrent. For BitTorrent v2 support, use
│ │ │ │ │ info_hashes() to get an object that may hold both a v1 and v2 info-hash
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** vv22(()) vv11(()) **********
│ │ │ │ │ -bool vv11 () const;
│ │ │ │ │ +********** vv11(()) vv22(()) **********
│ │ │ │ │ bool vv22 () const;
│ │ │ │ │ +bool vv11 () const;
│ │ │ │ │ returns whether this torrent has v1 and/or v2 metadata, respectively. Hybrid
│ │ │ │ │ torrents have both. These are shortcuts for info_hashes().has_v1() and
│ │ │ │ │ info_hashes().has_v2() calls.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnuumm__ffiilleess(()) **********
│ │ │ │ │ int nnuumm__ffiilleess () const;
│ │ │ │ │ If you need index-access to files you can use the num_files() along with the
│ │ │ │ │ @@ -2429,17 +2429,17 @@
│ │ │ │ │ than the i2p network.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ returns the piece size of file with index. This will be the same as
│ │ │ │ │ _p_i_e_c_e___l_e_n_g_t_h_(_), except for the last piece, which may be shorter.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaasshh__ffoorr__ppiieeccee__ppttrr(()) hhaasshh__ffoorr__ppiieeccee(()) **********
│ │ │ │ │ -char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ +********** hhaasshh__ffoorr__ppiieeccee(()) hhaasshh__ffoorr__ppiieeccee__ppttrr(()) **********
│ │ │ │ │ sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ +char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ hash_for_piece() takes a piece-index and returns the 20-bytes sha1-hash for
│ │ │ │ │ that piece and info_hash() returns the 20-bytes sha1-hash for the info-section
│ │ │ │ │ of the torrent file. hash_for_piece_ptr() returns a pointer to the 20 byte sha1
│ │ │ │ │ digest for the piece. Note that the string is not 0-terminated.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnaammee(()) **********
│ │ │ │ │ const std::string& nnaammee () const;
│ │ │ │ │ @@ -2982,41 +2982,41 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ start
│ │ │ │ │ The byte offset within that piece where the range starts.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ length
│ │ │ │ │ The size of the range, in bytes.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ llooaadd__ttoorrrreenntt__ppaarrsseedd(()) llooaadd__ttoorrrreenntt__bbuuffffeerr(()) llooaadd__ttoorrrreenntt__ffiillee(()) ************
│ │ │ │ │ +************ llooaadd__ttoorrrreenntt__ppaarrsseedd(()) llooaadd__ttoorrrreenntt__ffiillee(()) llooaadd__ttoorrrreenntt__bbuuffffeerr(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_l_o_a_d___t_o_r_r_e_n_t_._h_p_p"
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ - bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ - span buffer, load_torrent_limits const& cfg);
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │ - std::string const& filename);
│ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │ std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │ + std::string const& filename);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ + bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ bdecode_node const& torrent_file);
│ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ + span buffer, load_torrent_limits const& cfg);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ span buffer);
│ │ │ │ │ These functions load the content of a .torrent file into an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ │ object. The immutable part of a torrent file (the info-dictionary) is stored in
│ │ │ │ │ the ti field in the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object (as a _t_o_r_r_e_n_t___i_n_f_o object). The
│ │ │ │ │ returned object is suitable to be:
│ │ │ │ │ * added to a _s_e_s_s_i_o_n via _a_d_d___t_o_r_r_e_n_t_(_) or _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ * saved as a .torrent_file via _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ * turned into a magnet link via _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ mmaakkee__mmaaggnneett__uurrii(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p"
│ │ │ │ │ -std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info);
│ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle);
│ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp);
│ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info);
│ │ │ │ │ Generates a magnet URI from the specified torrent.
│ │ │ │ │ Several fields from the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s objects are recorded in the magnet
│ │ │ │ │ link. In order to not include them, they have to be cleared before calling
│ │ │ │ │ _m_a_k_e___m_a_g_n_e_t___u_r_i_(_). These fields are used:
│ │ │ │ │ ti, info_hashes, url_seeds, dht_nodes, file_priorities, trackers,
│ │ │ │ │ name, peers.
│ │ │ │ │ Depending on what the use case for the resulting magnet link is, clearing peers
│ │ │ │ │ @@ -3542,19 +3542,19 @@
│ │ │ │ │ Torrent plugins are associated with a single torrent and have a number of
│ │ │ │ │ functions called at certain events. Many of its functions have the ability to
│ │ │ │ │ change or override the default libtorrent behavior.
│ │ │ │ │ struct torrent_plugin
│ │ │ │ │ {
│ │ │ │ │ virtual std::shared_ptr nneeww__ccoonnnneeccttiioonn (peer_connection_handle
│ │ │ │ │ const&);
│ │ │ │ │ - virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ + virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ - virtual bool oonn__ppaauussee ();
│ │ │ │ │ virtual bool oonn__rreessuummee ();
│ │ │ │ │ + virtual bool oonn__ppaauussee ();
│ │ │ │ │ virtual void oonn__ffiilleess__cchheecckkeedd ();
│ │ │ │ │ virtual void oonn__ssttaattee (torrent_status::state_t);
│ │ │ │ │ virtual void oonn__aadddd__ppeeeerr (tcp::endpoint const&,
│ │ │ │ │ peer_source_flags_t, add_peer_flags_t);
│ │ │ │ │
│ │ │ │ │ static constexpr add_peer_flags_t ffiirrsstt__ttiimmee = 1_bit;
│ │ │ │ │ static constexpr add_peer_flags_t ffiilltteerreedd = 2_bit;
│ │ │ │ │ @@ -3571,30 +3571,30 @@
│ │ │ │ │ have its hook functions called on event specific to that peer.
│ │ │ │ │ The peer_connection_handle will be valid as long as the shared_ptr is being
│ │ │ │ │ held by the torrent object. So, it is generally a good idea to not keep a
│ │ │ │ │ shared_ptr to your own _p_e_e_r___p_l_u_g_i_n. If you want to keep references to it, use
│ │ │ │ │ weak_ptr.
│ │ │ │ │ If this function throws an exception, the connection will be closed.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) **********
│ │ │ │ │ -virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ +********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ +virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ These hooks are called when a piece passes the hash check or fails the hash
│ │ │ │ │ check, respectively. The index is the piece index that was downloaded. It is
│ │ │ │ │ possible to access the list of peers that participated in sending the piece
│ │ │ │ │ through the torrent and the piece_picker.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttiicckk(()) **********
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ This hook is called approximately once per second. It is a way of making it
│ │ │ │ │ easy for plugins to do timed events, for sending messages or whatever.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__rreessuummee(()) oonn__ppaauussee(()) **********
│ │ │ │ │ -virtual bool oonn__ppaauussee ();
│ │ │ │ │ +********** oonn__ppaauussee(()) oonn__rreessuummee(()) **********
│ │ │ │ │ virtual bool oonn__rreessuummee ();
│ │ │ │ │ +virtual bool oonn__ppaauussee ();
│ │ │ │ │ These hooks are called when the torrent is paused and resumed respectively. The
│ │ │ │ │ return value indicates if the event was handled. A return value of true
│ │ │ │ │ indicates that it was handled, and no other _p_l_u_g_i_n after this one will have
│ │ │ │ │ this hook function called, and the standard handler will also not be invoked.
│ │ │ │ │ So, returning true effectively overrides the standard behavior of pause or
│ │ │ │ │ resume.
│ │ │ │ │ Note that if you call pause() or resume() on the torrent from your handler it
│ │ │ │ │ @@ -3640,51 +3640,51 @@
│ │ │ │ │ {
│ │ │ │ │ virtual string_view ttyyppee () const;
│ │ │ │ │ virtual void aadddd__hhaannddsshhaakkee (entry&);
│ │ │ │ │ virtual void oonn__ddiissccoonnnneecctt (error_code const&);
│ │ │ │ │ virtual void oonn__ccoonnnneecctteedd ();
│ │ │ │ │ virtual bool oonn__hhaannddsshhaakkee (span);
│ │ │ │ │ virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (bdecode_node const&);
│ │ │ │ │ - virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ - virtual bool oonn__cchhookkee ();
│ │ │ │ │ - virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ - virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ - virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ - virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ + virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ + virtual bool oonn__cchhookkee ();
│ │ │ │ │ + virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ + virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ + virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ + virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ + virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ - virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**//
│ │ │ │ │ , span //**bbuuff**//);
│ │ │ │ │ + virtual bool oonn__rreejjeecctt (peer_request const&);
│ │ │ │ │ virtual bool oonn__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ virtual bool oonn__ccaanncceell (peer_request const&);
│ │ │ │ │ - virtual bool oonn__rreejjeecctt (peer_request const&);
│ │ │ │ │ virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ - virtual void sseenntt__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ - virtual void sseenntt__hhaavvee__nnoonnee ();
│ │ │ │ │ - virtual void sseenntt__ccaanncceell (peer_request const&);
│ │ │ │ │ - virtual void sseenntt__hhaavvee__aallll ();
│ │ │ │ │ virtual void sseenntt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ + virtual void sseenntt__hhaavvee__nnoonnee ();
│ │ │ │ │ virtual void sseenntt__cchhookkee ();
│ │ │ │ │ + virtual void sseenntt__hhaavvee__aallll ();
│ │ │ │ │ + virtual void sseenntt__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ + virtual void sseenntt__ccaanncceell (peer_request const&);
│ │ │ │ │ virtual void sseenntt__aallllooww__ffaasstt (piece_index_t);
│ │ │ │ │ - virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ - virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ - virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ + virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ + virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ + virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//);
│ │ │ │ │ virtual bool ccaann__ddiissccoonnnneecctt (error_code const& //**eecc**//);
│ │ │ │ │ virtual bool oonn__eexxtteennddeedd (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │ span //**bbooddyy**//);
│ │ │ │ │ virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │ span //**bbooddyy**//);
│ │ │ │ │ - virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ + virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ virtual bool wwrriittee__rreeqquueesstt (peer_request const&);
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttyyppee(()) **********
│ │ │ │ │ virtual string_view ttyyppee () const;
│ │ │ │ │ This function is expected to return the name of the _p_l_u_g_i_n.
│ │ │ │ │ @@ -3712,48 +3712,48 @@
│ │ │ │ │ ********** oonn__eexxtteennssiioonn__hhaannddsshhaakkee(()) **********
│ │ │ │ │ virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (bdecode_node const&);
│ │ │ │ │ called when the extension handshake from the other end is received if this
│ │ │ │ │ returns false, it means that this extension isn't supported by this peer. It
│ │ │ │ │ will result in this _p_e_e_r___p_l_u_g_i_n being removed from the peer_connection and
│ │ │ │ │ destructed. this is not called for web seeds
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__cchhookkee(()) oonn__iinntteerreesstteedd(()) oonn__hhaavvee(()) oonn__hhaavvee__nnoonnee(()) oonn__uunncchhookkee(())
│ │ │ │ │ -oonn__aalllloowweedd__ffaasstt(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee__aallll(()) oonn__rreeqquueesstt(()) oonn__bbiittffiieelldd(())
│ │ │ │ │ -oonn__ddoonntt__hhaavvee(()) **********
│ │ │ │ │ -virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ -virtual bool oonn__cchhookkee ();
│ │ │ │ │ -virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ -virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ +********** oonn__iinntteerreesstteedd(()) oonn__ddoonntt__hhaavvee(()) oonn__uunncchhookkee(()) oonn__cchhookkee(()) oonn__bbiittffiieelldd(())
│ │ │ │ │ +oonn__hhaavvee__aallll(()) oonn__aalllloowweedd__ffaasstt(()) oonn__rreeqquueesstt(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee(())
│ │ │ │ │ +oonn__hhaavvee__nnoonnee(()) **********
│ │ │ │ │ virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ +virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ +virtual bool oonn__cchhookkee ();
│ │ │ │ │ +virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ +virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ +virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ +virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ -virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ returning true from any of the message handlers indicates that the _p_l_u_g_i_n has
│ │ │ │ │ handled the message. it will break the _p_l_u_g_i_n chain traversing and not let
│ │ │ │ │ anyone else handle the message, including the default handler.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** oonn__ppiieeccee(()) **********
│ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**//
│ │ │ │ │ , span //**bbuuff**//);
│ │ │ │ │ This function is called when the peer connection is receiving a piece. buf
│ │ │ │ │ points (non-owning pointer) to the data in an internal immutable disk buffer.
│ │ │ │ │ The length of the data is specified in the length member of the piece
│ │ │ │ │ parameter. returns true to indicate that the piece is handled and the rest of
│ │ │ │ │ the logic should be ignored.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseenntt__hhaavvee(()) sseenntt__uunncchhookkee(()) sseenntt__iinntteerreesstteedd(()) sseenntt__nnoott__iinntteerreesstteedd(())
│ │ │ │ │ -sseenntt__ppiieeccee(()) **********
│ │ │ │ │ -virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ -virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ -virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +********** sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__hhaavvee(()) sseenntt__ppiieeccee(()) sseenntt__uunncchhookkee(())
│ │ │ │ │ +sseenntt__iinntteerreesstteedd(()) **********
│ │ │ │ │ virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ +virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ +virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ +virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ called after a choke message has been sent to the peer
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseenntt__ppaayyllooaadd(()) **********
│ │ │ │ │ virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//);
│ │ │ │ │ called after piece data has been sent to the peer this can be used for stats
│ │ │ │ │ book keeping
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -3776,17 +3776,17 @@
│ │ │ │ │ receiving large messages.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** oonn__uunnkknnoowwnn__mmeessssaaggee(()) **********
│ │ │ │ │ virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │ span //**bbooddyy**//);
│ │ │ │ │ this is not called for web seeds
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) **********
│ │ │ │ │ -virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ +********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ +virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ called when a piece that this peer participated in either fails or passes the
│ │ │ │ │ hash_check
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttiicckk(()) **********
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ called approximately once every second
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -3828,63 +3828,63 @@
│ │ │ │ │ {
│ │ │ │ │ explicit ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (std::weak_ptr impl);
│ │ │ │ │ connection_type ttyyppee () const;
│ │ │ │ │ void aadddd__eexxtteennssiioonn (std::shared_ptr);
│ │ │ │ │ peer_plugin const* ffiinndd__pplluuggiinn (string_view type) const;
│ │ │ │ │ bool iiss__sseeeedd () const;
│ │ │ │ │ bool uuppllooaadd__oonnllyy () const;
│ │ │ │ │ - peer_id const& ppiidd () const;
│ │ │ │ │ bool hhaass__ppiieeccee (piece_index_t i) const;
│ │ │ │ │ + peer_id const& ppiidd () const;
│ │ │ │ │ bool iiss__iinntteerreessttiinngg () const;
│ │ │ │ │ bool iiss__cchhookkeedd () const;
│ │ │ │ │ bool iiss__ppeeeerr__iinntteerreesstteedd () const;
│ │ │ │ │ bool hhaass__ppeeeerr__cchhookkeedd () const;
│ │ │ │ │ void mmaayybbee__uunncchhookkee__tthhiiss__ppeeeerr ();
│ │ │ │ │ void cchhookkee__tthhiiss__ppeeeerr ();
│ │ │ │ │ void ggeett__ppeeeerr__iinnffoo (peer_info& p) const;
│ │ │ │ │ torrent_handle aassssoocciiaatteedd__ttoorrrreenntt () const;
│ │ │ │ │ - _t_c_p_:_:_e_n_d_p_o_i_n_t llooccaall__eennddppooiinntt () const;
│ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t const& rreemmoottee () const;
│ │ │ │ │ - void ddiissccoonnnneecctt (error_code const& ec, operation_t op
│ │ │ │ │ - , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ │ + _t_c_p_:_:_e_n_d_p_o_i_n_t llooccaall__eennddppooiinntt () const;
│ │ │ │ │ + bool iiss__ccoonnnneeccttiinngg () const;
│ │ │ │ │ bool iiss__ddiissccoonnnneeccttiinngg () const;
│ │ │ │ │ bool iiss__oouuttggooiinngg () const;
│ │ │ │ │ - bool iiss__ccoonnnneeccttiinngg () const;
│ │ │ │ │ - bool iiggnnoorree__uunncchhookkee__sslloottss () const;
│ │ │ │ │ + void ddiissccoonnnneecctt (error_code const& ec, operation_t op
│ │ │ │ │ + , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ │ bool oonn__llooccaall__nneettwwoorrkk () const;
│ │ │ │ │ + bool iiggnnoorree__uunncchhookkee__sslloottss () const;
│ │ │ │ │ bool ffaaiilleedd () const;
│ │ │ │ │ + bool sshhoouulldd__lloogg (peer_log_alert::direction_t direction) const;
│ │ │ │ │ void ppeeeerr__lloogg (peer_log_alert::direction_t direction
│ │ │ │ │ , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT
│ │ │ │ │ (4,5);
│ │ │ │ │ - bool sshhoouulldd__lloogg (peer_log_alert::direction_t direction) const;
│ │ │ │ │ bool ccaann__ddiissccoonnnneecctt (error_code const& ec) const;
│ │ │ │ │ bool hhaass__mmeettaaddaattaa () const;
│ │ │ │ │ bool iinn__hhaannddsshhaakkee () const;
│ │ │ │ │ void sseenndd__bbuuffffeerr (char const* begin, int size);
│ │ │ │ │ time_point ttiimmee__ooff__llaasstt__uunncchhookkee () const;
│ │ │ │ │ std::time_t llaasstt__sseeeenn__ccoommpplleettee () const;
│ │ │ │ │ - bool ooppeerraattoorr==== (peer_connection_handle const& o) const;
│ │ │ │ │ - bool ooppeerraattoorr!!== (peer_connection_handle const& o) const;
│ │ │ │ │ bool ooppeerraattoorr<< (peer_connection_handle const& o) const;
│ │ │ │ │ + bool ooppeerraattoorr!!== (peer_connection_handle const& o) const;
│ │ │ │ │ + bool ooppeerraattoorr==== (peer_connection_handle const& o) const;
│ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │ The _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e provides a handle to the internal bittorrent peer
│ │ │ │ │ connection object to plugins. It's low level and may not be a stable API across
│ │ │ │ │ libtorrent versions.
│ │ │ │ │ struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │ │ {
│ │ │ │ │ explicit bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (peer_connection_handle pc);
│ │ │ │ │ bool ssuuppppoorrtt__eexxtteennssiioonnss () const;
│ │ │ │ │ bool ppaacckkeett__ffiinniisshheedd () const;
│ │ │ │ │ bool ssuuppppoorrttss__eennccrryyppttiioonn () const;
│ │ │ │ │ - void sswwiittcchh__rreeccvv__ccrryyppttoo (std::shared_ptr crypto);
│ │ │ │ │ void sswwiittcchh__sseenndd__ccrryyppttoo (std::shared_ptr crypto);
│ │ │ │ │ + void sswwiittcchh__rreeccvv__ccrryyppttoo (std::shared_ptr crypto);
│ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ccrreeaattee__uutt__ppeexx__pplluuggiinn(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_x_t_e_n_s_i_o_n_s_/_u_t___p_e_x_._h_p_p"
│ │ │ │ │ std::shared_ptr ccrreeaattee__uutt__ppeexx__pplluuggiinn (torrent_handle const&,
│ │ │ │ │ client_data_t);
│ │ │ │ │ @@ -3949,67 +3949,67 @@
│ │ │ │ │ {
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ void rreesseerrvvee (int num_files);
│ │ │ │ │ void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}
│ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ - void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ + void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t
│ │ │ │ │ +file_size
│ │ │ │ │ + , file_flags_t file_flags = {}
│ │ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ + , char const* root_hash = nullptr);
│ │ │ │ │ + void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ - void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ + void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ - void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t
│ │ │ │ │ -file_size
│ │ │ │ │ - , file_flags_t file_flags = {}
│ │ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ - , char const* root_hash = nullptr);
│ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t piece, std::int64_t offset
│ │ │ │ │ , std::int64_t size) const;
│ │ │ │ │ peer_request mmaapp__ffiillee (file_index_t file, std::int64_t offset, int size)
│ │ │ │ │ const;
│ │ │ │ │ int nnuumm__ffiilleess () const noexcept;
│ │ │ │ │ file_index_t eenndd__ffiillee () const noexcept;
│ │ │ │ │ index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ int nnuumm__ppiieecceess () const;
│ │ │ │ │ void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │ - int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ + int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ int ppiieeccee__ssiizzee22 (piece_index_t index) const;
│ │ │ │ │ int bblloocckkss__iinn__ppiieeccee22 (piece_index_t index) const;
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ - void sseett__nnaammee (std::string const& n);
│ │ │ │ │ std::string const& nnaammee () const;
│ │ │ │ │ + void sseett__nnaammee (std::string const& n);
│ │ │ │ │ void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │ void ccaannoonniiccaalliizzee ();
│ │ │ │ │ - std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ + std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ - bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ - std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ - sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ - char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ - std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ - sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ "") const;
│ │ │ │ │ - int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ + std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ + sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ + std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ + bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ + sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ + char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ + int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const&
│ │ │ │ │ save_path) const;
│ │ │ │ │ void aallll__ppaatthh__hhaasshheess (std::unordered_set& table) const;
│ │ │ │ │ file_flags_t ffiillee__ffllaaggss (file_index_t index) const;
│ │ │ │ │ bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │ @@ -4039,28 +4039,28 @@
│ │ │ │ │ is known up-front.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aadddd__ffiillee(()) aadddd__ffiillee__bboorrrrooww(()) **********
│ │ │ │ │ void aadddd__ffiillee (std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}
│ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ -void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ +void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ │ + , file_flags_t file_flags = {}
│ │ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ + , char const* root_hash = nullptr);
│ │ │ │ │ +void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ -void aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ +void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ -void aadddd__ffiillee (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ │ - , file_flags_t file_flags = {}
│ │ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ - , char const* root_hash = nullptr);
│ │ │ │ │ Adds a file to the file storage. The add_file_borrow version expects that
│ │ │ │ │ filename is the file name (without a path) of the file that's being added. This
│ │ │ │ │ memory is bboorrrroowweedd, i.e. it is the caller's responsibility to make sure it
│ │ │ │ │ stays valid throughout the lifetime of this _f_i_l_e___s_t_o_r_a_g_e object or any copy of
│ │ │ │ │ it. The same thing applies to filehash, which is an optional pointer to a 20
│ │ │ │ │ byte binary SHA-1 hash of the file.
│ │ │ │ │ if filename is empty, the filename from path is used and not borrowed.
│ │ │ │ │ @@ -4150,17 +4150,17 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__rraannggee(()) **********
│ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │ returns an implementation-defined type that can be used as the container in a
│ │ │ │ │ range-for loop. Where the values are the indices of all pieces in the
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__lleennggtthh(()) sseett__ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ -int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +********** sseett__ppiieeccee__lleennggtthh(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ +int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ set and get the size of each piece in this torrent. It must be a power of two
│ │ │ │ │ and at least 16 kiB.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ returns the piece size of index. This will be the same as _p_i_e_c_e___l_e_n_g_t_h_(_),
│ │ │ │ │ except for the last piece, which may be shorter.
│ │ │ │ │ @@ -4178,40 +4178,40 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bblloocckkss__ppeerr__ppiieeccee(()) **********
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ returns the number of blocks there are in the typical piece. There may be fewer
│ │ │ │ │ in the last piece)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__nnaammee(()) nnaammee(()) **********
│ │ │ │ │ -void sseett__nnaammee (std::string const& n);
│ │ │ │ │ std::string const& nnaammee () const;
│ │ │ │ │ +void sseett__nnaammee (std::string const& n);
│ │ │ │ │ set and get the name of this torrent. For multi-file torrents, this is also the
│ │ │ │ │ name of the root directory all the files are stored in.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sswwaapp(()) **********
│ │ │ │ │ void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │ swap all content of tthhiiss with ttii.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ccaannoonniiccaalliizzee(()) **********
│ │ │ │ │ void ccaannoonniiccaalliizzee ();
│ │ │ │ │ arrange files and padding to match the canonical form required by BEP 52
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__ooffffsseett(()) mmttiimmee(()) hhaasshh(()) ppaadd__ffiillee__aatt(()) ssyymmlliinnkk(()) ffiillee__ppaatthh(())
│ │ │ │ │ -ffiillee__ssiizzee(()) rroooott__ppttrr(()) rroooott(()) ffiillee__nnaammee(()) **********
│ │ │ │ │ -std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ +********** ffiillee__nnaammee(()) hhaasshh(()) rroooott__ppttrr(()) ffiillee__ppaatthh(()) ffiillee__ooffffsseett(()) mmttiimmee(())
│ │ │ │ │ +ppaadd__ffiillee__aatt(()) rroooott(()) ffiillee__ssiizzee(()) ssyymmlliinnkk(()) **********
│ │ │ │ │ string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ -bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ -std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ -sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ -std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ -sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ const;
│ │ │ │ │ +std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ +std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ +bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ +sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ These functions are used to query attributes of files at a given index.
│ │ │ │ │ The hash() is a SHA-1 hash of the file, or 0 if none was provided in the
│ │ │ │ │ torrent file. This can potentially be used to join a bittorrent network with
│ │ │ │ │ other file sharing networks.
│ │ │ │ │ root() returns the SHA-256 merkle tree root of the specified file, in case this
│ │ │ │ │ is a v2 torrent. Otherwise returns zeros. root_ptr() returns a pointer to the
│ │ │ │ │ SHA-256 merkle tree root hash for the specified file. The pointer points into
│ │ │ │ │ @@ -4225,23 +4225,23 @@
│ │ │ │ │ pad_file_at() returns true if the file at the given index is a pad-file.
│ │ │ │ │ file_name() returns jjuusstt the name of the file, whereas file_path() returns the
│ │ │ │ │ path (inside the torrent file) with the filename appended.
│ │ │ │ │ file_offset() returns the byte offset within the torrent file where this file
│ │ │ │ │ starts. It can be used to map the file to a piece index (given the piece size).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__nnuumm__ppiieecceess(()) ffiillee__nnuumm__bblloocckkss(()) ffiillee__ppiieeccee__rraannggee(()) **********
│ │ │ │ │ -int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ +int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ Returns the number of pieces or blocks the file atindexspans, under the
│ │ │ │ │ assumption that the file is aligned to the start of a piece. This is only
│ │ │ │ │ meaningful for v2 torrents, where files are guaranteed such alignment. These
│ │ │ │ │ numbers are used to size and navigate the merkle hash tree for each file.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) ffiillee__ffiirrsstt__bblloocckk__nnooddee(()) **********
│ │ │ │ │ +********** ffiillee__ffiirrsstt__bblloocckk__nnooddee(()) ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) **********
│ │ │ │ │ int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ index of first piece node in the merkle tree
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__ppaatthh__hhaasshh(()) **********
│ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const& save_path)
│ │ │ │ │ const;
│ │ │ │ │ @@ -4408,34 +4408,34 @@
│ │ │ │ │ passed in to libtorrent and returned on demand. It adds type-safety by
│ │ │ │ │ requiring the same type be requested out of it as was assigned to it.
│ │ │ │ │ struct client_data_t
│ │ │ │ │ {
│ │ │ │ │ cclliieenntt__ddaattaa__tt () = default;
│ │ │ │ │ explicit cclliieenntt__ddaattaa__tt (T* v);
│ │ │ │ │ client_data_t& ooppeerraattoorr== (T* v);
│ │ │ │ │ - explicit operator TT () const;
│ │ │ │ │ T* ggeett () const;
│ │ │ │ │ - operator vvooiidd** () const = delete;
│ │ │ │ │ + explicit operator TT () const;
│ │ │ │ │ operator void ccoonnsstt** () const = delete;
│ │ │ │ │ - client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │ client_data_t& ooppeerraattoorr== (void*) = delete;
│ │ │ │ │ + operator vvooiidd** () const = delete;
│ │ │ │ │ + client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │
│ │ │ │ │ template