Transmission/transmission
1
0
Fork 0
mirror of https://github.com/transmission/transmission.git synced 2026-05-08 09:39:08 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor: remove tr_isDirection() (#8213)

Browse Source
This commit is contained in:
Yat Ho
2026-01-27 00:00:02 +08:00
committed by GitHub
parent dda5dc7ec3
commit 2362afd113
25 changed files with 237 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files
daemon/daemon.cc
+2 -2
View File
@@ -436,8 +436,8 @@ bool tr_daemon::reopen_log_file(char const* filename)
void tr_daemon::report_status()
{
double const up = tr_sessionGetRawSpeed_KBps(my_session_, TR_UP);
double const dn = tr_sessionGetRawSpeed_KBps(my_session_, TR_DOWN);
auto const up = tr_sessionGetRawSpeed_KBps(my_session_, tr_direction::Up);
auto const dn = tr_sessionGetRawSpeed_KBps(my_session_, tr_direction::Down);
if (up > 0 || dn > 0)
{
gtk/Application.cc
+7 -7
View File
@@ -1172,19 +1172,19 @@ void Application::Impl::on_prefs_changed(tr_quark const key)
break;
case TR_KEY_speed_limit_down_enabled:
tr_sessionLimitSpeed(tr, TR_DOWN, gtr_pref_flag_get(key));
tr_sessionLimitSpeed(tr, tr_direction::Down, gtr_pref_flag_get(key));
break;
case TR_KEY_speed_limit_down:
tr_sessionSetSpeedLimit_KBps(tr, TR_DOWN, gtr_pref_int_get(key));
tr_sessionSetSpeedLimit_KBps(tr, tr_direction::Down, gtr_pref_int_get(key));
break;
case TR_KEY_speed_limit_up_enabled:
tr_sessionLimitSpeed(tr, TR_UP, gtr_pref_flag_get(key));
tr_sessionLimitSpeed(tr, tr_direction::Up, gtr_pref_flag_get(key));
break;
case TR_KEY_speed_limit_up:
tr_sessionSetSpeedLimit_KBps(tr, TR_UP, gtr_pref_int_get(key));
tr_sessionSetSpeedLimit_KBps(tr, tr_direction::Up, gtr_pref_int_get(key));
break;
case TR_KEY_ratio_limit_enabled:
@@ -1216,7 +1216,7 @@ void Application::Impl::on_prefs_changed(tr_quark const key)
break;
case TR_KEY_download_queue_size:
tr_sessionSetQueueSize(tr, TR_DOWN, gtr_pref_int_get(key));
tr_sessionSetQueueSize(tr, tr_direction::Down, gtr_pref_int_get(key));
break;
case TR_KEY_queue_stalled_minutes:
@@ -1264,11 +1264,11 @@ void Application::Impl::on_prefs_changed(tr_quark const key)
break;
case TR_KEY_alt_speed_up:
tr_sessionSetAltSpeed_KBps(tr, TR_UP, gtr_pref_int_get(key));
tr_sessionSetAltSpeed_KBps(tr, tr_direction::Up, gtr_pref_int_get(key));
break;
case TR_KEY_alt_speed_down:
tr_sessionSetAltSpeed_KBps(tr, TR_DOWN, gtr_pref_int_get(key));
tr_sessionSetAltSpeed_KBps(tr, tr_direction::Down, gtr_pref_int_get(key));
break;
case TR_KEY_alt_speed_enabled:
gtk/DetailsDialog.cc
+12 -12
View File
@@ -294,11 +294,11 @@ void DetailsDialog::Impl::refreshOptions(std::vector<tr_torrent*> const& torrent
/* down_limited_check */
if (!torrents.empty())
{
bool const baseline = tr_torrentUsesSpeedLimit(torrents.front(), TR_DOWN);
bool const is_uniform = std::all_of(
auto const baseline = tr_torrentUsesSpeedLimit(torrents.front(), tr_direction::Down);
auto const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentUsesSpeedLimit(torrent, TR_DOWN); });
[baseline](auto const* torrent) { return baseline == tr_torrentUsesSpeedLimit(torrent, tr_direction::Down); });
if (is_uniform)
{
@@ -309,11 +309,11 @@ void DetailsDialog::Impl::refreshOptions(std::vector<tr_torrent*> const& torrent
/* down_limit_spin */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetSpeedLimit_KBps(torrents.front(), TR_DOWN);
bool const is_uniform = std::all_of(
auto const baseline = tr_torrentGetSpeedLimit_KBps(torrents.front(), tr_direction::Down);
auto const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentGetSpeedLimit_KBps(torrent, TR_DOWN); });
[baseline](auto const* torrent) { return baseline == tr_torrentGetSpeedLimit_KBps(torrent, tr_direction::Down); });
if (is_uniform)
{
@@ -324,11 +324,11 @@ void DetailsDialog::Impl::refreshOptions(std::vector<tr_torrent*> const& torrent
/* up_limited_check */
if (!torrents.empty())
{
bool const baseline = tr_torrentUsesSpeedLimit(torrents.front(), TR_UP);
bool const is_uniform = std::all_of(
auto const baseline = tr_torrentUsesSpeedLimit(torrents.front(), tr_direction::Up);
auto const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentUsesSpeedLimit(torrent, TR_UP); });
[baseline](auto const* torrent) { return baseline == tr_torrentUsesSpeedLimit(torrent, tr_direction::Up); });
if (is_uniform)
{
@@ -339,11 +339,11 @@ void DetailsDialog::Impl::refreshOptions(std::vector<tr_torrent*> const& torrent
/* up_limit_sping */
if (!torrents.empty())
{
auto const baseline = tr_torrentGetSpeedLimit_KBps(torrents.front(), TR_UP);
bool const is_uniform = std::all_of(
auto const baseline = tr_torrentGetSpeedLimit_KBps(torrents.front(), tr_direction::Up);
auto const is_uniform = std::all_of(
torrents.begin(),
torrents.end(),
[baseline](auto const* torrent) { return baseline == tr_torrentGetSpeedLimit_KBps(torrent, TR_UP); });
[baseline](auto const* torrent) { return baseline == tr_torrentGetSpeedLimit_KBps(torrent, tr_direction::Up); });
if (is_uniform)
{
gtk/MainWindow.cc
+9 -9
View File
@@ -409,24 +409,24 @@ void MainWindow::Impl::onAltSpeedToggledIdle()
void MainWindow::Impl::onSpeedToggled(std::string const& action_name, tr_direction dir, bool enabled)
{
options_actions_->change_action_state(action_name, VariantInt::create(enabled ? 1 : 0));
core_->set_pref(dir == TR_UP ? TR_KEY_speed_limit_up_enabled : TR_KEY_speed_limit_down_enabled, enabled);
core_->set_pref(dir == tr_direction::Up ? TR_KEY_speed_limit_up_enabled : TR_KEY_speed_limit_down_enabled, enabled);
}
void MainWindow::Impl::onSpeedSet(tr_direction dir, int KBps)
{
core_->set_pref(dir == TR_UP ? TR_KEY_speed_limit_up : TR_KEY_speed_limit_down, KBps);
core_->set_pref(dir == TR_UP ? TR_KEY_speed_limit_up_enabled : TR_KEY_speed_limit_down_enabled, true);
core_->set_pref(dir == tr_direction::Up ? TR_KEY_speed_limit_up : TR_KEY_speed_limit_down, KBps);
core_->set_pref(dir == tr_direction::Up ? TR_KEY_speed_limit_up_enabled : TR_KEY_speed_limit_down_enabled, true);
}
Glib::RefPtr<Gio::MenuModel> MainWindow::Impl::createSpeedMenu(
Glib::RefPtr<Gio::SimpleActionGroup> const& actions,
tr_direction dir)
{
auto& info = speed_menu_info_.at(dir);
auto& info = speed_menu_info_.at(static_cast<uint8_t>(dir));
auto m = Gio::Menu::create();
auto const action_name = fmt::format("speed-limit-{}", dir == TR_UP ? "up" : "down");
auto const action_name = fmt::format("speed-limit-{}", dir == tr_direction::Up ? "up" : "down");
auto const full_action_name = fmt::format("{}.{}", OptionsMenuActionGroupName, action_name);
info.action = actions->add_action_radio_integer(
action_name,
@@ -537,8 +537,8 @@ Glib::RefPtr<Gio::MenuModel> MainWindow::Impl::createOptionsMenu()
auto actions = Gio::SimpleActionGroup::create();
auto section = Gio::Menu::create();
section->append_submenu(_("Limit Download Speed"), createSpeedMenu(actions, TR_DOWN));
section->append_submenu(_("Limit Upload Speed"), createSpeedMenu(actions, TR_UP));
section->append_submenu(_("Limit Download Speed"), createSpeedMenu(actions, tr_direction::Down));
section->append_submenu(_("Limit Upload Speed"), createSpeedMenu(actions, tr_direction::Up));
top->append_section(section);
section = Gio::Menu::create();
@@ -570,12 +570,12 @@ void MainWindow::Impl::onOptionsClicked()
};
update_menu(
speed_menu_info_[TR_DOWN],
speed_menu_info_[static_cast<uint8_t>(tr_direction::Down)],
Speed{ gtr_pref_int_get(TR_KEY_speed_limit_down), Speed::Units::KByps }.to_string(),
TR_KEY_speed_limit_down_enabled);
update_menu(
speed_menu_info_[TR_UP],
speed_menu_info_[static_cast<uint8_t>(tr_direction::Up)],
Speed{ gtr_pref_int_get(TR_KEY_speed_limit_up), Speed::Units::KByps }.to_string(),
TR_KEY_speed_limit_up_enabled);
gtk/SystemTrayIcon.cc
+6 -2
View File
@@ -205,6 +205,10 @@ std::string SystemTrayIcon::Impl::make_tooltip_text() const
auto const* const session = core_->get_session();
return fmt::format(
fmt::runtime(_("{upload_speed} ▲ {download_speed} ▼")),
fmt::arg("upload_speed", Speed{ tr_sessionGetRawSpeed_KBps(session, TR_UP), Speed::Units::KByps }.to_string()),
fmt::arg("download_speed", Speed{ tr_sessionGetRawSpeed_KBps(session, TR_DOWN), Speed::Units::KByps }.to_string()));
fmt::arg(
"upload_speed",
Speed{ tr_sessionGetRawSpeed_KBps(session, tr_direction::Up), Speed::Units::KByps }.to_string()),
fmt::arg(
"download_speed",
Speed{ tr_sessionGetRawSpeed_KBps(session, tr_direction::Down), Speed::Units::KByps }.to_string()));
}
libtransmission/announcer-http.cc
+3 -3
View File
@@ -52,7 +52,7 @@ void verboseLog(std::string_view description, tr_direction direction, std::strin
return;
}
auto const direction_sv = direction == TR_DOWN ? "<< "sv : ">> "sv;
auto const direction_sv = direction == tr_direction::Down ? "<< "sv : ">> "sv;
auto& out = std::cerr;
out << description << '\n' << "[raw]"sv << direction_sv;
for (unsigned char const ch : message)
@@ -322,7 +322,7 @@ void tr_tracker_http_announce(
void tr_announcerParseHttpAnnounceResponse(tr_announce_response& response, std::string_view benc, std::string_view log_name)
{
verboseLog("Announce response:", TR_DOWN, benc);
verboseLog("Announce response:", tr_direction::Down, benc);
struct AnnounceHandler final : public transmission::benc::BasicHandler<MaxBencDepth>
{
@@ -563,7 +563,7 @@ void tr_tracker_http_scrape(tr_session const* session, tr_scrape_request const&
void tr_announcerParseHttpScrapeResponse(tr_scrape_response& response, std::string_view benc, std::string_view log_name)
{
verboseLog("Scrape response:", TR_DOWN, benc);
verboseLog("Scrape response:", tr_direction::Down, benc);
struct ScrapeHandler final : public transmission::benc::BasicHandler<MaxBencDepth>
{
libtransmission/bandwidth.cc
+21 -22
View File
@@ -151,9 +151,9 @@ void tr_bandwidth::allocate_bandwidth(
auto const priority = std::min(parent_priority, priority_);
// set the available bandwidth
for (auto const dir : { TR_UP, TR_DOWN })
for (auto const dir : { tr_direction::Up, tr_direction::Down })
{
if (auto& bandwidth = band_[dir]; bandwidth.is_limited_)
if (auto& bandwidth = band_[static_cast<uint8_t>(dir)]; bandwidth.is_limited_)
{
auto const next_pulse_speed = bandwidth.desired_speed_;
bandwidth.bytes_left_ = next_pulse_speed.base_quantity() * period_msec / 1000U;
@@ -179,7 +179,8 @@ void tr_bandwidth::phase_one(std::vector<tr_peerIo*>& peers, tr_direction dir)
{
// First phase of IO. Tries to distribute bandwidth fairly to keep faster
// peers from starving the others.
tr_logAddTrace(fmt::format("{} peers to go round-robin for {}", peers.size(), dir == TR_UP ? "upload" : "download"));
tr_logAddTrace(
fmt::format("{} peers to go round-robin for {}", peers.size(), dir == tr_direction::Up ? "upload" : "download"));
// Shuffle the peers so they all have equal chance to be first in line.
static thread_local auto urbg = tr_urbg<size_t>{};
@@ -258,8 +259,8 @@ void tr_bandwidth::allocate(uint64_t period_msec)
// and/or peers that can use it
for (auto& peers : peer_arrays)
{
phase_one(peers, TR_UP);
phase_one(peers, TR_DOWN);
phase_one(peers, tr_direction::Up);
phase_one(peers, tr_direction::Down);
}
// Second phase of IO. To help us scale in high bandwidth situations,
@@ -268,8 +269,8 @@ void tr_bandwidth::allocate(uint64_t period_msec)
// or (2) the next tr_bandwidth::allocate () call, when we start over again.
for (auto const& io : refs)
{
io->set_enabled(TR_UP, io->has_bandwidth_left(TR_UP));
io->set_enabled(TR_DOWN, io->has_bandwidth_left(TR_DOWN));
io->set_enabled(tr_direction::Up, io->has_bandwidth_left(tr_direction::Up));
io->set_enabled(tr_direction::Down, io->has_bandwidth_left(tr_direction::Down));
}
}
@@ -277,14 +278,14 @@ void tr_bandwidth::allocate(uint64_t period_msec)
size_t tr_bandwidth::clamp(tr_direction const dir, size_t byte_count) const noexcept
{
TR_ASSERT(tr_isDirection(dir));
auto const idx = static_cast<uint8_t>(dir);
if (band_[dir].is_limited_)
if (band_[idx].is_limited_)
{
byte_count = std::min(byte_count, band_[dir].bytes_left_);
byte_count = std::min(byte_count, band_[idx].bytes_left_);
}
if (parent_ != nullptr && band_[dir].honor_parent_limits_ && byte_count > 0U)
if (parent_ != nullptr && band_[idx].honor_parent_limits_ && byte_count > 0U)
{
byte_count = parent_->clamp(dir, byte_count);
}
@@ -294,9 +295,7 @@ size_t tr_bandwidth::clamp(tr_direction const dir, size_t byte_count) const noex
void tr_bandwidth::notify_bandwidth_consumed(tr_direction dir, size_t byte_count, bool is_piece_data, uint64_t now)
{
TR_ASSERT(tr_isDirection(dir));
auto& band = band_[dir];
auto& band = band_[static_cast<uint8_t>(dir)];
if (is_piece_data)
{
@@ -323,17 +322,17 @@ void tr_bandwidth::notify_bandwidth_consumed(tr_direction dir, size_t byte_count
tr_bandwidth_limits tr_bandwidth::get_limits() const
{
auto limits = tr_bandwidth_limits{};
limits.up_limit = get_desired_speed(TR_UP);
limits.down_limit = get_desired_speed(TR_DOWN);
limits.up_limited = is_limited(TR_UP);
limits.down_limited = is_limited(TR_DOWN);
limits.up_limit = get_desired_speed(tr_direction::Up);
limits.down_limit = get_desired_speed(tr_direction::Down);
limits.up_limited = is_limited(tr_direction::Up);
limits.down_limited = is_limited(tr_direction::Down);
return limits;
}
void tr_bandwidth::set_limits(tr_bandwidth_limits const& limits)
{
set_desired_speed(TR_UP, limits.up_limit);
set_desired_speed(TR_DOWN, limits.down_limit);
set_limited(TR_UP, limits.up_limited);
set_limited(TR_DOWN, limits.down_limited);
set_desired_speed(tr_direction::Up, limits.up_limit);
set_desired_speed(tr_direction::Down, limits.down_limit);
set_limited(tr_direction::Up, limits.up_limited);
set_limited(tr_direction::Down, limits.down_limited);
}
libtransmission/bandwidth.h
+8 -12
View File
@@ -141,17 +141,13 @@ public:
/** @brief Get the raw total of bytes read or sent by this bandwidth subtree. */
[[nodiscard]] auto get_raw_speed(uint64_t const now, tr_direction const dir) const
{
TR_ASSERT(tr_isDirection(dir));
return get_speed(band_[dir].raw_, HistoryMSec, now);
return get_speed(band_[static_cast<uint8_t>(dir)].raw_, HistoryMSec, now);
}
/** @brief Get the number of piece data bytes read or sent by this bandwidth subtree. */
[[nodiscard]] auto get_piece_speed(uint64_t const now, tr_direction const dir) const
{
TR_ASSERT(tr_isDirection(dir));
return get_speed(band_[dir].piece_, HistoryMSec, now);
return get_speed(band_[static_cast<uint8_t>(dir)].piece_, HistoryMSec, now);
}
/**
@@ -161,7 +157,7 @@ public:
*/
constexpr bool set_desired_speed(tr_direction dir, Speed desired_speed)
{
auto& value = band_[dir].desired_speed_;
auto& value = band_[static_cast<uint8_t>(dir)].desired_speed_;
auto const did_change = desired_speed != value;
value = desired_speed;
return did_change;
@@ -173,7 +169,7 @@ public:
*/
[[nodiscard]] constexpr auto get_desired_speed(tr_direction dir) const
{
return band_[dir].desired_speed_;
return band_[static_cast<uint8_t>(dir)].desired_speed_;
}
[[nodiscard]] bool is_maxed_out(tr_direction dir, uint64_t now_msec) const noexcept
@@ -193,7 +189,7 @@ public:
*/
constexpr bool set_limited(tr_direction dir, bool is_limited)
{
auto& value = band_[dir].is_limited_;
auto& value = band_[static_cast<uint8_t>(dir)].is_limited_;
auto const did_change = is_limited != value;
value = is_limited;
return did_change;
@@ -204,7 +200,7 @@ public:
*/
[[nodiscard]] constexpr bool is_limited(tr_direction dir) const noexcept
{
return band_[dir].is_limited_;
return band_[static_cast<uint8_t>(dir)].is_limited_;
}
/**
@@ -215,7 +211,7 @@ public:
*/
constexpr bool honor_parent_limits(tr_direction direction, bool is_enabled)
{
auto& value = band_[direction].honor_parent_limits_;
auto& value = band_[static_cast<uint8_t>(direction)].honor_parent_limits_;
auto const did_change = is_enabled != value;
value = is_enabled;
return did_change;
@@ -223,7 +219,7 @@ public:
[[nodiscard]] constexpr bool are_parent_limits_honored(tr_direction direction) const
{
return band_[direction].honor_parent_limits_;
return band_[static_cast<uint8_t>(direction)].honor_parent_limits_;
}
[[nodiscard]] tr_bandwidth_limits get_limits() const;
libtransmission/peer-io.cc
+15 -23
View File
@@ -65,7 +65,7 @@ size_t get_desired_output_buffer_size(tr_peerIo const* io, uint64_t now)
// the .5 is to leave room for protocol messages
static auto constexpr Floor = static_cast<uint64_t>(tr_block_info::BlockSize * 3.5);
auto const current_speed = io->get_piece_speed(now, TR_UP);
auto const current_speed = io->get_piece_speed(now, tr_direction::Up);
return std::max(Floor, current_speed.base_quantity() * PeriodSecs);
}
} // namespace
@@ -212,8 +212,8 @@ void tr_peerIo::close()
void tr_peerIo::clear()
{
clear_callbacks();
set_enabled(TR_UP, false);
set_enabled(TR_DOWN, false);
set_enabled(tr_direction::Up, false);
set_enabled(tr_direction::Down, false);
close();
}
@@ -251,7 +251,7 @@ void tr_peerIo::did_write_wrapper(size_t bytes_transferred)
if (bytes_transferred > 0U)
{
bandwidth().notify_bandwidth_consumed(TR_UP, bytes_transferred, false, now);
bandwidth().notify_bandwidth_consumed(tr_direction::Up, bytes_transferred, false, now);
}
while (bytes_transferred > 0U && !std::empty(outbuf_info_))
@@ -261,7 +261,7 @@ void tr_peerIo::did_write_wrapper(size_t bytes_transferred)
if (is_piece_data)
{
bandwidth().notify_bandwidth_consumed(TR_UP, payload, true, now);
bandwidth().notify_bandwidth_consumed(tr_direction::Up, payload, true, now);
}
if (did_write_ != nullptr)
@@ -280,7 +280,7 @@ void tr_peerIo::did_write_wrapper(size_t bytes_transferred)
size_t tr_peerIo::try_write(size_t max)
{
static auto constexpr Dir = TR_UP;
static auto constexpr Dir = tr_direction::Up;
if (max == 0U)
{
@@ -354,7 +354,7 @@ void tr_peerIo::can_read_wrapper(size_t bytes_transferred)
if (socket_.is_tcp() && bytes_transferred > 0U)
{
bandwidth().notify_bandwidth_consumed(TR_DOWN, bytes_transferred, false, now);
bandwidth().notify_bandwidth_consumed(tr_direction::Down, bytes_transferred, false, now);
}
// In normal conditions, only continue processing if we still have bandwidth
@@ -364,7 +364,8 @@ void tr_peerIo::can_read_wrapper(size_t bytes_transferred)
// than the bandwidth limit allows. To safeguard against that, we keep
// processing if the read buffer is more than twice as large as the target size.
while (!done && !err &&
(socket_.is_tcp() || read_buffer_size() > RcvBuf * 2U || bandwidth().clamp(TR_DOWN, read_buffer_size()) != 0U))
(socket_.is_tcp() || read_buffer_size() > RcvBuf * 2U ||
bandwidth().clamp(tr_direction::Down, read_buffer_size()) != 0U))
{
auto piece = size_t{};
auto const old_size = read_buffer_size();
@@ -373,12 +374,12 @@ void tr_peerIo::can_read_wrapper(size_t bytes_transferred)
if (piece > 0U)
{
bandwidth().notify_bandwidth_consumed(TR_DOWN, piece, true, now);
bandwidth().notify_bandwidth_consumed(tr_direction::Down, piece, true, now);
}
if (socket_.is_utp() && used > 0U)
{
bandwidth().notify_bandwidth_consumed(TR_DOWN, used, false, now);
bandwidth().notify_bandwidth_consumed(tr_direction::Down, used, false, now);
}
switch (read_state)
@@ -404,7 +405,7 @@ void tr_peerIo::can_read_wrapper(size_t bytes_transferred)
size_t tr_peerIo::try_read(size_t max)
{
static auto constexpr Dir = TR_DOWN;
static auto constexpr Dir = tr_direction::Down;
if (max == 0U)
{
@@ -527,9 +528,7 @@ void tr_peerIo::event_disable(short event)
void tr_peerIo::set_enabled(tr_direction dir, bool is_enabled)
{
TR_ASSERT(tr_isDirection(dir));
short const event = dir == TR_UP ? EV_WRITE : EV_READ;
short const event = dir == tr_direction::Up ? EV_WRITE : EV_READ;
if (is_enabled)
{
@@ -541,13 +540,6 @@ void tr_peerIo::set_enabled(tr_direction dir, bool is_enabled)
}
}
size_t tr_peerIo::flush(tr_direction dir, size_t limit)
{
TR_ASSERT(tr_isDirection(dir));
return dir == TR_DOWN ? try_read(limit) : try_write(limit);
}
size_t tr_peerIo::flush_outgoing_protocol_msgs()
{
size_t byte_count = 0U;
@@ -564,7 +556,7 @@ size_t tr_peerIo::flush_outgoing_protocol_msgs()
byte_count += n_bytes;
}
return flush(TR_UP, byte_count);
return flush(tr_direction::Up, byte_count);
}
void tr_peerIo::write_bytes(void const* bytes, size_t n_bytes, bool is_piece_data)
@@ -729,7 +721,7 @@ void tr_peerIo::utp_init([[maybe_unused]] struct_utp_context* ctx)
auto const keep_alive = io->shared_from_this();
io->inbuf_.add(args->buf, args->len);
io->set_enabled(TR_DOWN, true);
io->set_enabled(tr_direction::Down, true);
io->can_read_wrapper(args->len);
// utp_read_drained() notifies libutp that we read a packet from them.
libtransmission/peer-io.h
+4 -1
View File
@@ -161,7 +161,10 @@ public:
size_t flush_outgoing_protocol_msgs();
size_t flush(tr_direction dir, size_t byte_limit);
size_t flush(tr_direction dir, size_t byte_limit)
{
return dir == tr_direction::Down ? try_read(byte_limit) : try_write(byte_limit);
}
///
libtransmission/peer-mgr.cc
+14 -14
View File
@@ -469,7 +469,7 @@ public:
return std::count_if(
std::begin(webseeds),
std::end(webseeds),
[&now](auto const& webseed) { return webseed->get_piece_speed(now, TR_DOWN).base_quantity() != 0U; });
[&now](auto const& webseed) { return webseed->get_piece_speed(now, tr_direction::Down).base_quantity() != 0U; });
}
[[nodiscard]] TR_CONSTEXPR20 auto peerCount() const noexcept
@@ -1762,8 +1762,8 @@ tr_swarm_stats tr_swarmGetStats(tr_swarm const* const swarm)
};
auto& stats = swarm->stats;
stats.active_peer_count[TR_UP] = count_active_peers(TR_UP);
stats.active_peer_count[TR_DOWN] = count_active_peers(TR_DOWN);
stats.active_peer_count[static_cast<uint8_t>(tr_direction::Up)] = count_active_peers(tr_direction::Up);
stats.active_peer_count[static_cast<uint8_t>(tr_direction::Down)] = count_active_peers(tr_direction::Down);
stats.active_webseed_count = swarm->count_active_webseeds(tr_time_msec());
return stats;
}
@@ -1840,15 +1840,15 @@ namespace peer_stat_helpers
stats.progress = peer->percent_done();
stats.isUTP = peer->is_utp_connection();
stats.isEncrypted = peer->is_encrypted();
stats.rateToPeer_KBps = peer->get_piece_speed(now_msec, TR_CLIENT_TO_PEER).count(Speed::Units::KByps);
stats.rateToClient_KBps = peer->get_piece_speed(now_msec, TR_PEER_TO_CLIENT).count(Speed::Units::KByps);
stats.rateToPeer_KBps = peer->get_piece_speed(now_msec, tr_direction::ClientToPeer).count(Speed::Units::KByps);
stats.rateToClient_KBps = peer->get_piece_speed(now_msec, tr_direction::PeerToClient).count(Speed::Units::KByps);
stats.peerIsChoked = peer->peer_is_choked();
stats.peerIsInterested = peer->peer_is_interested();
stats.clientIsChoked = peer->client_is_choked();
stats.clientIsInterested = peer->client_is_interested();
stats.isIncoming = peer->is_incoming_connection();
stats.isDownloadingFrom = peer->is_active(TR_PEER_TO_CLIENT);
stats.isUploadingTo = peer->is_active(TR_CLIENT_TO_PEER);
stats.isDownloadingFrom = peer->is_active(tr_direction::PeerToClient);
stats.isUploadingTo = peer->is_active(tr_direction::ClientToPeer);
stats.isSeed = peer->is_seed();
stats.blocksToPeer = peer->blocks_sent_to_peer.count(now, CancelHistorySec);
@@ -1859,8 +1859,8 @@ namespace peer_stat_helpers
stats.bytes_to_peer = peer->bytes_sent_to_peer.count(now, CancelHistorySec);
stats.bytes_to_client = peer->bytes_sent_to_client.count(now, CancelHistorySec);
stats.activeReqsToPeer = peer->active_req_count(TR_CLIENT_TO_PEER);
stats.activeReqsToClient = peer->active_req_count(TR_PEER_TO_CLIENT);
stats.activeReqsToPeer = peer->active_req_count(tr_direction::ClientToPeer);
stats.activeReqsToClient = peer->active_req_count(tr_direction::PeerToClient);
char* pch = stats.flagStr;
@@ -2063,18 +2063,18 @@ struct ChokeData
{
if (tor->is_done())
{
return peer->get_piece_speed(now, TR_CLIENT_TO_PEER);
return peer->get_piece_speed(now, tr_direction::ClientToPeer);
}
// downloading a private torrent... take upload speed into account
// because there may only be a small window of opportunity to share
if (tor->is_private())
{
return peer->get_piece_speed(now, TR_PEER_TO_CLIENT) + peer->get_piece_speed(now, TR_CLIENT_TO_PEER);
return peer->get_piece_speed(now, tr_direction::PeerToClient) + peer->get_piece_speed(now, tr_direction::ClientToPeer);
}
// downloading a public torrent
return peer->get_piece_speed(now, TR_PEER_TO_CLIENT);
return peer->get_piece_speed(now, tr_direction::PeerToClient);
}
// an optimistically unchoked peer is immune from rechoking
@@ -2091,7 +2091,7 @@ void rechokeUploads(tr_swarm* s, uint64_t const now)
choked.reserve(peer_count);
auto const* const session = s->manager->session;
bool const choke_all = !s->tor->client_can_upload();
bool const is_maxed_out = s->tor->bandwidth().is_maxed_out(TR_UP, now);
bool const is_maxed_out = s->tor->bandwidth().is_maxed_out(tr_direction::Up, now);
/* an optimistic unchoke peer's "optimistic"
* state lasts for N calls to rechokeUploads(). */
@@ -2726,7 +2726,7 @@ void get_peer_candidates(size_t global_peer_limit, tr_torrents& torrents, tr_pee
}
/* if we've already got enough speed in this torrent... */
if (seeding && tor->bandwidth().is_maxed_out(TR_UP, now_msec))
if (seeding && tor->bandwidth().is_maxed_out(tr_direction::Up, now_msec))
{
continue;
}
libtransmission/peer-msgs.cc
+19 -20
View File
@@ -337,8 +337,8 @@ public:
~tr_peerMsgsImpl() override
{
set_active(TR_UP, false);
set_active(TR_DOWN, false);
set_active(tr_direction::Up, false);
set_active(tr_direction::Down, false);
if (io_)
{
@@ -357,10 +357,10 @@ public:
{
switch (dir)
{
case TR_CLIENT_TO_PEER: // requests we sent
case tr_direction::ClientToPeer: // requests we sent
return active_requests.count();
case TR_PEER_TO_CLIENT: // requests they sent
case tr_direction::PeerToClient: // requests they sent
return std::size(peer_requested_);
default:
@@ -438,7 +438,7 @@ public:
}
choke_changed_at_ = now;
update_active(TR_CLIENT_TO_PEER);
update_active(tr_direction::ClientToPeer);
}
}
@@ -458,7 +458,7 @@ public:
{
set_client_interested(interested);
protocol_send_interest(interested);
update_active(TR_PEER_TO_CLIENT);
update_active(tr_direction::PeerToClient);
}
}
@@ -502,24 +502,23 @@ public:
void update_active()
{
update_active(TR_CLIENT_TO_PEER);
update_active(TR_PEER_TO_CLIENT);
update_active(tr_direction::ClientToPeer);
update_active(tr_direction::PeerToClient);
}
void update_active(tr_direction direction)
{
TR_ASSERT(tr_isDirection(direction));
set_active(direction, calculate_active(direction));
}
[[nodiscard]] bool calculate_active(tr_direction direction) const
{
if (direction == TR_CLIENT_TO_PEER)
if (direction == tr_direction::ClientToPeer)
{
return peer_is_interested() && !peer_is_choked();
}
// TR_PEER_TO_CLIENT
// tr_direction::PeerToClient
if (!tor_.has_metainfo())
{
@@ -1484,26 +1483,26 @@ ReadResult tr_peerMsgsImpl::process_peer_message(uint8_t id, MessageReader& payl
request_timeouts_.clear();
}
update_active(TR_PEER_TO_CLIENT);
update_active(tr_direction::PeerToClient);
break;
case BtPeerMsgs::Unchoke:
logtrace(this, "got Unchoke");
set_client_choked(false);
update_active(TR_PEER_TO_CLIENT);
update_active(tr_direction::PeerToClient);
update_desired_request_count();
break;
case BtPeerMsgs::Interested:
logtrace(this, "got Interested");
set_peer_interested(true);
update_active(TR_CLIENT_TO_PEER);
update_active(tr_direction::ClientToPeer);
break;
case BtPeerMsgs::NotInterested:
logtrace(this, "got Not Interested");
set_peer_interested(false);
update_active(TR_CLIENT_TO_PEER);
update_active(tr_direction::ClientToPeer);
break;
case BtPeerMsgs::Have:
@@ -1925,7 +1924,7 @@ void tr_peerMsgsImpl::maybe_send_block_requests()
return;
}
auto const n_active = active_req_count(TR_CLIENT_TO_PEER);
auto const n_active = active_req_count(tr_direction::ClientToPeer);
if (n_active >= desired_request_count_)
{
return;
@@ -2153,16 +2152,16 @@ size_t tr_peerMsgsImpl::max_available_reqs() const
// Get the rate limit we should use.
// TODO: this needs to consider all the other peers as well...
uint64_t const now = tr_time_msec();
auto rate = get_piece_speed(now, TR_PEER_TO_CLIENT);
if (tor_.uses_speed_limit(TR_PEER_TO_CLIENT))
auto rate = get_piece_speed(now, tr_direction::PeerToClient);
if (tor_.uses_speed_limit(tr_direction::PeerToClient))
{
rate = std::min(rate, tor_.speed_limit(TR_PEER_TO_CLIENT));
rate = std::min(rate, tor_.speed_limit(tr_direction::PeerToClient));
}
// honor the session limits, if enabled
if (tor_.uses_session_limits())
{
if (auto const limit = session->active_speed_limit(TR_PEER_TO_CLIENT))
if (auto const limit = session->active_speed_limit(tr_direction::PeerToClient))
{
rate = std::min(rate, *limit);
}
libtransmission/peer-msgs.h
+2 -2
View File
@@ -102,7 +102,7 @@ public:
[[nodiscard]] constexpr auto is_active(tr_direction direction) const noexcept
{
return is_active_[direction];
return is_active_[static_cast<uint8_t>(direction)];
}
[[nodiscard]] constexpr auto is_disconnecting() const noexcept
@@ -157,7 +157,7 @@ protected:
constexpr void set_active(tr_direction direction, bool active) noexcept
{
is_active_[direction] = active;
is_active_[static_cast<uint8_t>(direction)] = active;
}
constexpr void set_user_agent(tr_interned_string val) noexcept
libtransmission/resume.cc
+4 -4
View File
@@ -245,8 +245,8 @@ tr_variant::Map save_single_speed_limit(tr_torrent const* tor, tr_direction dir)
void save_speed_limits(tr_variant::Map& map, tr_torrent const* tor)
{
map.insert_or_assign(TR_KEY_speed_limit_down, save_single_speed_limit(tor, TR_DOWN));
map.insert_or_assign(TR_KEY_speed_limit_up, save_single_speed_limit(tor, TR_UP));
map.insert_or_assign(TR_KEY_speed_limit_down, save_single_speed_limit(tor, tr_direction::Down));
map.insert_or_assign(TR_KEY_speed_limit_up, save_single_speed_limit(tor, tr_direction::Up));
}
void save_ratio_limits(tr_variant::Map& map, tr_torrent const* tor)
@@ -293,13 +293,13 @@ auto load_speed_limits(tr_variant::Map const& map, tr_torrent* tor)
if (auto const* child = map.find_if<tr_variant::Map>(TR_KEY_speed_limit_up))
{
load_single_speed_limit(*child, TR_UP, tor);
load_single_speed_limit(*child, tr_direction::Up, tor);
ret = tr_resume::Speedlimit;
}
if (auto const* child = map.find_if<tr_variant::Map>(TR_KEY_speed_limit_down))
{
load_single_speed_limit(*child, TR_DOWN, tor);
load_single_speed_limit(*child, tr_direction::Down, tor);
ret = tr_resume::Speedlimit;
}
libtransmission/rpcimpl.cc
+33 -33
View File
@@ -807,9 +807,9 @@ namespace make_torrent_field_helpers
case TR_KEY_download_dir:
return tr_variant::unmanaged_string(tor.download_dir().sv());
case TR_KEY_download_limit:
return tr_torrentGetSpeedLimit_KBps(&tor, TR_DOWN);
return tr_torrentGetSpeedLimit_KBps(&tor, tr_direction::Down);
case TR_KEY_download_limited:
return tor.uses_speed_limit(TR_DOWN);
return tor.uses_speed_limit(tr_direction::Down);
case TR_KEY_downloaded_ever:
return st.downloadedEver;
case TR_KEY_edit_date:
@@ -929,9 +929,9 @@ namespace make_torrent_field_helpers
case TR_KEY_trackers:
return make_tracker_vec(tor);
case TR_KEY_upload_limit:
return tr_torrentGetSpeedLimit_KBps(&tor, TR_UP);
return tr_torrentGetSpeedLimit_KBps(&tor, tr_direction::Up);
case TR_KEY_upload_limited:
return tor.uses_speed_limit(TR_UP);
return tor.uses_speed_limit(tr_direction::Up);
case TR_KEY_upload_ratio:
return st.ratio;
case TR_KEY_uploaded_ever:
@@ -1313,7 +1313,7 @@ namespace make_torrent_field_helpers
if (auto const val = args_in.value_if<int64_t>(TR_KEY_download_limit); val)
{
tr_torrentSetSpeedLimit_KBps(tor, TR_DOWN, *val);
tr_torrentSetSpeedLimit_KBps(tor, tr_direction::Down, *val);
}
if (auto const val = args_in.value_if<bool>(TR_KEY_sequential_download); val)
@@ -1328,7 +1328,7 @@ namespace make_torrent_field_helpers
if (auto const val = args_in.value_if<bool>(TR_KEY_download_limited); val)
{
tor->use_speed_limit(TR_DOWN, *val);
tor->use_speed_limit(tr_direction::Down, *val);
}
if (auto const val = args_in.value_if<bool>(TR_KEY_honors_session_limits); val)
@@ -1338,12 +1338,12 @@ namespace make_torrent_field_helpers
if (auto const val = args_in.value_if<int64_t>(TR_KEY_upload_limit); val)
{
tr_torrentSetSpeedLimit_KBps(tor, TR_UP, *val);
tr_torrentSetSpeedLimit_KBps(tor, tr_direction::Up, *val);
}
if (auto const val = args_in.value_if<bool>(TR_KEY_upload_limited); val)
{
tor->use_speed_limit(TR_UP, *val);
tor->use_speed_limit(tr_direction::Up, *val);
}
if (auto const val = args_in.value_if<int64_t>(TR_KEY_seed_idle_limit); val)
@@ -1910,7 +1910,7 @@ void add_strings_from_var(std::set<std::string_view>& strings, tr_variant const&
{
auto const limits = group->get_limits();
auto group_map = tr_variant::Map{ 6U };
group_map.try_emplace(TR_KEY_honors_session_limits, group->are_parent_limits_honored(TR_UP));
group_map.try_emplace(TR_KEY_honors_session_limits, group->are_parent_limits_honored(tr_direction::Up));
group_map.try_emplace(TR_KEY_name, name.sv());
group_map.try_emplace(TR_KEY_speed_limit_down, limits.down_limit.count(Speed::Units::KByps));
group_map.try_emplace(TR_KEY_speed_limit_down_enabled, limits.down_limited);
@@ -1964,8 +1964,8 @@ void add_strings_from_var(std::set<std::string_view>& strings, tr_variant const&
if (auto const val = args_in.value_if<bool>(TR_KEY_honors_session_limits); val)
{
group.honor_parent_limits(TR_UP, *val);
group.honor_parent_limits(TR_DOWN, *val);
group.honor_parent_limits(tr_direction::Up, *val);
group.honor_parent_limits(tr_direction::Down, *val);
}
return { Error::SUCCESS, {} };
@@ -2000,10 +2000,10 @@ void add_strings_from_var(std::set<std::string_view>& strings, tr_variant const&
args_out.try_emplace(TR_KEY_active_torrent_count, n_running);
args_out.try_emplace(TR_KEY_cumulative_stats, make_stats_map(session->stats().cumulative()));
args_out.try_emplace(TR_KEY_current_stats, make_stats_map(session->stats().current()));
args_out.try_emplace(TR_KEY_download_speed, session->piece_speed(TR_DOWN).base_quantity());
args_out.try_emplace(TR_KEY_download_speed, session->piece_speed(tr_direction::Down).base_quantity());
args_out.try_emplace(TR_KEY_paused_torrent_count, total - n_running);
args_out.try_emplace(TR_KEY_torrent_count, total);
args_out.try_emplace(TR_KEY_upload_speed, session->piece_speed(TR_UP).base_quantity());
args_out.try_emplace(TR_KEY_upload_speed, session->piece_speed(tr_direction::Up).base_quantity());
return { JsonRpc::Error::SUCCESS, {} };
}
@@ -2055,12 +2055,12 @@ using SessionAccessors = std::pair<SessionGetter, SessionSetter>;
map.try_emplace(
TR_KEY_alt_speed_down,
[](tr_session const& src) -> tr_variant { return tr_sessionGetAltSpeed_KBps(&src, TR_DOWN); },
[](tr_session const& src) -> tr_variant { return tr_sessionGetAltSpeed_KBps(&src, tr_direction::Down); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<int64_t>())
{
tr_sessionSetAltSpeed_KBps(&tgt, TR_DOWN, *val);
tr_sessionSetAltSpeed_KBps(&tgt, tr_direction::Down, *val);
}
});
@@ -2121,12 +2121,12 @@ using SessionAccessors = std::pair<SessionGetter, SessionSetter>;
map.try_emplace(
TR_KEY_alt_speed_up,
[](tr_session const& src) -> tr_variant { return tr_sessionGetAltSpeed_KBps(&src, TR_UP); },
[](tr_session const& src) -> tr_variant { return tr_sessionGetAltSpeed_KBps(&src, tr_direction::Up); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<int64_t>())
{
tr_sessionSetAltSpeed_KBps(&tgt, TR_UP, *val);
tr_sessionSetAltSpeed_KBps(&tgt, tr_direction::Up, *val);
}
});
@@ -2240,23 +2240,23 @@ using SessionAccessors = std::pair<SessionGetter, SessionSetter>;
map.try_emplace(
TR_KEY_download_queue_enabled,
[](tr_session const& src) -> tr_variant { return src.queueEnabled(TR_DOWN); },
[](tr_session const& src) -> tr_variant { return src.queueEnabled(tr_direction::Down); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<bool>())
{
tr_sessionSetQueueEnabled(&tgt, TR_DOWN, *val);
tr_sessionSetQueueEnabled(&tgt, tr_direction::Down, *val);
}
});
map.try_emplace(
TR_KEY_download_queue_size,
[](tr_session const& src) -> tr_variant { return src.queueSize(TR_DOWN); },
[](tr_session const& src) -> tr_variant { return src.queueSize(tr_direction::Down); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<int64_t>())
{
tr_sessionSetQueueSize(&tgt, TR_DOWN, *val);
tr_sessionSetQueueSize(&tgt, tr_direction::Down, *val);
}
});
@@ -2487,23 +2487,23 @@ using SessionAccessors = std::pair<SessionGetter, SessionSetter>;
map.try_emplace(
TR_KEY_seed_queue_enabled,
[](tr_session const& src) -> tr_variant { return src.queueEnabled(TR_UP); },
[](tr_session const& src) -> tr_variant { return src.queueEnabled(tr_direction::Up); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<bool>())
{
tr_sessionSetQueueEnabled(&tgt, TR_UP, *val);
tr_sessionSetQueueEnabled(&tgt, tr_direction::Up, *val);
}
});
map.try_emplace(
TR_KEY_seed_queue_size,
[](tr_session const& src) -> tr_variant { return src.queueSize(TR_UP); },
[](tr_session const& src) -> tr_variant { return src.queueSize(tr_direction::Up); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<int64_t>())
{
tr_sessionSetQueueSize(&tgt, TR_UP, *val);
tr_sessionSetQueueSize(&tgt, tr_direction::Up, *val);
}
});
@@ -2522,45 +2522,45 @@ using SessionAccessors = std::pair<SessionGetter, SessionSetter>;
map.try_emplace(
TR_KEY_speed_limit_down,
[](tr_session const& src) -> tr_variant { return src.speed_limit(TR_DOWN).count(Speed::Units::KByps); },
[](tr_session const& src) -> tr_variant { return src.speed_limit(tr_direction::Down).count(Speed::Units::KByps); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<int64_t>())
{
tgt.set_speed_limit(TR_DOWN, Speed{ *val, Speed::Units::KByps });
tgt.set_speed_limit(tr_direction::Down, Speed{ *val, Speed::Units::KByps });
}
});
map.try_emplace(
TR_KEY_speed_limit_down_enabled,
[](tr_session const& src) -> tr_variant { return src.is_speed_limited(TR_DOWN); },
[](tr_session const& src) -> tr_variant { return src.is_speed_limited(tr_direction::Down); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<bool>())
{
tr_sessionLimitSpeed(&tgt, TR_DOWN, *val);
tr_sessionLimitSpeed(&tgt, tr_direction::Down, *val);
}
});
map.try_emplace(
TR_KEY_speed_limit_up,
[](tr_session const& src) -> tr_variant { return src.speed_limit(TR_UP).count(Speed::Units::KByps); },
[](tr_session const& src) -> tr_variant { return src.speed_limit(tr_direction::Up).count(Speed::Units::KByps); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<int64_t>())
{
tgt.set_speed_limit(TR_UP, Speed{ *val, Speed::Units::KByps });
tgt.set_speed_limit(tr_direction::Up, Speed{ *val, Speed::Units::KByps });
}
});
map.try_emplace(
TR_KEY_speed_limit_up_enabled,
[](tr_session const& src) -> tr_variant { return src.is_speed_limited(TR_UP); },
[](tr_session const& src) -> tr_variant { return src.is_speed_limited(tr_direction::Up); },
[](tr_session& tgt, tr_variant const& src, ErrorInfo& /*err*/)
{
if (auto const val = src.value_if<bool>())
{
tr_sessionLimitSpeed(&tgt, TR_UP, *val);
tr_sessionLimitSpeed(&tgt, tr_direction::Up, *val);
}
});
libtransmission/session-alt-speeds.h
+2 -2
View File
@@ -158,13 +158,13 @@ public:
[[nodiscard]] auto speed_limit(tr_direction const dir) const noexcept
{
auto const kbyps = dir == TR_DOWN ? settings().speed_down_kbyps : settings().speed_up_kbyps;
auto const kbyps = dir == tr_direction::Down ? settings().speed_down_kbyps : settings().speed_up_kbyps;
return Speed{ kbyps, Speed::Units::KByps };
}
constexpr void set_speed_limit(tr_direction dir, Speed const limit) noexcept
{
if (dir == TR_DOWN)
if (dir == tr_direction::Down)
{
settings_.speed_down_kbyps = limit.count(Speed::Units::KByps);
}
libtransmission/session.cc
+13 -31
View File
@@ -127,8 +127,8 @@ void bandwidthGroupRead(tr_session* session, std::string_view config_dir)
if (auto const val = group_map->value_if<bool>(TR_KEY_honors_session_limits); val)
{
group.honor_parent_limits(TR_UP, *val);
group.honor_parent_limits(TR_DOWN, *val);
group.honor_parent_limits(tr_direction::Up, *val);
group.honor_parent_limits(tr_direction::Down, *val);
}
}
}
@@ -143,7 +143,7 @@ void bandwidthGroupWrite(tr_session const* session, std::string_view const confi
auto group_map = tr_variant::Map{ 6U };
group_map.try_emplace(TR_KEY_download_limit, limits.down_limit.count(Speed::Units::KByps));
group_map.try_emplace(TR_KEY_download_limited, limits.down_limited);
group_map.try_emplace(TR_KEY_honors_session_limits, group->are_parent_limits_honored(TR_UP));
group_map.try_emplace(TR_KEY_honors_session_limits, group->are_parent_limits_honored(tr_direction::Up));
group_map.try_emplace(TR_KEY_name, name.sv());
group_map.try_emplace(TR_KEY_upload_limit, limits.up_limit.count(Speed::Units::KByps));
group_map.try_emplace(TR_KEY_upload_limited, limits.up_limited);
@@ -348,7 +348,7 @@ size_t tr_session::WebMediator::clamp(int torrent_id, size_t byte_count) const
auto const lock = session_->unique_lock();
auto const* const tor = session_->torrents().get(torrent_id);
return tor == nullptr ? 0U : tor->bandwidth().clamp(TR_DOWN, byte_count);
return tor == nullptr ? 0U : tor->bandwidth().clamp(tr_direction::Down, byte_count);
}
std::optional<std::string> tr_session::WebMediator::proxyUrl() const
@@ -614,8 +614,6 @@ namespace queue_helpers
{
std::vector<tr_torrent*> get_next_queued_torrents(tr_torrents& torrents, tr_direction dir, size_t num_wanted)
{
TR_ASSERT(tr_isDirection(dir));
auto candidates = torrents.get_matching([dir](auto const* const tor) { return tor->is_queued(dir); });
// find the best n candidates
@@ -643,7 +641,7 @@ size_t tr_session::count_queue_free_slots(tr_direction dir) const noexcept
}
auto const max = queueSize(dir);
auto const activity = dir == TR_UP ? TR_STATUS_SEED : TR_STATUS_DOWNLOAD;
auto const activity = dir == tr_direction::Up ? TR_STATUS_SEED : TR_STATUS_DOWNLOAD;
// count how many torrents are active
auto active_count = size_t{};
@@ -684,7 +682,7 @@ void tr_session::on_queue_timer()
{
using namespace queue_helpers;
for (auto const dir : { TR_UP, TR_DOWN })
for (auto const dir : { tr_direction::Up, tr_direction::Down })
{
if (!queueEnabled(dir))
{
@@ -885,8 +883,8 @@ void tr_session::setSettings(tr_session::Settings&& settings_in, bool force)
// We need to update bandwidth if speed settings changed.
// It's a harmless call, so just call it instead of checking for settings changes
update_bandwidth(TR_UP);
update_bandwidth(TR_DOWN);
update_bandwidth(tr_direction::Up);
update_bandwidth(tr_direction::Down);
}
void tr_sessionSet(tr_session* session, tr_variant const& settings)
@@ -1168,8 +1166,8 @@ void tr_session::AltSpeedMediator::is_active_changed(bool is_active, tr_session_
{
auto const in_session_thread = [session = &session_, is_active, reason]()
{
session->update_bandwidth(TR_UP);
session->update_bandwidth(TR_DOWN);
session->update_bandwidth(tr_direction::Up);
session->update_bandwidth(tr_direction::Down);
if (session->alt_speed_active_changed_func_ != nullptr)
{
@@ -1189,25 +1187,20 @@ void tr_session::AltSpeedMediator::is_active_changed(bool is_active, tr_session_
void tr_sessionSetSpeedLimit_KBps(tr_session* const session, tr_direction const dir, size_t const limit_kbyps)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
session->set_speed_limit(dir, Speed{ limit_kbyps, Speed::Units::KByps });
}
size_t tr_sessionGetSpeedLimit_KBps(tr_session const* session, tr_direction dir)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
return session->speed_limit(dir).count(Speed::Units::KByps);
}
void tr_sessionLimitSpeed(tr_session* session, tr_direction const dir, bool limited)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
if (dir == TR_DOWN)
if (dir == tr_direction::Down)
{
session->settings_.speed_limit_down_enabled = limited;
}
@@ -1222,8 +1215,6 @@ void tr_sessionLimitSpeed(tr_session* session, tr_direction const dir, bool limi
bool tr_sessionIsSpeedLimited(tr_session const* session, tr_direction const dir)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
return session->is_speed_limited(dir);
}
@@ -1232,8 +1223,6 @@ bool tr_sessionIsSpeedLimited(tr_session const* session, tr_direction const dir)
void tr_sessionSetAltSpeed_KBps(tr_session* const session, tr_direction const dir, size_t const limit_kbyps)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
session->alt_speeds_.set_speed_limit(dir, Speed{ limit_kbyps, Speed::Units::KByps });
session->update_bandwidth(dir);
}
@@ -1241,8 +1230,6 @@ void tr_sessionSetAltSpeed_KBps(tr_session* const session, tr_direction const di
size_t tr_sessionGetAltSpeed_KBps(tr_session const* session, tr_direction dir)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
return session->alt_speeds_.speed_limit(dir).count(Speed::Units::KByps);
}
@@ -2007,9 +1994,8 @@ std::string tr_sessionGetScript(tr_session const* const session, TrScript const
void tr_sessionSetQueueSize(tr_session* session, tr_direction dir, size_t max_simultaneous_torrents)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
if (dir == TR_DOWN)
if (dir == tr_direction::Down)
{
session->settings_.download_queue_size = max_simultaneous_torrents;
}
@@ -2022,7 +2008,6 @@ void tr_sessionSetQueueSize(tr_session* session, tr_direction dir, size_t max_si
size_t tr_sessionGetQueueSize(tr_session const* session, tr_direction dir)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
return session->queueSize(dir);
}
@@ -2030,9 +2015,8 @@ size_t tr_sessionGetQueueSize(tr_session const* session, tr_direction dir)
void tr_sessionSetQueueEnabled(tr_session* session, tr_direction dir, bool do_limit_simultaneous_torrents)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
if (dir == TR_DOWN)
if (dir == tr_direction::Down)
{
session->settings_.download_queue_enabled = do_limit_simultaneous_torrents;
}
@@ -2045,8 +2029,6 @@ void tr_sessionSetQueueEnabled(tr_session* session, tr_direction dir, bool do_li
bool tr_sessionGetQueueEnabled(tr_session const* session, tr_direction dir)
{
TR_ASSERT(session != nullptr);
TR_ASSERT(tr_isDirection(dir));
return session->queueEnabled(dir);
}
libtransmission/session.h
+5 -5
View File
@@ -932,12 +932,12 @@ public:
[[nodiscard]] constexpr auto queueEnabled(tr_direction dir) const noexcept
{
return dir == TR_DOWN ? settings_.download_queue_enabled : settings_.seed_queue_enabled;
return dir == tr_direction::Down ? settings_.download_queue_enabled : settings_.seed_queue_enabled;
}
[[nodiscard]] constexpr auto queueSize(tr_direction dir) const noexcept
{
return dir == TR_DOWN ? settings_.download_queue_size : settings_.seed_queue_size;
return dir == tr_direction::Down ? settings_.download_queue_size : settings_.seed_queue_size;
}
[[nodiscard]] constexpr auto queueStalledEnabled() const noexcept
@@ -1122,20 +1122,20 @@ public:
[[nodiscard]] auto speed_limit(tr_direction const dir) const noexcept
{
auto const kbyps = dir == TR_DOWN ? settings_.speed_limit_down : settings_.speed_limit_up;
auto const kbyps = dir == tr_direction::Down ? settings_.speed_limit_down : settings_.speed_limit_up;
return Speed{ kbyps, Speed::Units::KByps };
}
void set_speed_limit(tr_direction dir, Speed limit) noexcept
{
auto& tgt = dir == TR_DOWN ? settings_.speed_limit_down : settings_.speed_limit_up;
auto& tgt = dir == tr_direction::Down ? settings_.speed_limit_down : settings_.speed_limit_up;
tgt = limit.count(Speed::Units::KByps);
update_bandwidth(dir);
}
[[nodiscard]] constexpr auto is_speed_limited(tr_direction dir) const noexcept
{
return dir == TR_DOWN ? settings_.speed_limit_down_enabled : settings_.speed_limit_up_enabled;
return dir == tr_direction::Down ? settings_.speed_limit_down_enabled : settings_.speed_limit_up_enabled;
}
[[nodiscard]] auto piece_speed(tr_direction dir) const noexcept
libtransmission/torrent.cc
+10 -13
View File
@@ -219,16 +219,12 @@ void tr_torrentSetSpeedLimit_KBps(tr_torrent* const tor, tr_direction const dir,
size_t tr_torrentGetSpeedLimit_KBps(tr_torrent const* const tor, tr_direction const dir)
{
TR_ASSERT(tr_isTorrent(tor));
TR_ASSERT(tr_isDirection(dir));
return tor->speed_limit(dir).count(Speed::Units::KByps);
}
void tr_torrentUseSpeedLimit(tr_torrent* const tor, tr_direction const dir, bool const enabled)
{
TR_ASSERT(tr_isTorrent(tor));
TR_ASSERT(tr_isDirection(dir));
tor->use_speed_limit(dir, enabled);
}
@@ -243,7 +239,8 @@ void tr_torrentUseSessionLimits(tr_torrent* const tor, bool const enabled)
{
TR_ASSERT(tr_isTorrent(tor));
if (tor->bandwidth().honor_parent_limits(TR_UP, enabled) || tor->bandwidth().honor_parent_limits(TR_DOWN, enabled))
if (tor->bandwidth().honor_parent_limits(tr_direction::Up, enabled) ||
tor->bandwidth().honor_parent_limits(tr_direction::Down, enabled))
{
tor->set_dirty();
}
@@ -954,10 +951,10 @@ void tr_torrent::init(tr_ctor const& ctor)
if ((loaded & tr_resume::Speedlimit) == 0)
{
use_speed_limit(TR_UP, false);
set_speed_limit(TR_UP, session->speed_limit(TR_UP));
use_speed_limit(TR_DOWN, false);
set_speed_limit(TR_DOWN, session->speed_limit(TR_DOWN));
use_speed_limit(tr_direction::Up, false);
set_speed_limit(tr_direction::Up, session->speed_limit(tr_direction::Up));
use_speed_limit(tr_direction::Down, false);
set_speed_limit(tr_direction::Down, session->speed_limit(tr_direction::Down));
tr_torrentUseSessionLimits(this, true);
}
@@ -1291,8 +1288,8 @@ tr_stat tr_torrent::stats() const
stats.errorString = this->error().errmsg().c_str();
stats.peersConnected = swarm_stats.peer_count;
stats.peersSendingToUs = swarm_stats.active_peer_count[TR_DOWN];
stats.peersGettingFromUs = swarm_stats.active_peer_count[TR_UP];
stats.peersSendingToUs = swarm_stats.active_peer_count[static_cast<uint8_t>(tr_direction::Down)];
stats.peersGettingFromUs = swarm_stats.active_peer_count[static_cast<uint8_t>(tr_direction::Up)];
stats.webseedsSendingToUs = swarm_stats.active_webseed_count;
for (int i = 0; i < TR_PEER_FROM_N_TYPES; i++)
@@ -1301,9 +1298,9 @@ tr_stat tr_torrent::stats() const
stats.knownPeersFrom[i] = swarm_stats.known_peer_from_count[i];
}
auto const piece_upload_speed = bandwidth().get_piece_speed(now_msec, TR_UP);
auto const piece_upload_speed = bandwidth().get_piece_speed(now_msec, tr_direction::Up);
stats.pieceUploadSpeed_KBps = piece_upload_speed.count(Speed::Units::KByps);
auto const piece_download_speed = bandwidth().get_piece_speed(now_msec, TR_DOWN);
auto const piece_download_speed = bandwidth().get_piece_speed(now_msec, tr_direction::Down);
stats.pieceDownloadSpeed_KBps = piece_download_speed.count(Speed::Units::KByps);
stats.percentComplete = this->completion_.percent_complete();
libtransmission/torrent.h
+6 -6
View File
@@ -240,7 +240,7 @@ struct tr_torrent
[[nodiscard]] constexpr auto uses_session_limits() const noexcept
{
return bandwidth().are_parent_limits_honored(TR_UP);
return bandwidth().are_parent_limits_honored(tr_direction::Up);
}
[[nodiscard]] constexpr auto uses_speed_limit(tr_direction dir) const noexcept
@@ -651,7 +651,7 @@ struct tr_torrent
[[nodiscard]] constexpr auto queue_direction() const noexcept
{
return is_done() ? TR_UP : TR_DOWN;
return is_done() ? tr_direction::Up : tr_direction::Down;
}
[[nodiscard]] constexpr auto is_queued(tr_direction const dir) const noexcept
@@ -686,12 +686,12 @@ struct tr_torrent
[[nodiscard]] constexpr bool client_can_download() const
{
return this->is_piece_transfer_allowed(TR_PEER_TO_CLIENT);
return this->is_piece_transfer_allowed(tr_direction::PeerToClient);
}
[[nodiscard]] constexpr bool client_can_upload() const
{
return this->is_piece_transfer_allowed(TR_CLIENT_TO_PEER);
return this->is_piece_transfer_allowed(tr_direction::ClientToPeer);
}
void set_download_dir(std::string_view path, bool is_new_torrent = false);
@@ -735,12 +735,12 @@ struct tr_torrent
return is_done() ? TR_STATUS_SEED : TR_STATUS_DOWNLOAD;
}
if (is_queued(TR_UP) && session->queueEnabled(TR_UP))
if (is_queued(tr_direction::Up) && session->queueEnabled(tr_direction::Up))
{
return TR_STATUS_SEED_WAIT;
}
if (is_queued(TR_DOWN) && session->queueEnabled(TR_DOWN))
if (is_queued(tr_direction::Down) && session->queueEnabled(tr_direction::Down))
{
return TR_STATUS_DOWNLOAD_WAIT;
}
libtransmission/transmission.h
+10 -18
View File
@@ -465,12 +465,12 @@ enum tr_port_forwarding_state : uint8_t
tr_port_forwarding_state tr_sessionGetPortForwarding(tr_session const* session);
enum tr_direction : uint8_t
enum class tr_direction : uint8_t
{
TR_CLIENT_TO_PEER = 0,
TR_UP = 0,
TR_PEER_TO_CLIENT = 1,
TR_DOWN = 1
ClientToPeer = 0,
Up = 0,
PeerToClient = 1,
Down = 1,
};
// --- Session primary speed limits
@@ -554,7 +554,7 @@ void tr_torrentSetPriority(tr_torrent* tor, tr_priority_t priority);
/**
* Torrent Queueing
*
* There are independent queues for seeding (`TR_UP`) and leeching (`TR_DOWN`).
* There are independent queues for seeding (`tr_direction::Up`) and leeching (`tr_direction::Down`).
*
* If the session already has enough non-stalled seeds/leeches when
* `tr_torrentStart()` is called, the torrent will be moved into the
@@ -594,16 +594,16 @@ void tr_torrentsQueueMoveBottom(tr_torrent* const* torrents, size_t torrent_coun
// ---
/** @brief Return the number of torrents allowed to download (if direction is `TR_DOWN`) or seed (if direction is `TR_UP`) at the same time */
/** @brief Return the number of torrents allowed to download (if direction is `tr_direction::Down`) or seed (if direction is `tr_direction::Up`) at the same time */
size_t tr_sessionGetQueueSize(tr_session const* session, tr_direction dir);
/** @brief Set the number of torrents allowed to download (if direction is `TR_DOWN`) or seed (if direction is `TR_UP`) at the same time */
/** @brief Set the number of torrents allowed to download (if direction is `tr_direction::Down`) or seed (if direction is `tr_direction::Up`) at the same time */
void tr_sessionSetQueueSize(tr_session* session, tr_direction dir, size_t max_simultaneous_torrents);
/** @brief Return true if we're limiting how many torrents can concurrently download (`TR_DOWN`) or seed (`TR_UP`) at the same time */
/** @brief Return true if we're limiting how many torrents can concurrently download (`tr_direction::Down`) or seed (`tr_direction::Up`) at the same time */
bool tr_sessionGetQueueEnabled(tr_session const* session, tr_direction dir);
/** @brief Set whether or not to limit how many torrents can download (`TR_DOWN`) or seed (`TR_UP`) at the same time */
/** @brief Set whether or not to limit how many torrents can download (`tr_direction::Down`) or seed (`tr_direction::Up`) at the same time */
void tr_sessionSetQueueEnabled(tr_session* session, tr_direction dir, bool do_limit_simultaneous_torrents);
// ---
@@ -1567,11 +1567,3 @@ tr_stat const* tr_torrentStat(tr_torrent* torrent);
// Prefer calling this over calling the single-torrent version in a loop.
// TODO(c++20) take a std::span argument
std::vector<tr_stat const*> tr_torrentStat(tr_torrent* const* torrents, size_t n_torrents);
/** @} */
/** @brief Sanity checker to test that the direction is `TR_UP` or `TR_DOWN` */
constexpr bool tr_isDirection(tr_direction d)
{
return d == TR_UP || d == TR_DOWN;
}
libtransmission/webseed.cc
+5 -5
View File
@@ -196,13 +196,13 @@ public:
[[nodiscard]] Speed get_piece_speed(uint64_t now, tr_direction dir) const override
{
return dir == TR_DOWN ? bandwidth_.get_piece_speed(now, dir) : Speed{};
return dir == tr_direction::Down ? bandwidth_.get_piece_speed(now, dir) : Speed{};
}
[[nodiscard]] tr_webseed_view get_view() const override
{
auto const is_downloading = !std::empty(tasks);
auto const speed = get_piece_speed(tr_time_msec(), TR_DOWN);
auto const speed = get_piece_speed(tr_time_msec(), tr_direction::Down);
return {
.url = base_url.c_str(),
.is_downloading = is_downloading,
@@ -212,7 +212,7 @@ public:
[[nodiscard]] TR_CONSTEXPR20 size_t active_req_count(tr_direction dir) const noexcept override
{
if (dir == TR_CLIENT_TO_PEER) // blocks we've requested
if (dir == tr_direction::ClientToPeer) // blocks we've requested
{
return active_requests.count();
}
@@ -254,8 +254,8 @@ public:
void got_piece_data(uint32_t n_bytes)
{
auto const now = tr_time_msec();
bandwidth_.notify_bandwidth_consumed(TR_DOWN, n_bytes, false, now);
bandwidth_.notify_bandwidth_consumed(TR_DOWN, n_bytes, true, now);
bandwidth_.notify_bandwidth_consumed(tr_direction::Down, n_bytes, false, now);
bandwidth_.notify_bandwidth_consumed(tr_direction::Down, n_bytes, true, now);
publish(tr_peer_event::GotPieceData(n_bytes));
connection_limiter.got_data();
}
macosx/GlobalOptionsPopoverViewController.mm
+4 -4
View File
@@ -52,7 +52,7 @@
- (IBAction)setDownSpeedSetting:(id)sender
{
tr_sessionLimitSpeed(self.fHandle, TR_DOWN, [self.fDefaults boolForKey:@"CheckDownload"]);
tr_sessionLimitSpeed(self.fHandle, tr_direction::Down, [self.fDefaults boolForKey:@"CheckDownload"]);
[NSNotificationCenter.defaultCenter postNotificationName:@"SpeedLimitUpdate" object:nil];
}
@@ -61,7 +61,7 @@
{
NSInteger const limit = [sender integerValue];
[self.fDefaults setInteger:limit forKey:@"DownloadLimit"];
tr_sessionSetSpeedLimit_KBps(self.fHandle, TR_DOWN, limit);
tr_sessionSetSpeedLimit_KBps(self.fHandle, tr_direction::Down, limit);
[NSNotificationCenter.defaultCenter postNotificationName:@"UpdateSpeedLimitValuesOutsidePrefs" object:nil];
[NSNotificationCenter.defaultCenter postNotificationName:@"SpeedLimitUpdate" object:nil];
@@ -69,7 +69,7 @@
- (IBAction)setUpSpeedSetting:(id)sender
{
tr_sessionLimitSpeed(self.fHandle, TR_UP, [self.fDefaults boolForKey:@"CheckUpload"]);
tr_sessionLimitSpeed(self.fHandle, tr_direction::Up, [self.fDefaults boolForKey:@"CheckUpload"]);
[NSNotificationCenter.defaultCenter postNotificationName:@"UpdateSpeedLimitValuesOutsidePrefs" object:nil];
[NSNotificationCenter.defaultCenter postNotificationName:@"SpeedLimitUpdate" object:nil];
@@ -79,7 +79,7 @@
{
NSInteger const limit = [sender integerValue];
[self.fDefaults setInteger:limit forKey:@"UploadLimit"];
tr_sessionSetSpeedLimit_KBps(self.fHandle, TR_UP, limit);
tr_sessionSetSpeedLimit_KBps(self.fHandle, tr_direction::Up, limit);
[NSNotificationCenter.defaultCenter postNotificationName:@"SpeedLimitUpdate" object:nil];
}
macosx/PrefsController.mm
+19 -19
View File
@@ -656,19 +656,19 @@ static NSString* const kWebUIURLFormat = @"http://localhost:%ld/";
- (void)applySpeedSettings:(id)sender
{
tr_sessionLimitSpeed(self.fHandle, TR_UP, [self.fDefaults boolForKey:@"CheckUpload"]);
tr_sessionSetSpeedLimit_KBps(self.fHandle, TR_UP, [self.fDefaults integerForKey:@"UploadLimit"]);
tr_sessionLimitSpeed(self.fHandle, tr_direction::Up, [self.fDefaults boolForKey:@"CheckUpload"]);
tr_sessionSetSpeedLimit_KBps(self.fHandle, tr_direction::Up, [self.fDefaults integerForKey:@"UploadLimit"]);
tr_sessionLimitSpeed(self.fHandle, TR_DOWN, [self.fDefaults boolForKey:@"CheckDownload"]);
tr_sessionSetSpeedLimit_KBps(self.fHandle, TR_DOWN, [self.fDefaults integerForKey:@"DownloadLimit"]);
tr_sessionLimitSpeed(self.fHandle, tr_direction::Down, [self.fDefaults boolForKey:@"CheckDownload"]);
tr_sessionSetSpeedLimit_KBps(self.fHandle, tr_direction::Down, [self.fDefaults integerForKey:@"DownloadLimit"]);
[NSNotificationCenter.defaultCenter postNotificationName:@"SpeedLimitUpdate" object:nil];
}
- (void)applyAltSpeedSettings
{
tr_sessionSetAltSpeed_KBps(self.fHandle, TR_UP, [self.fDefaults integerForKey:@"SpeedLimitUploadLimit"]);
tr_sessionSetAltSpeed_KBps(self.fHandle, TR_DOWN, [self.fDefaults integerForKey:@"SpeedLimitDownloadLimit"]);
tr_sessionSetAltSpeed_KBps(self.fHandle, tr_direction::Up, [self.fDefaults integerForKey:@"SpeedLimitUploadLimit"]);
tr_sessionSetAltSpeed_KBps(self.fHandle, tr_direction::Down, [self.fDefaults integerForKey:@"SpeedLimitDownloadLimit"]);
[NSNotificationCenter.defaultCenter postNotificationName:@"SpeedLimitUpdate" object:nil];
}
@@ -878,8 +878,8 @@ static NSString* const kWebUIURLFormat = @"http://localhost:%ld/";
- (void)setQueue:(id)sender
{
//let's just do both - easier that way
tr_sessionSetQueueEnabled(self.fHandle, TR_DOWN, [self.fDefaults boolForKey:@"Queue"]);
tr_sessionSetQueueEnabled(self.fHandle, TR_UP, [self.fDefaults boolForKey:@"QueueSeed"]);
tr_sessionSetQueueEnabled(self.fHandle, tr_direction::Down, [self.fDefaults boolForKey:@"Queue"]);
tr_sessionSetQueueEnabled(self.fHandle, tr_direction::Up, [self.fDefaults boolForKey:@"QueueSeed"]);
//handle if any transfers switch from queued to paused
[NSNotificationCenter.defaultCenter postNotificationName:@"UpdateTorrentsState" object:nil];
@@ -892,7 +892,7 @@ static NSString* const kWebUIURLFormat = @"http://localhost:%ld/";
[self.fDefaults setInteger:number forKey:seed ? @"QueueSeedNumber" : @"QueueDownloadNumber"];
tr_sessionSetQueueSize(self.fHandle, seed ? TR_UP : TR_DOWN, number);
tr_sessionSetQueueSize(self.fHandle, seed ? tr_direction::Up : tr_direction::Down, number);
}
- (void)setStalled:(id)sender
@@ -1375,17 +1375,17 @@ static NSString* const kWebUIURLFormat = @"http://localhost:%ld/";
[self.fDefaults setBool:randomPort forKey:@"RandomPort"];
//speed limit - down
BOOL const downLimitEnabled = tr_sessionIsSpeedLimited(self.fHandle, TR_DOWN);
BOOL const downLimitEnabled = tr_sessionIsSpeedLimited(self.fHandle, tr_direction::Down);
[self.fDefaults setBool:downLimitEnabled forKey:@"CheckDownload"];
auto const downLimit = tr_sessionGetSpeedLimit_KBps(self.fHandle, TR_DOWN);
auto const downLimit = tr_sessionGetSpeedLimit_KBps(self.fHandle, tr_direction::Down);
[self.fDefaults setInteger:downLimit forKey:@"DownloadLimit"];
//speed limit - up
BOOL const upLimitEnabled = tr_sessionIsSpeedLimited(self.fHandle, TR_UP);
BOOL const upLimitEnabled = tr_sessionIsSpeedLimited(self.fHandle, tr_direction::Up);
[self.fDefaults setBool:upLimitEnabled forKey:@"CheckUpload"];
auto const upLimit = tr_sessionGetSpeedLimit_KBps(self.fHandle, TR_UP);
auto const upLimit = tr_sessionGetSpeedLimit_KBps(self.fHandle, tr_direction::Up);
[self.fDefaults setInteger:upLimit forKey:@"UploadLimit"];
//alt speed limit enabled
@@ -1393,11 +1393,11 @@ static NSString* const kWebUIURLFormat = @"http://localhost:%ld/";
[self.fDefaults setBool:useAltSpeed forKey:@"SpeedLimit"];
//alt speed limit - down
auto const downLimitAlt = tr_sessionGetAltSpeed_KBps(self.fHandle, TR_DOWN);
auto const downLimitAlt = tr_sessionGetAltSpeed_KBps(self.fHandle, tr_direction::Down);
[self.fDefaults setInteger:downLimitAlt forKey:@"SpeedLimitDownloadLimit"];
//alt speed limit - up
auto const upLimitAlt = tr_sessionGetAltSpeed_KBps(self.fHandle, TR_UP);
auto const upLimitAlt = tr_sessionGetAltSpeed_KBps(self.fHandle, tr_direction::Up);
[self.fDefaults setInteger:upLimitAlt forKey:@"SpeedLimitUploadLimit"];
//alt speed limit schedule
@@ -1435,16 +1435,16 @@ static NSString* const kWebUIURLFormat = @"http://localhost:%ld/";
[self.fDefaults setInteger:idleLimitMin forKey:@"IdleLimitMinutes"];
//queue
BOOL const downloadQueue = tr_sessionGetQueueEnabled(self.fHandle, TR_DOWN);
BOOL const downloadQueue = tr_sessionGetQueueEnabled(self.fHandle, tr_direction::Down);
[self.fDefaults setBool:downloadQueue forKey:@"Queue"];
size_t const downloadQueueNum = tr_sessionGetQueueSize(self.fHandle, TR_DOWN);
size_t const downloadQueueNum = tr_sessionGetQueueSize(self.fHandle, tr_direction::Down);
[self.fDefaults setInteger:downloadQueueNum forKey:@"QueueDownloadNumber"];
BOOL const seedQueue = tr_sessionGetQueueEnabled(self.fHandle, TR_UP);
BOOL const seedQueue = tr_sessionGetQueueEnabled(self.fHandle, tr_direction::Up);
[self.fDefaults setBool:seedQueue forKey:@"QueueSeed"];
size_t const seedQueueNum = tr_sessionGetQueueSize(self.fHandle, TR_UP);
size_t const seedQueueNum = tr_sessionGetQueueSize(self.fHandle, tr_direction::Up);
[self.fDefaults setInteger:seedQueueNum forKey:@"QueueSeedNumber"];
BOOL const checkStalled = tr_sessionGetQueueStalledEnabled(self.fHandle);
macosx/Torrent.mm
+4 -4
View File
@@ -448,22 +448,22 @@ bool trashDataFile(char const* filename, void* /*user_data*/, tr_error* error)
- (BOOL)usesSpeedLimit:(BOOL)upload
{
return tr_torrentUsesSpeedLimit(self.fHandle, upload ? TR_UP : TR_DOWN);
return tr_torrentUsesSpeedLimit(self.fHandle, upload ? tr_direction::Up : tr_direction::Down);
}
- (void)setUseSpeedLimit:(BOOL)use upload:(BOOL)upload
{
tr_torrentUseSpeedLimit(self.fHandle, upload ? TR_UP : TR_DOWN, use);
tr_torrentUseSpeedLimit(self.fHandle, upload ? tr_direction::Up : tr_direction::Down, use);
}
- (NSUInteger)speedLimit:(BOOL)upload
{
return tr_torrentGetSpeedLimit_KBps(self.fHandle, upload ? TR_UP : TR_DOWN);
return tr_torrentGetSpeedLimit_KBps(self.fHandle, upload ? tr_direction::Up : tr_direction::Down);
}
- (void)setSpeedLimit:(NSUInteger)limit upload:(BOOL)upload
{
tr_torrentSetSpeedLimit_KBps(self.fHandle, upload ? TR_UP : TR_DOWN, limit);
tr_torrentSetSpeedLimit_KBps(self.fHandle, upload ? tr_direction::Up : tr_direction::Down, limit);
}
- (BOOL)usesGlobalSpeedLimit