Changeset 1146

Timestamp:

03/15/10 19:31:58 (3 years ago)

Author:

rakshasa

Message:

• Cleaned up torrent/download.h.

• Removed raw_value as it is redundant.

• Fixed 'greater' command and added 'equal'. Patch by Josef Drexler.

Location:

trunk

Files:

• libtorrent/src/download/download_main.h (modified) (2 diffs)
• libtorrent/src/download/download_wrapper.cc (modified) (14 diffs)
• libtorrent/src/download/download_wrapper.h (modified) (7 diffs)
• libtorrent/src/torrent/download.cc (modified) (1 diff)
• libtorrent/src/torrent/download.h (modified) (1 diff)
• libtorrent/src/torrent/download_info.h (modified) (4 diffs)
• libtorrent/test/torrent/object_static_map_test.cc (modified) (3 diffs)
• rtorrent/src/command_download.cc (modified) (1 diff)
• rtorrent/src/command_ui.cc (modified) (3 diffs)
• rtorrent/src/core/download.cc (modified) (1 diff)
• rtorrent/src/core/download_list.cc (modified) (1 diff)

trunk/libtorrent/src/download/download_main.h

@@ -149 +149 @@
   void                update_endgame();
 
+  rak::priority_item& delay_download_done() { return m_delayDownloadDone; }
+
 private:
   // Disable copy ctor and assignment.
@@ -190 +192 @@
   SlotHashCheckAdd    m_slotHashCheckAdd;
 
+  rak::priority_item  m_delayDownloadDone;
   rak::priority_item  m_taskTrackerRequest;
 };

trunk/libtorrent/src/download/download_wrapper.cc

@@ -64 +64 @@
 
 DownloadWrapper::DownloadWrapper() :
+  m_main(new DownloadMain),
+
   m_bencode(NULL),
   m_hashChecker(NULL),
   m_connectionType(0) {
 
-  m_delayDownloadDone.set_slot(rak::mem_fn(&m_signalDownloadDone, &Signal::operator()));
-
-  m_main.tracker_manager()->set_info(info());
-  m_main.tracker_manager()->slot_success(rak::make_mem_fun(this, &DownloadWrapper::receive_tracker_success));
-  m_main.tracker_manager()->slot_failed(rak::make_mem_fun(this, &DownloadWrapper::receive_tracker_failed));
-
-  m_main.chunk_list()->slot_storage_error(rak::make_mem_fun(this, &DownloadWrapper::receive_storage_error));
+  m_main->delay_download_done().set_slot(rak::mem_fn(&info()->signal_download_done(), &Signal::operator()));
+
+  m_main->tracker_manager()->set_info(info());
+  m_main->tracker_manager()->slot_success(rak::make_mem_fun(this, &DownloadWrapper::receive_tracker_success));
+  m_main->tracker_manager()->slot_failed(rak::make_mem_fun(this, &DownloadWrapper::receive_tracker_failed));
+
+  m_main->chunk_list()->slot_storage_error(rak::make_mem_fun(this, &DownloadWrapper::receive_storage_error));
 }
 
 DownloadWrapper::~DownloadWrapper() {
   if (info()->is_active())
-    m_main.stop();
+    m_main->stop();
 
   if (info()->is_open())
@@ -86 +88 @@
   // If the client wants to do a quick cleanup after calling close, it
   // will need to manually cancel the tracker requests.
-  m_main.tracker_manager()->close();
+  m_main->tracker_manager()->close();
 
   delete m_hashChecker;
   delete m_bencode;
+  delete m_main;
 }
 
@@ -102 +105 @@
   info()->mutable_local_id().assign(id.c_str());
 
-  info()->slot_left() = sigc::mem_fun(m_main.file_list(), &FileList::left_bytes);
-  info()->slot_completed() = sigc::mem_fun(m_main.file_list(), &FileList::completed_bytes);
-
-  m_main.slot_hash_check_add(rak::make_mem_fun(this, &DownloadWrapper::check_chunk_hash));
+  info()->slot_left() = sigc::mem_fun(m_main->file_list(), &FileList::left_bytes);
+  info()->slot_completed() = sigc::mem_fun(m_main->file_list(), &FileList::completed_bytes);
+
+  m_main->slot_hash_check_add(rak::make_mem_fun(this, &DownloadWrapper::check_chunk_hash));
 
   // Info hash must be calculate from here on.
-  m_hashChecker = new HashTorrent(m_main.chunk_list());
+  m_hashChecker = new HashTorrent(m_main->chunk_list());
 
   // Connect various signals and slots.
@@ -130 +133 @@
   // succeeds or not, any chunks not included in that last
   // hash_resume_save get ignored anyway.
-  m_main.chunk_list()->sync_chunks(ChunkList::sync_all | ChunkList::sync_force | ChunkList::sync_sloppy | ChunkList::sync_ignore_error);
-
-  m_main.close();
+  m_main->chunk_list()->sync_chunks(ChunkList::sync_all | ChunkList::sync_force | ChunkList::sync_sloppy | ChunkList::sync_ignore_error);
+
+  m_main->close();
 
   // Should this perhaps be in stop?
-  priority_queue_erase(&taskScheduler, &m_delayDownloadDone);
+  priority_queue_erase(&taskScheduler, &m_main->delay_download_done());
 }
 
 bool
 DownloadWrapper::is_stopped() const {
-  return !m_main.tracker_manager()->is_active() && !m_main.tracker_manager()->is_busy();
+  return !m_main->tracker_manager()->is_active() && !m_main->tracker_manager()->is_busy();
 }
 
@@ -159 +162 @@
     // Initialize the ChunkSelector here so that no chunks will be
     // marked by HashTorrent that are not accounted for.
-    m_main.chunk_selector()->initialize(m_main.file_list()->mutable_bitfield(), m_main.chunk_statistics());
+    m_main->chunk_selector()->initialize(m_main->file_list()->mutable_bitfield(), m_main->chunk_statistics());
     receive_update_priorities();
   }
 
-  m_signalInitialHash.emit();
+  info()->signal_initial_hash().emit();
 }    
 
@@ -181 +184 @@
     } else {
       if (std::memcmp(hash, chunk_hash(handle.index()), 20) == 0)
-        m_main.file_list()->mark_completed(handle.index());
+        m_main->file_list()->mark_completed(handle.index());
 
       m_hashChecker->receive_chunkdone();
@@ -197 +200 @@
       // safe.
 
-      if (m_main.chunk_selector()->bitfield()->get(handle.index()))
+      if (m_main->chunk_selector()->bitfield()->get(handle.index()))
         throw internal_error("DownloadWrapper::receive_hash_done(...) received a chunk that isn't set in ChunkSelector.");
 
       if (std::memcmp(hash, chunk_hash(handle.index()), 20) == 0) {
-        m_main.file_list()->mark_completed(handle.index());
-        m_main.delegator()->transfer_list()->hash_succeeded(handle.index(), handle.chunk());
-        m_main.update_endgame();
-
-        if (m_main.file_list()->is_done())
+        m_main->file_list()->mark_completed(handle.index());
+        m_main->delegator()->transfer_list()->hash_succeeded(handle.index(), handle.chunk());
+        m_main->update_endgame();
+
+        if (m_main->file_list()->is_done())
           finished_download();
     
-        if (!m_main.have_queue()->empty() && m_main.have_queue()->front().first >= cachedTime)
-          m_main.have_queue()->push_front(DownloadMain::have_queue_type::value_type(m_main.have_queue()->front().first + 1, handle.index()));
+        if (!m_main->have_queue()->empty() && m_main->have_queue()->front().first >= cachedTime)
+          m_main->have_queue()->push_front(DownloadMain::have_queue_type::value_type(m_main->have_queue()->front().first + 1, handle.index()));
         else
-          m_main.have_queue()->push_front(DownloadMain::have_queue_type::value_type(cachedTime, handle.index()));
-
-        signal_chunk_passed().emit(handle.index());
+          m_main->have_queue()->push_front(DownloadMain::have_queue_type::value_type(cachedTime, handle.index()));
+
+        info()->signal_chunk_passed().emit(handle.index());
 
       } else {
         // This needs to ensure the chunk is still valid.
-        m_main.delegator()->transfer_list()->hash_failed(handle.index(), handle.chunk());
-        signal_chunk_failed().emit(handle.index());
+        m_main->delegator()->transfer_list()->hash_failed(handle.index(), handle.chunk());
+        info()->signal_chunk_failed().emit(handle.index());
       }
     }
   }
 
-  m_main.chunk_list()->release(&handle);
+  m_main->chunk_list()->release(&handle);
 }  
 
@@ -234 +237 @@
 void
 DownloadWrapper::receive_storage_error(const std::string& str) {
-  m_main.stop();
+  m_main->stop();
   close();
 
-  m_main.tracker_manager()->set_active(false);
-  m_main.tracker_manager()->close();
+  m_main->tracker_manager()->set_active(false);
+  m_main->tracker_manager()->close();
 
   info()->signal_storage_error().emit(str);
@@ -245 +248 @@
 void
 DownloadWrapper::receive_tracker_success(AddressList* l) {
-  m_main.peer_list()->insert_available(l);
-  m_main.receive_connect_peers();
-  m_main.receive_tracker_success();
-
-  m_signalTrackerSuccess.emit();
+  m_main->peer_list()->insert_available(l);
+  m_main->receive_connect_peers();
+  m_main->receive_tracker_success();
+
+  info()->signal_tracker_success().emit();
 }
 
 void
 DownloadWrapper::receive_tracker_failed(const std::string& msg) {
-  m_signalTrackerFailed.emit(msg);
+  info()->signal_tracker_failed().emit(msg);
 }
 
@@ -264 +267 @@
   if (ticks % 120 == 0)
 //   if (ticks % 1 == 0)
-    m_main.peer_list()->cull_peers(PeerList::cull_old | PeerList::cull_keep_interesting);
+    m_main->peer_list()->cull_peers(PeerList::cull_old | PeerList::cull_keep_interesting);
 
   if (!info()->is_open())
@@ -273 +276 @@
     if (info()->is_active()) {
       if (info()->is_pex_enabled()) {
-        m_main.do_peer_exchange();
+        m_main->do_peer_exchange();
 
       // If PEX was disabled since the last peer exchange, deactivate it now.
@@ -279 +282 @@
         info()->unset_flags(DownloadInfo::flag_pex_active);
 
-        for (ConnectionList::iterator itr = m_main.connection_list()->begin(); itr != m_main.connection_list()->end(); ++itr)
+        for (ConnectionList::iterator itr = m_main->connection_list()->begin(); itr != m_main->connection_list()->end(); ++itr)
           (*itr)->m_ptr()->set_peer_exchange(false);
       }
     }
 
-    for (ConnectionList::iterator itr = m_main.connection_list()->begin(); itr != m_main.connection_list()->end(); )
+    for (ConnectionList::iterator itr = m_main->connection_list()->begin(); itr != m_main->connection_list()->end(); )
       if (!(*itr)->m_ptr()->receive_keepalive())
-        itr = m_main.connection_list()->erase(itr, ConnectionList::disconnect_available);
+        itr = m_main->connection_list()->erase(itr, ConnectionList::disconnect_available);
       else
         itr++;
   }
 
-  DownloadMain::have_queue_type* haveQueue = m_main.have_queue();
+  DownloadMain::have_queue_type* haveQueue = m_main->have_queue();
   haveQueue->erase(std::find_if(haveQueue->rbegin(), haveQueue->rend(),
                                 rak::less(cachedTime - rak::timer::from_seconds(600),
@@ -297 +300 @@
                    haveQueue->end());
 
-  m_main.receive_connect_peers();
+  m_main->receive_connect_peers();
 }
 
 void
 DownloadWrapper::receive_update_priorities() {
-  if (m_main.chunk_selector()->empty())
+  if (m_main->chunk_selector()->empty())
     return;
 
-  m_main.chunk_selector()->high_priority()->clear();
-  m_main.chunk_selector()->normal_priority()->clear();
-
-  for (FileList::iterator itr = m_main.file_list()->begin(); itr != m_main.file_list()->end(); ++itr) {
+  m_main->chunk_selector()->high_priority()->clear();
+  m_main->chunk_selector()->normal_priority()->clear();
+
+  for (FileList::iterator itr = m_main->file_list()->begin(); itr != m_main->file_list()->end(); ++itr) {
     if ((*itr)->priority() == 1)
-      m_main.chunk_selector()->normal_priority()->insert((*itr)->range().first, (*itr)->range().second);
+      m_main->chunk_selector()->normal_priority()->insert((*itr)->range().first, (*itr)->range().second);
 
     else if ((*itr)->priority() == 2)
-      m_main.chunk_selector()->high_priority()->insert((*itr)->range().first, (*itr)->range().second);
+      m_main->chunk_selector()->high_priority()->insert((*itr)->range().first, (*itr)->range().second);
   }
 
-  m_main.chunk_selector()->update_priorities();
-
-  std::for_each(m_main.connection_list()->begin(), m_main.connection_list()->end(),
+  m_main->chunk_selector()->update_priorities();
+
+  std::for_each(m_main->connection_list()->begin(), m_main->connection_list()->end(),
                 rak::on(std::mem_fun(&Peer::m_ptr), std::mem_fun(&PeerConnectionBase::update_interested)));
 }
@@ -331 +334 @@
   //
   // This needs to be seperated into a new function.
-  if (!m_delayDownloadDone.is_queued())
-    priority_queue_insert(&taskScheduler, &m_delayDownloadDone, cachedTime);
-
-  m_main.connection_list()->erase_seeders();
+  if (!m_main->delay_download_done().is_queued())
+    priority_queue_insert(&taskScheduler, &m_main->delay_download_done(), cachedTime);
+
+  m_main->connection_list()->erase_seeders();
   info()->mutable_down_rate()->reset_rate();
 }

trunk/libtorrent/src/download/download_wrapper.h

@@ -38 +38 @@
 #define LIBTORRENT_DOWNLOAD_WRAPPER_H
 
-#include <rak/socket_address.h>
 #include <sigc++/connection.h>
 #include <sigc++/signal.h>
@@ -68 +67 @@
   ~DownloadWrapper();
 
+  DownloadInfo*       info()                                  { return m_main->info(); }
+
   // Initialize hash checker and various download stuff.
   void                initialize(const std::string& hash, const std::string& id);
@@ -73 +74 @@
   void                close();
 
-//   bool                is_open() const                         { return m_main.is_open(); }
   bool                is_stopped() const;
 
-  DownloadMain*       main()                                  { return &m_main; }
-  const DownloadMain* main() const                            { return &m_main; }
+  DownloadMain*       main()                                  { return m_main; }
+  const DownloadMain* main() const                            { return m_main; }
   HashTorrent*        hash_checker()                          { return m_hashChecker; }
 
@@ -90 +90 @@
   void                set_complete_hash(const std::string& hash) { m_hash = hash; }
 
-  DownloadInfo*       info()                                  { return m_main.info(); }
-
   int                 connection_type() const                 { return m_connectionType; }
   void                set_connection_type(int t)              { m_connectionType = t; }
+
+  //
+  // Internal:
+  //
 
   void                receive_initial_hash();
@@ -108 +110 @@
   void                receive_update_priorities();
 
-  Signal&             signal_initial_hash()          { return m_signalInitialHash; }
-  Signal&             signal_download_done()         { return m_signalDownloadDone; }
-
-  // The list of addresses is guaranteed to be sorted and unique.
-  Signal&             signal_tracker_success()       { return m_signalTrackerSuccess; }
-  SignalString&       signal_tracker_failed()        { return m_signalTrackerFailed; }
-
-  SignalChunk&        signal_chunk_passed()          { return m_signalChunkPassed; }
-  SignalChunk&        signal_chunk_failed()          { return m_signalChunkFailed; }
-
 private:
   DownloadWrapper(const DownloadWrapper&);
@@ -124 +116 @@
   void                finished_download();
 
-  DownloadMain        m_main;
+  DownloadMain*       m_main;
   Object*             m_bencode;
   HashTorrent*        m_hashChecker;
@@ -133 +125 @@
   int                 m_connectionType;
 
-  rak::priority_item  m_delayDownloadDone;
-
-  Signal              m_signalInitialHash;
-  Signal              m_signalDownloadDone;
-
-  Signal              m_signalTrackerSuccess;
-  SignalString        m_signalTrackerFailed;
-
-  SignalChunk         m_signalChunkPassed;
-  SignalChunk         m_signalChunkFailed;
-
   sigc::connection    m_connectionChunkPassed;
   sigc::connection    m_connectionChunkFailed;

trunk/libtorrent/src/torrent/download.cc

@@ -446 +446 @@
 }
 
-sigc::connection
-Download::signal_download_done(Download::slot_void_type s) {
-  return m_ptr->signal_download_done().connect(s);
-}
-
-sigc::connection
-Download::signal_hash_done(Download::slot_void_type s) {
-  return m_ptr->signal_initial_hash().connect(s);
-}
-
-sigc::connection
-Download::signal_tracker_succeeded(Download::slot_void_type s) {
-  return m_ptr->signal_tracker_success().connect(s);
-}
-
-sigc::connection
-Download::signal_tracker_failed(Download::slot_string_type s) {
-  return m_ptr->signal_tracker_failed().connect(s);
-}
-
-sigc::connection
-Download::signal_tracker_dump(Download::slot_dump_type s) {
-  return m_ptr->info()->signal_tracker_dump().connect(s);
-}
-
-sigc::connection
-Download::signal_chunk_passed(Download::slot_chunk_type s) {
-  return m_ptr->signal_chunk_passed().connect(s);
-}
-
-sigc::connection
-Download::signal_chunk_failed(Download::slot_chunk_type s) {
-  return m_ptr->signal_chunk_failed().connect(s);
-}
-
-sigc::connection
-Download::signal_network_log(slot_string_type s) {
-  return m_ptr->info()->signal_network_log().connect(s);
-}
-
-sigc::connection
-Download::signal_storage_error(slot_string_type s) {
-  return m_ptr->info()->signal_storage_error().connect(s);
-}
-
-}
+}

trunk/libtorrent/src/torrent/download.h

@@ -172 +172 @@
   void                add_peer(const sockaddr* addr, int port);
 
-  typedef sigc::slot0<void>                                          slot_void_type;
-  typedef sigc::slot1<void, const std::string&>                      slot_string_type;
-
-  typedef sigc::slot1<void, uint32_t>                                slot_chunk_type;
-  typedef sigc::slot3<void, const std::string&, const char*, size_t> slot_dump_type;
-
-  // signal_download_done is a delayed signal so it is safe to
-  // stop/close the torrent when received. The signal is only emitted
-  // when the torrent is active, so hash checking will not trigger it.
-  sigc::connection    signal_download_done(slot_void_type s);
-  sigc::connection    signal_hash_done(slot_void_type s);
-
-  sigc::connection    signal_tracker_succeeded(slot_void_type s);
-  sigc::connection    signal_tracker_failed(slot_string_type s);
-  sigc::connection    signal_tracker_dump(slot_dump_type s);
-
-  sigc::connection    signal_chunk_passed(slot_chunk_type s);
-  sigc::connection    signal_chunk_failed(slot_chunk_type s);
-
-  // Various network log message signals.
-  sigc::connection    signal_network_log(slot_string_type s);
-
-  // Emits error messages if there are problems opening files for
-  // read/write when the download is active. The client should stop
-  // the download if it receive any of these as it will not be able to
-  // continue.
-  sigc::connection    signal_storage_error(slot_string_type s);
-
   DownloadWrapper*    ptr() { return m_ptr; }
 

trunk/libtorrent/src/torrent/download_info.h

@@ -57 +57 @@
 public:
   typedef sigc::slot0<uint64_t>                                        slot_stat_type;
+  typedef sigc::signal0<void>                                          signal_void_type;
   typedef sigc::signal1<void, const std::string&>                      signal_string_type;
   typedef sigc::signal1<void, uint32_t>                                signal_chunk_type;
@@ -142 +143 @@
   uint32_t            udp_tries() const                            { return 2; }
 
-  slot_stat_type&     slot_left()                                  { return m_slotStatLeft; }
-  slot_stat_type&     slot_completed()                             { return m_slotStatCompleted; }
-
-  signal_string_type& signal_network_log()                         { return m_signalNetworkLog; }
-  signal_string_type& signal_storage_error()                       { return m_signalStorageError; }
-  signal_dump_type&   signal_tracker_dump()                        { return m_signalTrackerDump; }
+  // These signals are also used internally, so do not clear them or
+  // trigger them.
+  signal_void_type&   signal_initial_hash() const                  { return m_signalInitialHash; }
+  signal_void_type&   signal_download_done() const                 { return m_signalDownloadDone; }
+
+  signal_string_type& signal_network_log() const                   { return m_signalNetworkLog; }
+  signal_string_type& signal_storage_error() const                 { return m_signalStorageError; }
+  signal_dump_type&   signal_tracker_dump() const                  { return m_signalTrackerDump; }
+
+  // The list of addresses is guaranteed to be sorted and unique.
+  signal_void_type&   signal_tracker_success() const               { return m_signalTrackerSuccess; }
+  signal_string_type& signal_tracker_failed() const                { return m_signalTrackerFailed; }
+
+  signal_chunk_type&  signal_chunk_passed() const                  { return m_signalChunkPassed; }
+  signal_chunk_type&  signal_chunk_failed() const                  { return m_signalChunkFailed; }
 
   //
@@ -154 +164 @@
 
   void                set_creation_date(uint32_t d)                { m_creationDate = d; }
+
+  slot_stat_type&     slot_left()                                  { return m_slotStatLeft; }
+  slot_stat_type&     slot_completed()                             { return m_slotStatCompleted; }
 
 private:
@@ -179 +192 @@
   slot_stat_type      m_slotStatCompleted;
 
-  signal_string_type  m_signalNetworkLog;
-  signal_string_type  m_signalStorageError;
-  signal_dump_type    m_signalTrackerDump;
+  mutable signal_void_type    m_signalInitialHash;
+  mutable signal_void_type    m_signalDownloadDone;
+
+  mutable signal_string_type  m_signalNetworkLog;
+  mutable signal_string_type  m_signalStorageError;
+  mutable signal_dump_type    m_signalTrackerDump;
+
+  mutable signal_void_type    m_signalTrackerSuccess;
+  mutable signal_string_type  m_signalTrackerFailed;
+
+  mutable signal_chunk_type   m_signalChunkPassed;
+  mutable signal_chunk_type   m_signalChunkFailed;
 };
 

trunk/libtorrent/test/torrent/object_static_map_test.cc

@@ -260 +260 @@
   CPPUNIT_ASSERT(static_map_read_bencode(map_raw, "d1:bi1ee"));
   CPPUNIT_ASSERT(torrent::raw_bencode_equal_c_str(map_raw[key_raw_a].as_raw_bencode(), "i1e"));
-  CPPUNIT_ASSERT(torrent::raw_bencode_equal_c_str(map_raw[key_raw_a].as_raw_bencode().as_raw_value(), "1"));
 
   CPPUNIT_ASSERT(static_map_read_bencode(map_raw, "d1:b2:abe"));
@@ -310 +309 @@
   CPPUNIT_ASSERT(static_map_read_bencode(map_normal, "d1:ai1e1:bi2e1:ci3ee"));
   CPPUNIT_ASSERT(map_normal[key_multiple_a].as_value() == 1);
-  CPPUNIT_ASSERT(map_normal[key_multiple_b].as_raw_bencode().as_raw_value().size() == 1);
-  CPPUNIT_ASSERT(map_normal[key_multiple_b].as_raw_bencode().as_raw_value().data()[0] == '2');
+//   CPPUNIT_ASSERT(map_normal[key_multiple_b].as_raw_bencode().as_raw_value().size() == 1);
+//   CPPUNIT_ASSERT(map_normal[key_multiple_b].as_raw_bencode().as_raw_value().data()[0] == '2');
   CPPUNIT_ASSERT(map_normal[key_multiple_c].as_value() == 3);
 }
@@ -355 +354 @@
   CPPUNIT_ASSERT(static_map_write_bencode(map_value, "d1:bi1ee"));
 
-  map_value[key_single_a] = torrent::raw_value("1", 1);
-  CPPUNIT_ASSERT(static_map_write_bencode(map_value, "d1:bi1ee"));
+//   map_value[key_single_a] = torrent::raw_value("1", 1);
+//   CPPUNIT_ASSERT(static_map_write_bencode(map_value, "d1:bi1ee"));
 
   map_value[key_single_a] = torrent::raw_string("test", 4);

trunk/rtorrent/src/command_download.cc

@@ -308 +308 @@
 torrent::Object
 cmd_d_initialize_logs(core::Download* download) {
-  download->download()->signal_network_log(sigc::mem_fun(control->core(), &core::Manager::push_log_complete));
-  download->download()->signal_storage_error(sigc::mem_fun(control->core(), &core::Manager::push_log_complete));
+  download->info()->signal_network_log().connect(sigc::mem_fun(control->core(), &core::Manager::push_log_complete));
+  download->info()->signal_storage_error().connect(sigc::mem_fun(control->core(), &core::Manager::push_log_complete));
 
   if (!rpc::call_command_string("log.tracker").empty())
-    download->download()->signal_tracker_dump(sigc::ptr_fun(&core::receive_tracker_dump));
+    download->info()->signal_tracker_dump().connect(sigc::ptr_fun(&core::receive_tracker_dump));
 
   return torrent::Object();

trunk/rtorrent/src/command_ui.cc

@@ -213 +213 @@
 
 torrent::Object
-apply_less(rpc::target_type target, const torrent::Object& rawArgs) {
+apply_cmp(rpc::target_type target, const torrent::Object& rawArgs) {
   const torrent::Object::list_type& args = rawArgs.as_list();
   
@@ -240 +240 @@
     
   switch (result1.type()) {
-  case torrent::Object::TYPE_VALUE:  return result1.as_value() < result2.as_value();
-  case torrent::Object::TYPE_STRING: return result1.as_string() < result2.as_string();
-  default: return (int64_t)false;
+  case torrent::Object::TYPE_VALUE:  return result1.as_value() - result2.as_value();
+  case torrent::Object::TYPE_STRING: return result1.as_string().compare(result2.as_string());
+  default: return torrent::Object();
   }
 }
 
-// Fixme.
-torrent::Object
-apply_greater(rpc::target_type target, const torrent::Object& rawArgs) {
-  return (int64_t)!apply_less(target, rawArgs).as_value();
+torrent::Object apply_less(rpc::target_type target, const torrent::Object& rawArgs) {
+  torrent::Object result = apply_cmp(target, rawArgs);
+  return result.is_value() ? result.as_value() <  0 : (int64_t)false;
+}
+
+torrent::Object apply_greater(rpc::target_type target, const torrent::Object& rawArgs) {
+  torrent::Object result = apply_cmp(target, rawArgs);
+  return result.is_value() ? result.as_value() >  0 : (int64_t)false;
+}
+
+torrent::Object apply_equal(rpc::target_type target, const torrent::Object& rawArgs) {
+  torrent::Object result = apply_cmp(target, rawArgs);
+  return result.is_value() ? result.as_value() == 0 : (int64_t)false;
 }
 
@@ -506 +515 @@
   ADD_ANY_LIST("less",                  rak::ptr_fn(&apply_less));
   ADD_ANY_LIST("greater",               rak::ptr_fn(&apply_greater));
+  ADD_ANY_LIST("equal",                 rak::ptr_fn(&apply_equal));
 
   // A temporary command for handling stuff until we get proper

trunk/rtorrent/src/core/download.cc

@@ -64 +64 @@
   m_resumeFlags(~uint32_t()) {
 
-  m_connTrackerSucceeded = m_download.signal_tracker_succeeded(sigc::bind(sigc::mem_fun(*this, &Download::receive_tracker_msg), ""));
-  m_connTrackerFailed   = m_download.signal_tracker_failed(sigc::mem_fun(*this, &Download::receive_tracker_msg));
-  m_connStorageError    = m_download.signal_storage_error(sigc::mem_fun(*this, &Download::receive_storage_error));
+  m_connTrackerSucceeded = m_download.info()->signal_tracker_success().connect(sigc::bind(sigc::mem_fun(*this, &Download::receive_tracker_msg), ""));
+  m_connTrackerFailed   = m_download.info()->signal_tracker_failed().connect(sigc::mem_fun(*this, &Download::receive_tracker_msg));
+  m_connStorageError    = m_download.info()->signal_storage_error().connect(sigc::mem_fun(*this, &Download::receive_storage_error));
 
-  m_download.signal_chunk_failed(sigc::mem_fun(*this, &Download::receive_chunk_failed));
+  m_download.info()->signal_chunk_failed().connect(sigc::mem_fun(*this, &Download::receive_chunk_failed));
 }
 

trunk/rtorrent/src/core/download_list.cc

@@ -176 +176 @@
 
   try {
-    (*itr)->download()->signal_download_done(sigc::bind(sigc::mem_fun(*this, &DownloadList::received_finished), download));
-    (*itr)->download()->signal_hash_done(sigc::bind(sigc::mem_fun(*this, &DownloadList::hash_done), download));
+    (*itr)->info()->signal_download_done().connect(sigc::bind(sigc::mem_fun(*this, &DownloadList::received_finished), download));
+    (*itr)->info()->signal_initial_hash().connect(sigc::bind(sigc::mem_fun(*this, &DownloadList::hash_done), download));
 
     // This needs to be separated into two different calls to ensure