* Last of the commands converted, cleanup remaining.

git-svn-id: svn://rakshasa.no/libtorrent/trunk/rtorrent@1154 e378c898-3ddf-0310-93e7-cc216c733640

src/core/dht_manager.cc

@@ -103,7 +103,7 @@ DhtManager::start_dht() {
   torrent::dht_manager()->set_upload_throttle(throttles.first);
   torrent::dht_manager()->set_download_throttle(throttles.second);
 
-  int port = rpc::call_command_value("get_dht_port");
+  int port = rpc::call_command_value("dht.port");
   if (port <= 0)
     return;
 
@@ -167,7 +167,7 @@ DhtManager::save_dht_cache() {
 }
 
 void
-DhtManager::set_start(const std::string& arg) {
+DhtManager::set_mode(const std::string& arg) {
   int i;
   for (i = 0; i < dht_settings_num; i++) {
     if (arg == dht_settings[i]) {

src/core/dht_manager.h

@@ -56,7 +56,7 @@ public:
   void                stop_dht();
   void                auto_start()                 { if (m_start == dht_auto) start_dht(); }
 
-  void                set_start(const std::string& arg);
+  void                set_mode(const std::string& arg);
 
   void                set_throttle_name(const std::string& throttleName);
   const std::string&  throttle_name() const        { return m_throttleName; }

src/core/download_factory.cc

@@ -251,24 +251,24 @@ DownloadFactory::receive_success() {
   if (!rtorrent->has_key_string("custom4")) rtorrent->insert_key("custom4", std::string());
   if (!rtorrent->has_key_string("custom5")) rtorrent->insert_key("custom5", std::string());
 
-  rpc::call_command("d.set_uploads_max",      rpc::call_command_void("max_uploads"), rpc::make_target(download));
-  rpc::call_command("d.set_peers_min",        rpc::call_command_void("min_peers"), rpc::make_target(download));
-  rpc::call_command("d.set_peers_max",        rpc::call_command_void("max_peers"), rpc::make_target(download));
-  rpc::call_command("d.set_tracker_numwant",  rpc::call_command_void("trackers.numwant"), rpc::make_target(download));
+  rpc::call_command("d.uploads_max.set",      rpc::call_command_void("max_uploads"), rpc::make_target(download));
+  rpc::call_command("d.peers_min.set",        rpc::call_command_void("min_peers"), rpc::make_target(download));
+  rpc::call_command("d.peers_max.set",        rpc::call_command_void("max_peers"), rpc::make_target(download));
+  rpc::call_command("d.tracker_numwant.set",  rpc::call_command_void("trackers.numwant"), rpc::make_target(download));
 
-  if (rpc::call_command_value("d.get_complete", rpc::make_target(download)) != 0) {
+  if (rpc::call_command_value("d.complete", rpc::make_target(download)) != 0) {
     if (rpc::call_command_value("min_peers_seed") >= 0)
-      rpc::call_command("d.set_peers_min", rpc::call_command_void("min_peers_seed"), rpc::make_target(download));
+      rpc::call_command("d.peers_min.set", rpc::call_command_void("min_peers_seed"), rpc::make_target(download));
 
     if (rpc::call_command_value("max_peers_seed") >= 0)
-      rpc::call_command("d.set_peers_max", rpc::call_command_void("max_peers_seed"), rpc::make_target(download));
+      rpc::call_command("d.peers_max.set", rpc::call_command_void("max_peers_seed"), rpc::make_target(download));
   }
 
   if (!rpc::call_command_value("trackers.use_udp"))
     download->enable_udp_trackers(false);
 
   if (rpc::call_command_value("system.file.max_size") > 0)
-    rpc::call_command("d.set_max_file_size", rpc::call_command_void("system.file.max_size"), rpc::make_target(download));
+    rpc::call_command("d.max_file_size.set", rpc::call_command_void("system.file.max_size"), rpc::make_target(download));
 
   // Check first if we already have these values set in the session
   // torrent, so that it is safe to change the values.
@@ -280,12 +280,12 @@ DownloadFactory::receive_success() {
                             rpc::call_command_string("system.file.split_suffix"));
 
   if (!rtorrent->has_key_string("directory"))
-    rpc::call_command("d.set_directory", m_variables["directory"], rpc::make_target(download));
+    rpc::call_command("d.directory.set", m_variables["directory"], rpc::make_target(download));
   else
-    rpc::call_command("d.set_directory_base", rtorrent->get_key("directory"), rpc::make_target(download));
+    rpc::call_command("d.directory_base.set", rtorrent->get_key("directory"), rpc::make_target(download));
 
   if (!m_session && m_variables["tied_to_file"].as_value())
-    rpc::call_command("d.set_tied_to_file", m_uri.empty() ? m_variables["tied_file"] : m_uri, rpc::make_target(download));
+    rpc::call_command("d.tied_to_file.set", m_uri.empty() ? m_variables["tied_file"] : m_uri, rpc::make_target(download));
 
   rpc::call_command("d.peer_exchange.set", rpc::call_command_value("protocol.pex"), rpc::make_target(download));
 
@@ -313,7 +313,7 @@ DownloadFactory::receive_success() {
       throw torrent::input_error("The newly created download was removed.");
 
     if (!m_session)
-       rpc::call_command("d.set_state", (int64_t)m_start, rpc::make_target(download));
+       rpc::call_command("d.state.set", (int64_t)m_start, rpc::make_target(download));
 
     rpc::commands.call_catch(m_session ? "event.download.inserted_session" : "event.download.inserted_new",
                              rpc::make_target(download), torrent::Object(), "Download event action failed: ");
@@ -369,9 +369,9 @@ DownloadFactory::initialize_rtorrent(Download* download, torrent::Object* rtorre
   rtorrent->insert_key("loaded_file", m_isFile ? m_uri : std::string());
 
   if (rtorrent->has_key_value("priority"))
-    rpc::call_command("d.set_priority", rtorrent->get_key_value("priority") % 4, rpc::make_target(download));
+    rpc::call_command("d.priority.set", rtorrent->get_key_value("priority") % 4, rpc::make_target(download));
   else
-    rpc::call_command("d.set_priority", (int64_t)2, rpc::make_target(download));
+    rpc::call_command("d.priority.set", (int64_t)2, rpc::make_target(download));
 
   if (rtorrent->has_key_value("key")) {
     download->tracker_list()->set_key(rtorrent->get_key_value("key"));

src/core/download_list.cc

@@ -309,7 +309,7 @@ DownloadList::close_throw(Download* download) {
 
   download->download()->close();
 
-  if (!download->is_hash_failed() && rpc::call_command_value("d.get_hashing", rpc::make_target(download)) != Download::variable_hashing_stopped)
+  if (!download->is_hash_failed() && rpc::call_command_value("d.hashing", rpc::make_target(download)) != Download::variable_hashing_stopped)
     throw torrent::internal_error("DownloadList::close_throw(...) called but we're going into a hashing loop.");
 
   rpc::commands.call_catch("event.download.hash_removed", rpc::make_target(download), torrent::Object(), "Download event action failed: ");
@@ -343,8 +343,8 @@ DownloadList::resume(Download* download, int flags) {
       if (download->is_hash_failed())
         return;
 
-      if (rpc::call_command_value("d.get_hashing", rpc::make_target(download)) == Download::variable_hashing_stopped)
-        rpc::call_command("d.set_hashing", Download::variable_hashing_initial, rpc::make_target(download));
+      if (rpc::call_command_value("d.hashing", rpc::make_target(download)) == Download::variable_hashing_stopped)
+        rpc::call_command("d.hashing.set", Download::variable_hashing_initial, rpc::make_target(download));
 
       rpc::commands.call_catch("event.download.hash_queued", rpc::make_target(download), torrent::Object(), "Download event action failed: ");
       return;
@@ -353,13 +353,13 @@ DownloadList::resume(Download* download, int flags) {
     // This will never actually do anything due to the above hash check.
     // open_throw(download);
 
-    rpc::call_command("d.set_state_changed", cachedTime.seconds(), rpc::make_target(download));
-    rpc::call_command("d.set_state_counter", rpc::call_command_value("d.get_state_counter", rpc::make_target(download)) + 1, rpc::make_target(download));
+    rpc::call_command("d.state_changed.set", cachedTime.seconds(), rpc::make_target(download));
+    rpc::call_command("d.state_counter.set", rpc::call_command_value("d.state_counter", rpc::make_target(download)) + 1, rpc::make_target(download));
 
     if (download->is_done()) {
-      rpc::call_command("d.set_connection_current", rpc::call_command_void("d.get_connection_seed", rpc::make_target(download)), rpc::make_target(download));
+      rpc::call_command("d.connection_current.set", rpc::call_command_void("d.connection_seed", rpc::make_target(download)), rpc::make_target(download));
     } else {
-      rpc::call_command("d.set_connection_current", rpc::call_command_void("d.get_connection_leech", rpc::make_target(download)), rpc::make_target(download));
+      rpc::call_command("d.connection_current.set", rpc::call_command_void("d.connection_leech", rpc::make_target(download)), rpc::make_target(download));
 
       // For the moment, clear the resume data so we force hash-check
       // on non-complete downloads after a crash. This shouldn't be
@@ -400,9 +400,9 @@ DownloadList::pause(Download* download, int flags) {
 
     // Always clear hashing on pause. When a hashing request is added,
     // it should have cleared the hash resume data.
-    if (rpc::call_command_value("d.get_hashing", rpc::make_target(download)) != Download::variable_hashing_stopped) {
+    if (rpc::call_command_value("d.hashing", rpc::make_target(download)) != Download::variable_hashing_stopped) {
       download->download()->hash_stop();
-      rpc::call_command_set_value("d.set_hashing", Download::variable_hashing_stopped, rpc::make_target(download));
+      rpc::call_command_set_value("d.hashing.set", Download::variable_hashing_stopped, rpc::make_target(download));
 
       rpc::commands.call_catch("event.download.hash_removed", rpc::make_target(download), torrent::Object(), "Download event action failed: ");
     }
@@ -418,13 +418,13 @@ DownloadList::pause(Download* download, int flags) {
     // view.
     rpc::commands.call_catch("event.download.paused", rpc::make_target(download), torrent::Object(), "Download event action failed: ");
 
-    rpc::call_command("d.set_state_changed", cachedTime.seconds(), rpc::make_target(download));
-    rpc::call_command("d.set_state_counter", rpc::call_command_value("d.get_state_counter", rpc::make_target(download)), rpc::make_target(download));
+    rpc::call_command("d.state_changed.set", cachedTime.seconds(), rpc::make_target(download));
+    rpc::call_command("d.state_counter.set", rpc::call_command_value("d.state_counter", rpc::make_target(download)), rpc::make_target(download));
 
     // If initial seeding is complete, don't try it again when restarting.
     if (download->is_done() &&
-        rpc::call_command_void("d.get_connection_current", rpc::make_target(download)).as_string() == "initial_seed")
-      rpc::call_command("d.set_connection_seed", rpc::call_command_void("d.get_connection_current", rpc::make_target(download)), rpc::make_target(download));
+        rpc::call_command_void("d.connection_current", rpc::make_target(download)).as_string() == "initial_seed")
+      rpc::call_command("d.connection_seed.set", rpc::call_command_void("d.connection_current", rpc::make_target(download)), rpc::make_target(download));
 
     // Save the state after all the slots, etc have been called so we
     // include the modifications they may make.
@@ -441,7 +441,7 @@ DownloadList::check_hash(Download* download) {
 
   try {
 
-    if (rpc::call_command_value("d.get_hashing", rpc::make_target(download)) != Download::variable_hashing_stopped)
+    if (rpc::call_command_value("d.hashing", rpc::make_target(download)) != Download::variable_hashing_stopped)
       return;
 
     hash_queue(download, Download::variable_hashing_rehash);
@@ -474,8 +474,8 @@ DownloadList::hash_done(Download* download) {
   // confirm all the data, avoiding large BW usage on f.ex. the
   // ReiserFS bug with >4GB files.
 
-  int64_t hashing = rpc::call_command_value("d.get_hashing", rpc::make_target(download));
-  rpc::call_command_set_value("d.set_hashing", Download::variable_hashing_stopped, rpc::make_target(download));
+  int64_t hashing = rpc::call_command_value("d.hashing", rpc::make_target(download));
+  rpc::call_command_set_value("d.hashing.set", Download::variable_hashing_stopped, rpc::make_target(download));
 
   if (download->is_done() && download->download()->info()->is_meta_download())
     return process_meta_download(download);
@@ -487,17 +487,17 @@ DownloadList::hash_done(Download* download) {
 
     // If the download was previously completed but the files were
     // f.ex deleted, then we clear the state and complete.
-    if (rpc::call_command_value("d.get_complete", rpc::make_target(download)) && !download->is_done()) {
-      rpc::call_command("d.set_state", (int64_t)0, rpc::make_target(download));
+    if (rpc::call_command_value("d.complete", rpc::make_target(download)) && !download->is_done()) {
+      rpc::call_command("d.state.set", (int64_t)0, rpc::make_target(download));
       download->set_message("Download registered as completed, but hash check returned unfinished chunks.");
     }
 
     // Save resume data so we update time-stamps and priorities if
     // they were invalid/changed while loading/hashing.
-    rpc::call_command("d.set_complete", (int64_t)download->is_done(), rpc::make_target(download));
+    rpc::call_command("d.complete.set", (int64_t)download->is_done(), rpc::make_target(download));
     torrent::resume_save_progress(*download->download(), download->download()->bencode()->get_key("libtorrent_resume"));
 
-    if (rpc::call_command_value("d.get_state", rpc::make_target(download)) == 1)
+    if (rpc::call_command_value("d.state", rpc::make_target(download)) == 1)
       resume(download, download->resume_flags());
     //rpc::commands.call_catch("scheduler.simple.resume", rpc::make_target(download), torrent::Object(), "Download event action failed: ");
 
@@ -529,7 +529,7 @@ void
 DownloadList::hash_queue(Download* download, int type) {
   check_contains(download);
 
-  if (rpc::call_command_value("d.get_hashing", rpc::make_target(download)) != Download::variable_hashing_stopped)
+  if (rpc::call_command_value("d.hashing", rpc::make_target(download)) != Download::variable_hashing_stopped)
     throw torrent::internal_error("DownloadList::hash_queue(...) hashing already queued.");
 
   // HACK
@@ -544,7 +544,7 @@ DownloadList::hash_queue(Download* download, int type) {
   torrent::resume_clear_progress(*download->download(), download->download()->bencode()->get_key("libtorrent_resume"));
 
   download->set_hash_failed(false);
-  rpc::call_command_set_value("d.set_hashing", type, rpc::make_target(download));
+  rpc::call_command_set_value("d.hashing.set", type, rpc::make_target(download));
 
   if (download->is_open())
     throw torrent::internal_error("DownloadList::hash_clear(...) download still open.");
@@ -558,7 +558,7 @@ void
 DownloadList::received_finished(Download* download) {
   check_contains(download);
 
-  if (rpc::call_command_value("get_check_hash"))
+  if (rpc::call_command_value("check_hash"))
     // Set some 'checking_finished_thingie' variable to make hash_done
     // trigger correctly, also so it can bork on missing data.
     hash_queue(download, Download::variable_hashing_last);
@@ -574,16 +574,16 @@ DownloadList::confirm_finished(Download* download) {
   if (download->download()->info()->is_meta_download())
     return process_meta_download(download);
 
-  rpc::call_command("d.set_complete", (int64_t)1, rpc::make_target(download));
+  rpc::call_command("d.complete.set", (int64_t)1, rpc::make_target(download));
 
-  rpc::call_command("d.set_connection_current", rpc::call_command_void("d.get_connection_seed", rpc::make_target(download)), rpc::make_target(download));
+  rpc::call_command("d.connection_current.set", rpc::call_command_void("d.connection_seed", rpc::make_target(download)), rpc::make_target(download));
   download->set_priority(download->priority());
 
-  if (rpc::call_command_value("d.get_peers_min", rpc::make_target(download)) == rpc::call_command_value("min_peers") && rpc::call_command_value("min_peers_seed") >= 0)
-    rpc::call_command("d.set_peers_min", rpc::call_command_void("min_peers_seed"), rpc::make_target(download));
+  if (rpc::call_command_value("d.peers_min", rpc::make_target(download)) == rpc::call_command_value("min_peers") && rpc::call_command_value("min_peers_seed") >= 0)
+    rpc::call_command("d.peers_min.set", rpc::call_command_void("min_peers_seed"), rpc::make_target(download));
 
-  if (rpc::call_command_value("d.get_peers_max", rpc::make_target(download)) == rpc::call_command_value("max_peers") && rpc::call_command_value("max_peers_seed") >= 0)
-    rpc::call_command("d.set_peers_max", rpc::call_command_void("max_peers_seed"), rpc::make_target(download));
+  if (rpc::call_command_value("d.peers_max", rpc::make_target(download)) == rpc::call_command_value("max_peers") && rpc::call_command_value("max_peers_seed") >= 0)
+    rpc::call_command("d.peers_max.set", rpc::call_command_void("max_peers_seed"), rpc::make_target(download));
 
   // Do this before the slots are called in case one of them closes
   // the download.
@@ -603,7 +603,7 @@ DownloadList::confirm_finished(Download* download) {
   if (download->resume_flags() != ~uint32_t())
     throw torrent::internal_error("DownloadList::confirm_finished(...) download->resume_flags() != ~uint32_t().");
 
-  if (!download->is_active() && rpc::call_command_value("d.get_state", rpc::make_target(download)) == 1)
+  if (!download->is_active() && rpc::call_command_value("d.state", rpc::make_target(download)) == 1)
     resume(download, torrent::Download::start_no_create | torrent::Download::start_skip_tracker | torrent::Download::start_keep_baseline);
 }
 

src/core/manager.cc

@@ -500,7 +500,7 @@ path_expand(std::vector<std::string>* paths, const std::string& pattern) {
 
 bool
 manager_equal_tied(const std::string& path, Download* download) {
-  return path == rpc::call_command_string("d.get_tied_to_file", rpc::make_target(download));
+  return path == rpc::call_command_string("d.tied_to_file", rpc::make_target(download));
 }
 
 void
@@ -541,7 +541,7 @@ Manager::receive_hashing_changed() {
       continue;
 
     bool tryQuick =
-      rpc::call_command_value("d.get_hashing", rpc::make_target(*itr)) == Download::variable_hashing_initial &&
+      rpc::call_command_value("d.hashing", rpc::make_target(*itr)) == Download::variable_hashing_initial &&
       (*itr)->download()->file_list()->bitfield()->empty();
 
     if (!tryQuick && foundHashing)
@@ -564,7 +564,7 @@ Manager::receive_hashing_changed() {
         (*itr)->download()->hash_stop();
 
         if (foundHashing) {
-          rpc::call_command_set_value("d.set_hashing", Download::variable_hashing_rehash, rpc::make_target(*itr));
+          rpc::call_command_set_value("d.hashing.set", Download::variable_hashing_rehash, rpc::make_target(*itr));
           continue;
         }
       }
@@ -575,7 +575,7 @@ Manager::receive_hashing_changed() {
     } catch (torrent::local_error& e) {
       if (tryQuick) {
         // Make sure we don't repeat the quick hashing.
-        rpc::call_command_set_value("d.set_hashing", Download::variable_hashing_rehash, rpc::make_target(*itr));
+        rpc::call_command_set_value("d.hashing.set", Download::variable_hashing_rehash, rpc::make_target(*itr));
 
       } else {
         (*itr)->set_hash_failed(true);

src/core/view.cc

@@ -294,7 +294,7 @@ View::set_filter_on_event(const std::string& event) {
   if (std::find(m_events.begin(), m_events.end(), event) != m_events.end())
     return;
 
-  rpc::commands.call_catch("method.set_key", rpc::make_target(), rpc::create_object_list(event, "!view_" + m_name, "view.filter_download=" + m_name));
+  rpc::commands.call_catch("method.set_key", rpc::make_target(), rpc::create_object_list(event, "!view." + m_name, "view.filter_download=" + m_name));
   m_events.push_back(event);
 }
 
@@ -303,7 +303,7 @@ View::clear_filter_on() {
   // Don't clear insert and erase as these are required to keep the
   // View up-to-date with the available downloads.
   for (event_list_type::const_iterator itr = m_events.begin(); itr != m_events.end(); itr++)
-    rpc::commands.call_catch("method.set_key", rpc::make_target(), rpc::create_object_list(*itr, "!view_" + m_name));
+    rpc::commands.call_catch("method.set_key", rpc::make_target(), rpc::create_object_list(*itr, "!view." + m_name));
 }
 
 inline void