premiere
/
premiere-libtorrent
2
2
Fork 1
Code Issues Pull Requests Releases Wiki Activity

back-ported add_torrent_params extension from libtorrent_aio

This commit is contained in:
Arvid Norberg 2012-08-31 17:04:02 +00:00
parent 52f679d5dc
commit 9951724f16
5 changed files with 66 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
docs/manual.rst
View File

@ -394,7 +394,9 @@ async_add_torrent() add_torrent()
flag_auto_managed = 0x040.
flag_duplicate_is_error = 0x080,
flag_merge_resume_trackers = 0x100,
flag_update_subscribe = 0x200
flag_update_subscribe = 0x200,
flag_super_seeding = 0x400,
flag_sequential_download = 0x800
};
int version;
@ -417,6 +419,10 @@ async_add_torrent() add_torrent()
std::string uuid;
std::string source_feed_url;
boost::uint64_t flags;
int max_uploads;
int max_connections;
int upload_limit;
int download_limit;
};
torrent_handle add_torrent(add_torrent_params const& params);
@ -533,7 +539,9 @@ and how it's added. These are the flags::
flag_auto_managed = 0x040.
flag_duplicate_is_error = 0x080,
flag_merge_resume_trackers = 0x100,
flag_update_subscribe = 0x200
flag_update_subscribe = 0x200,
flag_super_seeding = 0x400,
flag_sequential_download = 0x800
}
``flag_apply_ip_filter`` determines if the IP filter should apply to this torrent or not. By
@ -605,6 +613,20 @@ priorities for torrents in share mode, it will make it not work.
The share mode has one setting, the share ratio target, see ``session_settings::share_mode_target``
for more info.
``flag_super_seeding`` sets the torrent into super seeding mode. If the torrent
is not a seed, this flag has no effect. It has the same effect as calling
``torrent_handle::super_seeding(true)`` on the torrent handle immediately
after adding it.
``flag_sequential_download`` sets the sequential download state for the torrent.
It has the same effect as calling ``torrent_handle::sequential_download(true)``
on the torrent handle immediately after adding it.
``max_uploads``, ``max_connections``, ``upload_limit``, ``download_limit`` correspond
to the ``set_max_uploads()``, ``set_max_connections()``, ``set_upload_limit()`` and
``set_download_limit()`` functions on torrent_handle_. These values let you initialize
these settings when the torrent is added, instead of calling these functions immediately
following adding it.
remove_torrent()
----------------

13
include/libtorrent/add_torrent_params.hpp
View File

@ -71,6 +71,10 @@ namespace libtorrent
#else
, flags(default_flags)
#endif
, max_uploads(-1)
, max_connections(-1)
, upload_limit(-1)
, download_limit(-1)
{
}
@ -105,6 +109,8 @@ namespace libtorrent
flag_duplicate_is_error = 0x080,
flag_merge_resume_trackers = 0x100,
flag_update_subscribe = 0x200,
flag_super_seeding = 0x400,
flag_sequential_download = 0x800,
default_flags = flag_update_subscribe | flag_auto_managed | flag_paused | flag_apply_ip_filter
#ifndef TORRENT_NO_DEPRECATE
@ -144,6 +150,13 @@ namespace libtorrent
bool duplicate_is_error;
bool merge_resume_trackers;
#endif
// -1 means unlimited on these settings
// just like their counterpart functions
// on torrent_handle
int max_uploads;
int max_connections;
int upload_limit;
int download_limit;
};
}

8
include/libtorrent/torrent.hpp
View File

@ -770,14 +770,14 @@ namespace libtorrent
void set_peer_upload_limit(tcp::endpoint ip, int limit);
void set_peer_download_limit(tcp::endpoint ip, int limit);
void set_upload_limit(int limit);
void set_upload_limit(int limit, bool state_update = true);
int upload_limit() const;
void set_download_limit(int limit);
void set_download_limit(int limit, bool state_update = true);
int download_limit() const;
void set_max_uploads(int limit);
void set_max_uploads(int limit, bool state_update = true);
int max_uploads() const { return m_max_uploads; }
void set_max_connections(int limit);
void set_max_connections(int limit, bool state_update = true);
int max_connections() const { return m_max_connections; }
void move_storage(std::string const& save_path);

32
src/torrent.cpp
View File

@ -562,6 +562,17 @@ namespace libtorrent
#endif
INVARIANT_CHECK;
if (p.flags & add_torrent_params::flag_sequential_download)
m_sequential_download = true;
if (p.flags & add_torrent_params::flag_super_seeding)
m_super_seeding = true;
set_max_uploads(p.max_uploads, false);
set_max_connections(p.max_connections, false);
set_upload_limit(p.upload_limit, false);
set_download_limit(p.download_limit, false);
if (!m_name && !m_url.empty()) m_name.reset(new std::string(m_url));
#ifndef TORRENT_NO_DEPRECATE
@ -3545,9 +3556,6 @@ namespace libtorrent
{
if (on == m_super_seeding) return;
// don't turn on super seeding if we're not a seed
TORRENT_ASSERT(!on || is_seed() || !m_files_checked);
if (on && !is_seed() && m_files_checked) return;
m_super_seeding = on;
if (m_super_seeding) return;
@ -6668,21 +6676,21 @@ namespace libtorrent
m_ses.m_auto_manage_time_scaler = 2;
}
void torrent::set_max_uploads(int limit)
void torrent::set_max_uploads(int limit, bool state_update)
{
TORRENT_ASSERT(m_ses.is_network_thread());
TORRENT_ASSERT(limit >= -1);
if (limit <= 0) limit = (1<<24)-1;
if (m_max_uploads != limit) state_updated();
if (m_max_uploads != limit && state_update) state_updated();
m_max_uploads = limit;
}
void torrent::set_max_connections(int limit)
void torrent::set_max_connections(int limit, bool state_update)
{
TORRENT_ASSERT(m_ses.is_network_thread());
TORRENT_ASSERT(limit >= -1);
if (limit <= 0) limit = (1<<24)-1;
if (m_max_connections != limit) state_updated();
if (m_max_connections != limit && state_update) state_updated();
m_max_connections = limit;
if (num_peers() > int(m_max_connections))
@ -6730,12 +6738,13 @@ namespace libtorrent
(*i)->set_download_limit(limit);
}
void torrent::set_upload_limit(int limit)
void torrent::set_upload_limit(int limit, bool state_update)
{
TORRENT_ASSERT(m_ses.is_network_thread());
TORRENT_ASSERT(limit >= -1);
if (limit <= 0) limit = 0;
if (m_bandwidth_channel[peer_connection::upload_channel].throttle() != limit)
if (m_bandwidth_channel[peer_connection::upload_channel].throttle() != limit
&& state_update)
state_updated();
m_bandwidth_channel[peer_connection::upload_channel].throttle(limit);
}
@ -6748,12 +6757,13 @@ namespace libtorrent
return limit;
}
void torrent::set_download_limit(int limit)
void torrent::set_download_limit(int limit, bool state_update)
{
TORRENT_ASSERT(m_ses.is_network_thread());
TORRENT_ASSERT(limit >= -1);
if (limit <= 0) limit = 0;
if (m_bandwidth_channel[peer_connection::download_channel].throttle() != limit)
if (m_bandwidth_channel[peer_connection::download_channel].throttle() != limit
&& state_update)
state_updated();
m_bandwidth_channel[peer_connection::download_channel].throttle(limit);
}

8
src/torrent_handle.cpp
View File

@ -293,7 +293,7 @@ namespace libtorrent
{
INVARIANT_CHECK;
TORRENT_ASSERT(max_uploads >= 2 || max_uploads == -1);
TORRENT_ASYNC_CALL1(set_max_uploads, max_uploads);
TORRENT_ASYNC_CALL2(set_max_uploads, max_uploads, true);
}
void torrent_handle::use_interface(const char* net_interface) const
@ -313,14 +313,14 @@ namespace libtorrent
{
INVARIANT_CHECK;
TORRENT_ASSERT(max_connections >= 2 || max_connections == -1);
TORRENT_ASYNC_CALL1(set_max_connections, max_connections);
TORRENT_ASYNC_CALL2(set_max_connections, max_connections, true);
}
void torrent_handle::set_upload_limit(int limit) const
{
INVARIANT_CHECK;
TORRENT_ASSERT(limit >= -1);
TORRENT_ASYNC_CALL1(set_upload_limit, limit);
TORRENT_ASYNC_CALL2(set_upload_limit, limit, true);
}
int torrent_handle::upload_limit() const
@ -334,7 +334,7 @@ namespace libtorrent
{
INVARIANT_CHECK;
TORRENT_ASSERT(limit >= -1);
TORRENT_ASYNC_CALL1(set_download_limit, limit);
TORRENT_ASYNC_CALL2(set_download_limit, limit, true);
}
int torrent_handle::download_limit() const