Changeset 1041

Show
Ignore:
Timestamp:
03/13/08 14:28:17 (2 years ago)
Author:
rakshasa
Message:

* Fixed minor bugs in the display of tracker groups. Patch by Josef
Drexler.

* Cleanup of the CommandMap? class.

Location:
trunk/rtorrent/src
Files:
12 modified

Legend:

Unmodified
Added
Removed

  • trunk/rtorrent/src/command_download.cc

    r1026 r1041  
    332332#define ADD_CD_SLOT(key, function, slot, parm, doc)    \ 
    333333  commandDownloadSlotsItr->set_slot(slot); \ 
    334   rpc::commands.insert_download(key, commandDownloadSlotsItr++, &rpc::CommandSlot<core::Download*>::function, rpc::CommandMap::flag_dont_delete, parm, doc); 
     334  rpc::commands.insert_type(key, commandDownloadSlotsItr++, &rpc::CommandSlot<core::Download*>::function, rpc::CommandMap::flag_dont_delete, parm, doc); 
    335335 
    336336#define ADD_CD_SLOT_PUBLIC(key, function, slot, parm, doc)    \ 
    337337  commandDownloadSlotsItr->set_slot(slot); \ 
    338   rpc::commands.insert_download(key, commandDownloadSlotsItr++, &rpc::CommandSlot<core::Download*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
     338  rpc::commands.insert_type(key, commandDownloadSlotsItr++, &rpc::CommandSlot<core::Download*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
    339339 
    340340#define ADD_CD_VOID(key, slot) \ 

  • trunk/rtorrent/src/command_file.cc

    r1030 r1041  
    100100#define ADD_CF_SLOT(key, function, slot, parm, doc)    \ 
    101101  commandFileSlotsItr->set_slot(slot); \ 
    102   rpc::commands.insert_file(key, commandFileSlotsItr++, &rpc::CommandSlot<torrent::File*>::function, rpc::CommandMap::flag_dont_delete, parm, doc); 
     102  rpc::commands.insert_type(key, commandFileSlotsItr++, &rpc::CommandSlot<torrent::File*>::function, rpc::CommandMap::flag_dont_delete, parm, doc); 
    103103 
    104104#define ADD_CF_SLOT_PUBLIC(key, function, slot, parm, doc)    \ 
    105105  commandFileSlotsItr->set_slot(slot); \ 
    106   rpc::commands.insert_file(key, commandFileSlotsItr++, &rpc::CommandSlot<torrent::File*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
     106  rpc::commands.insert_type(key, commandFileSlotsItr++, &rpc::CommandSlot<torrent::File*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
    107107 
    108108#define ADD_CF_VOID(key, slot) \ 
    … …  
    124124#define ADD_CFI_SLOT_PUBLIC(key, function, slot, parm, doc)    \ 
    125125  commandFileItrSlotsItr->set_slot(slot); \ 
    126   rpc::commands.insert_file_itr(key, commandFileItrSlotsItr++, &rpc::CommandSlot<torrent::FileListIterator*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
     126  rpc::commands.insert_type(key, commandFileItrSlotsItr++, &rpc::CommandSlot<torrent::FileListIterator*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
    127127 
    128128#define ADD_CFI_VOID(key, slot) \ 

  • trunk/rtorrent/src/command_helpers.cc

    r971 r1041  
    105105void 
    106106add_variable(const char* getKey, const char* setKey, const char* defaultSetKey, 
    107              rpc::CommandMap::generic_slot getSlot, rpc::CommandMap::generic_slot setSlot, 
     107             rpc::Command::generic_slot getSlot, rpc::Command::generic_slot setSlot, 
    108108             const torrent::Object& defaultObject) { 
    109109  rpc::CommandVariable* variable = commandVariablesItr++; 
    110110  variable->set_variable(defaultObject); 
    111111 
    112   rpc::commands.insert_generic(getKey, variable, getSlot, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, "i:", ""); 
     112  rpc::commands.insert_type(getKey, variable, getSlot, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, "i:", ""); 
    113113 
    114114  if (setKey) 
    115     rpc::commands.insert_generic(setKey, variable, setSlot, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, "i:", ""); 
     115    rpc::commands.insert_type(setKey, variable, setSlot, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, "i:", ""); 
    116116 
    117117  if (defaultSetKey) 
    118     rpc::commands.insert_generic(defaultSetKey, variable, setSlot, rpc::CommandMap::flag_dont_delete, "i:", ""); 
     118    rpc::commands.insert_type(defaultSetKey, variable, setSlot, rpc::CommandMap::flag_dont_delete, "i:", ""); 
    119119} 

  • trunk/rtorrent/src/command_helpers.h

    r1030 r1041  
    7979void 
    8080add_variable(const char* getKey, const char* setKey, const char* defaultSetKey, 
    81              rpc::CommandMap::generic_slot getSlot, rpc::CommandMap::generic_slot setSlot, 
     81             rpc::Command::generic_slot getSlot, rpc::Command::generic_slot setSlot, 
    8282             const torrent::Object& defaultObject); 
    8383 
    … …  
    9696#define ADD_COMMAND_SLOT(key, function, slot, parm, doc)    \ 
    9797  commandSlotsItr->set_slot(slot); \ 
    98   rpc::commands.insert_generic(key, commandSlotsItr++, &rpc::CommandSlot<void>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
     98  rpc::commands.insert_type(key, commandSlotsItr++, &rpc::CommandSlot<void>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
    9999 
    100100#define ADD_ANY_SLOT(key, function, slot, parm, doc)    \ 
    101101  commandAnySlotsItr->set_slot(slot); \ 
    102   rpc::commands.insert_any(key, commandAnySlotsItr++, &rpc::CommandSlot<rpc::target_type>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
     102  rpc::commands.insert_type(key, commandAnySlotsItr++, &rpc::CommandSlot<rpc::target_type>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
    103103 
    104104#define ADD_COMMAND_SLOT_PRIVATE(key, function, slot) \ 
    105105  commandSlotsItr->set_slot(slot); \ 
    106   rpc::commands.insert_generic(key, commandSlotsItr++, &rpc::CommandSlot<void>::function, rpc::CommandMap::flag_dont_delete, NULL, NULL); 
     106  rpc::commands.insert_type(key, commandSlotsItr++, &rpc::CommandSlot<void>::function, rpc::CommandMap::flag_dont_delete, NULL, NULL); 
    107107 
    108108#define ADD_COMMAND_COPY(key, function, parm, doc) \ 
    109   rpc::commands.insert_generic(key, (commandSlotsItr - 1), &rpc::CommandSlot<void>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
     109  rpc::commands.insert_type(key, (commandSlotsItr - 1), &rpc::CommandSlot<void>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
    110110 
    111111#define ADD_COMMAND_COPY_PRIVATE(key, function) \ 
    112   rpc::commands.insert_generic(key, (commandSlotsItr - 1), &rpc::CommandSlot<void>::function, rpc::CommandMap::flag_dont_delete, NULL, NULL); 
     112  rpc::commands.insert_type(key, (commandSlotsItr - 1), &rpc::CommandSlot<void>::function, rpc::CommandMap::flag_dont_delete, NULL, NULL); 
    113113 
    114114#define ADD_COMMAND_VALUE_TRI(key, set, get) \ 

  • trunk/rtorrent/src/command_peer.cc

    r1032 r1041  
    9797#define ADD_CP_SLOT(key, function, slot, parm, doc)    \ 
    9898  commandPeerSlotsItr->set_slot(slot); \ 
    99   rpc::commands.insert_peer(key, commandPeerSlotsItr++, &rpc::CommandSlot<torrent::Peer*>::function, rpc::CommandMap::flag_dont_delete, parm, doc); 
     99  rpc::commands.insert_type(key, commandPeerSlotsItr++, &rpc::CommandSlot<torrent::Peer*>::function, rpc::CommandMap::flag_dont_delete, parm, doc); 
    100100 
    101101#define ADD_CP_SLOT_PUBLIC(key, function, slot, parm, doc)    \ 
    102102  commandPeerSlotsItr->set_slot(slot); \ 
    103   rpc::commands.insert_peer(key, commandPeerSlotsItr++, &rpc::CommandSlot<torrent::Peer*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
     103  rpc::commands.insert_type(key, commandPeerSlotsItr++, &rpc::CommandSlot<torrent::Peer*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
    104104 
    105105#define ADD_CP_VOID(key, slot) \ 

  • trunk/rtorrent/src/command_tracker.cc

    r1002 r1041  
    5656#define ADD_CT_SLOT(key, function, slot, parm, doc)    \ 
    5757  commandTrackerSlotsItr->set_slot(slot); \ 
    58   rpc::commands.insert_tracker(key, commandTrackerSlotsItr++, &rpc::CommandSlot<torrent::Tracker*>::function, rpc::CommandMap::flag_dont_delete, parm, doc); 
     58  rpc::commands.insert_type(key, commandTrackerSlotsItr++, &rpc::CommandSlot<torrent::Tracker*>::function, rpc::CommandMap::flag_dont_delete, parm, doc); 
    5959 
    6060#define ADD_CT_SLOT_PUBLIC(key, function, slot, parm, doc)    \ 
    6161  commandTrackerSlotsItr->set_slot(slot); \ 
    62   rpc::commands.insert_tracker(key, commandTrackerSlotsItr++, &rpc::CommandSlot<torrent::Tracker*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
     62  rpc::commands.insert_type(key, commandTrackerSlotsItr++, &rpc::CommandSlot<torrent::Tracker*>::function, rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_xmlrpc, parm, doc); 
    6363 
    6464#define ADD_CT_VOID(key, slot) \ 

  • trunk/rtorrent/src/core/view.h

    r938 r1041  
    121121  void                set_filter_on(int event); 
    122122 
     123  void                set_cfilter(const std::string& s)        { m_cfilter = s; } 
     124 
    123125  void                clear_filter_on(); 
    124126 
    … …  
    163165  filter_list         m_filter; 
    164166 
     167  std::string         m_cfilter; 
     168 
    165169  rak::timer          m_lastChanged; 
    166170  signal_type         m_signalChanged; 

  • trunk/rtorrent/src/display/window_tracker_list.cc

    r1013 r1041  
    6161  m_canvas->erase(); 
    6262 
    63   int pos = 0; 
     63  unsigned int pos = 0; 
    6464  torrent::TrackerList* tl = m_download->tracker_list(); 
    6565 
    … …  
    7272  typedef std::pair<unsigned int, unsigned int> Range; 
    7373 
    74   unsigned int group = 0; 
    75   Range range = rak::advance_bidirectional<unsigned int>(0, *m_focus, tl->size(), (m_canvas->height() + 1) / 2); 
     74  Range range = rak::advance_bidirectional<unsigned int>(0, *m_focus, tl->size(), (m_canvas->height() - 1) / 2); 
     75  unsigned int group = tl->at(range.first)->group(); 
    7676 
    7777  while (range.first != range.second) { 
    … …  
    8989                    tracker->url().c_str()); 
    9090 
    91     m_canvas->print(4, pos++, "Id: %s Focus: %s Enabled: %s Open: %s S/L: %u/%u", 
    92                     rak::copy_escape_html(tracker->tracker_id()).c_str(), 
    93                     range.first == tl->focus_index() ? "yes" : " no", 
    94                     tracker->is_usable() ? "yes" : tracker->is_enabled() ? "off" : " no", 
    95                     tracker->is_busy() ? "yes" : " no", 
    96                     tracker->scrape_complete(), 
    97                     tracker->scrape_incomplete()); 
     91    if (pos < m_canvas->height()) 
     92      m_canvas->print(4, pos++, "Id: %s Focus: %s Enabled: %s Open: %s S/L: %u/%u", 
     93                      rak::copy_escape_html(tracker->tracker_id()).c_str(), 
     94                      range.first == tl->focus_index() ? "yes" : " no", 
     95                      tracker->is_usable() ? "yes" : tracker->is_enabled() ? "off" : " no", 
     96                      tracker->is_busy() ? "yes" : " no", 
     97                      tracker->scrape_complete(), 
     98                      tracker->scrape_incomplete()); 
    9899 
    99100//     m_canvas->print(4, pos++, "Id: %s Focus: %s Enabled: %s Open: %s Timer: %u/%u", 
    … …  
    111112 
    112113    range.first++; 
     114 
     115    // If we're at the end of the range, check if we can 
     116    // show one more line for the following tracker. 
     117    if (range.first == range.second && pos < m_canvas->height() && range.first < tl->size()) 
     118      range.second++; 
    113119  } 
    114120} 

  • trunk/rtorrent/src/rpc/command.h

    r970 r1041  
    4040#include <torrent/object.h> 
    4141 
     42namespace core { 
     43  class Download; 
     44} 
     45 
     46namespace torrent { 
     47  class File; 
     48  class FileListIterator; 
     49  class Peer; 
     50  class Tracker; 
     51} 
     52 
    4253namespace rpc { 
     54 
     55// Since c++0x isn't out yet... 
     56template <typename T1, typename T2, typename T3> 
     57struct rt_triple : private std::pair<T1, T2> { 
     58  typedef std::pair<T1, T2> base_type; 
     59  typedef T3                third_type; 
     60 
     61  using base_type::first; 
     62  using base_type::second; 
     63  using base_type::first_type; 
     64  using base_type::second_type; 
     65 
     66  T3 third; 
     67 
     68  rt_triple() : base_type(), third() {} 
     69 
     70  rt_triple(const T1& a, const T2& b) : 
     71    base_type(a, b), third() {} 
     72 
     73  rt_triple(const T1& a, const T2& b, const T3& c) : 
     74    base_type(a, b), third(c) {} 
     75 
     76  template <typename U1, typename U2> 
     77  rt_triple(const std::pair<U1, U2>& b) : base_type(b), third() {} 
     78 
     79  template <typename U1, typename U2, typename U3> 
     80  rt_triple(const rt_triple& src) : 
     81    base_type(src.first, src.second), third(src.third) {} 
     82}; 
    4383 
    4484// Since it gets used so many places we might as well put it in the 
    4585// rpc namespace. 
    46 typedef std::pair<int, void*> target_type; 
     86//typedef std::pair<int, void*> target_type; 
     87typedef rt_triple<int, void*, void*> target_type; 
    4788 
    4889class Command { 
    … …  
    5495  typedef torrent::Object::key_type    key_type; 
    5596 
     97  typedef const torrent::Object (*generic_slot)  (Command*, const torrent::Object&); 
     98  typedef const torrent::Object (*any_slot)      (Command*, target_type, const torrent::Object&); 
     99  typedef const torrent::Object (*download_slot) (Command*, core::Download*, const torrent::Object&); 
     100  typedef const torrent::Object (*file_slot)     (Command*, torrent::File*, const torrent::Object&); 
     101  typedef const torrent::Object (*file_itr_slot) (Command*, torrent::FileListIterator*, const torrent::Object&); 
     102  typedef const torrent::Object (*peer_slot)     (Command*, torrent::Peer*, const torrent::Object&); 
     103  typedef const torrent::Object (*tracker_slot)  (Command*, torrent::Tracker*, const torrent::Object&); 
     104 
     105  static const int target_generic  = 0; 
     106  static const int target_any      = 1; 
     107  static const int target_download = 2; 
     108  static const int target_peer     = 3; 
     109  static const int target_tracker  = 4; 
     110  static const int target_file     = 5; 
     111  static const int target_file_itr = 6; 
     112 
    56113  Command() {} 
    57114  virtual ~Command() {} 
    … …  
    62119}; 
    63120 
     121template <typename T> 
     122struct target_type_id { 
     123  // Nothing here, so we cause an error. 
     124}; 
     125 
     126template <> struct target_type_id<Command::generic_slot>  { static const int value = Command::target_generic; }; 
     127template <> struct target_type_id<Command::any_slot>      { static const int value = Command::target_any; }; 
     128template <> struct target_type_id<Command::download_slot> { static const int value = Command::target_download; }; 
     129template <> struct target_type_id<Command::peer_slot>     { static const int value = Command::target_peer; }; 
     130template <> struct target_type_id<Command::tracker_slot>  { static const int value = Command::target_tracker; }; 
     131template <> struct target_type_id<Command::file_slot>     { static const int value = Command::target_file; }; 
     132template <> struct target_type_id<Command::file_itr_slot> { static const int value = Command::target_file_itr; }; 
     133 
    64134} 
    65135 

  • trunk/rtorrent/src/rpc/command_map.cc

    r1006 r1041  
    6262} 
    6363 
    64 // The functions below should be reduced to just one. 
    65 void 
    66 CommandMap::insert_generic(key_type key, Command* variable, generic_slot targetSlot, int flags, const char* parm, const char* doc) { 
    67   iterator itr = insert(key, variable, flags, parm, doc); 
    68  
    69   itr->second.m_target      = target_generic; 
    70   itr->second.m_genericSlot = targetSlot; 
    71 } 
    72  
    73 void 
    74 CommandMap::insert_any(key_type key, Command* variable, any_slot targetSlot, int flags, const char* parm, const char* doc) { 
    75   iterator itr = insert(key, variable, flags, parm, doc); 
    76  
    77   itr->second.m_target  = target_any; 
    78   itr->second.m_anySlot = targetSlot; 
    79 } 
    80  
    81 void 
    82 CommandMap::insert_download(key_type key, Command* variable, download_slot targetSlot, int flags, const char* parm, const char* doc) { 
    83   iterator itr = insert(key, variable, flags, parm, doc); 
    84  
    85   itr->second.m_target       = target_download; 
    86   itr->second.m_downloadSlot = targetSlot; 
    87 } 
    88  
    89 void 
    90 CommandMap::insert_peer(key_type key, Command* variable, peer_slot targetSlot, int flags, const char* parm, const char* doc) { 
    91   iterator itr = insert(key, variable, flags, parm, doc); 
    92  
    93   itr->second.m_target   = target_peer; 
    94   itr->second.m_peerSlot = targetSlot; 
    95 } 
    96  
    97 void 
    98 CommandMap::insert_tracker(key_type key, Command* variable, tracker_slot targetSlot, int flags, const char* parm, const char* doc) { 
    99   iterator itr = insert(key, variable, flags, parm, doc); 
    100  
    101   itr->second.m_target      = target_tracker; 
    102   itr->second.m_trackerSlot = targetSlot; 
    103 } 
    104  
    105 void 
    106 CommandMap::insert_file(key_type key, Command* variable, file_slot targetSlot, int flags, const char* parm, const char* doc) { 
    107   iterator itr = insert(key, variable, flags, parm, doc); 
    108  
    109   itr->second.m_target   = target_file; 
    110   itr->second.m_fileSlot = targetSlot; 
    111 } 
    112  
    113 void 
    114 CommandMap::insert_file_itr(key_type key, Command* variable, file_itr_slot targetSlot, int flags, const char* parm, const char* doc) { 
    115   iterator itr = insert(key, variable, flags, parm, doc); 
    116  
    117   itr->second.m_target      = target_file_itr; 
    118   itr->second.m_fileItrSlot = targetSlot; 
    119 } 
    120  
    12164void 
    12265CommandMap::insert(key_type key, const command_map_data_type src) { 
    … …  
    13275  // This _should_ be optimized int just one assignment. 
    13376  switch (itr->second.m_target) { 
    134   case target_generic:  itr->second.m_genericSlot  = src.m_genericSlot; break; 
    135   case target_any:      itr->second.m_anySlot      = src.m_anySlot; break; 
    136   case target_download: itr->second.m_downloadSlot = src.m_downloadSlot; break; 
    137   case target_file:     itr->second.m_fileSlot     = src.m_fileSlot; break; 
    138   case target_file_itr: itr->second.m_fileItrSlot  = src.m_fileItrSlot; break; 
    139   case target_peer:     itr->second.m_peerSlot     = src.m_peerSlot; break; 
    140   case target_tracker:  itr->second.m_trackerSlot  = src.m_trackerSlot; break; 
     77  case Command::target_generic:  itr->second.m_genericSlot  = src.m_genericSlot; break; 
     78  case Command::target_any:      itr->second.m_anySlot      = src.m_anySlot; break; 
     79  case Command::target_download: itr->second.m_downloadSlot = src.m_downloadSlot; break; 
     80  case Command::target_file:     itr->second.m_fileSlot     = src.m_fileSlot; break; 
     81  case Command::target_file_itr: itr->second.m_fileItrSlot  = src.m_fileItrSlot; break; 
     82  case Command::target_peer:     itr->second.m_peerSlot     = src.m_peerSlot; break; 
     83  case Command::target_tracker:  itr->second.m_trackerSlot  = src.m_trackerSlot; break; 
    14184  default: throw torrent::internal_error("CommandMap::insert(...) Invalid target."); 
    14285  } 
    … …  
    15093    throw torrent::input_error("Command \"" + std::string(key) + "\" does not exist."); 
    15194 
    152   if (target.first != target_generic && target.second == NULL) { 
     95  if (target.first != Command::target_generic && target.second == NULL) { 
    15396    // We received a target that is NULL, so throw an exception unless 
    15497    // we can convert it to a void target. 
    155     if (itr->second.m_target > target_any) 
     98    if (itr->second.m_target > Command::target_any) 
    15699      throw torrent::input_error("Command type mis-match."); 
    157100 
    158     target.first = target_generic; 
     101    target.first = Command::target_generic; 
    159102  } 
    160103 
    161   if (itr->second.m_target != target.first && itr->second.m_target > target_any) { 
     104  if (itr->second.m_target != target.first && itr->second.m_target > Command::target_any) { 
    162105    // Mismatch between the target and command type. If it is not 
    163106    // possible to convert, then throw an input error. 
    164     if (target.first == target_file_itr && itr->second.m_target == target_file) 
    165       target = target_type((int)target_file, static_cast<torrent::FileListIterator*>(target.second)->file()); 
     107    if (target.first == Command::target_file_itr && itr->second.m_target == Command::target_file) 
     108      target = target_type((int)Command::target_file, static_cast<torrent::FileListIterator*>(target.second)->file()); 
    166109    else 
    167110      throw torrent::input_error("Command type mis-match."); 
    … …  
    170113  // This _should_ be optimized int just two calls. 
    171114  switch (itr->second.m_target) { 
    172   case target_generic:  return itr->second.m_genericSlot (itr->second.m_variable, arg); 
    173   case target_any:      return itr->second.m_anySlot     (itr->second.m_variable, target, arg); 
    174   case target_download: return itr->second.m_downloadSlot(itr->second.m_variable, (core::Download*)target.second, arg); 
    175   case target_peer:     return itr->second.m_peerSlot    (itr->second.m_variable, (torrent::Peer*)target.second, arg); 
    176   case target_tracker:  return itr->second.m_trackerSlot (itr->second.m_variable, (torrent::Tracker*)target.second, arg); 
    177   case target_file:     return itr->second.m_fileSlot    (itr->second.m_variable, (torrent::File*)target.second, arg); 
    178   case target_file_itr: return itr->second.m_fileItrSlot (itr->second.m_variable, (torrent::FileListIterator*)target.second, arg); 
     115  case Command::target_generic:  return itr->second.m_genericSlot (itr->second.m_variable, arg); 
     116  case Command::target_any:      return itr->second.m_anySlot     (itr->second.m_variable, target, arg); 
     117  case Command::target_download: return itr->second.m_downloadSlot(itr->second.m_variable, (core::Download*)target.second, arg); 
     118  case Command::target_peer:     return itr->second.m_peerSlot    (itr->second.m_variable, (torrent::Peer*)target.second, arg); 
     119  case Command::target_tracker:  return itr->second.m_trackerSlot (itr->second.m_variable, (torrent::Tracker*)target.second, arg); 
     120  case Command::target_file:     return itr->second.m_fileSlot    (itr->second.m_variable, (torrent::File*)target.second, arg); 
     121  case Command::target_file_itr: return itr->second.m_fileItrSlot (itr->second.m_variable, (torrent::FileListIterator*)target.second, arg); 
    179122  default: throw torrent::internal_error("CommandMap::call_command(...) Invalid target."); 
    180123  } 
    … …  
    183126const CommandMap::mapped_type 
    184127CommandMap::call_command(const_iterator itr, const mapped_type& arg, target_type target) { 
    185   if (target.first != target_generic && target.second == NULL) { 
     128  if (target.first != Command::target_generic && target.second == NULL) { 
    186129    // We received a target that is NULL, so throw an exception unless 
    187130    // we can convert it to a void target. 
    188     if (itr->second.m_target > target_any) 
     131    if (itr->second.m_target > Command::target_any) 
    189132      throw torrent::input_error("Command type mis-match."); 
    190133 
    191     target.first = target_generic; 
     134    target.first = Command::target_generic; 
    192135  } 
    193136 
    194   if (itr->second.m_target != target.first && itr->second.m_target > target_any) 
     137  if (itr->second.m_target != target.first && itr->second.m_target > Command::target_any) 
    195138    throw torrent::input_error("Command type mis-match."); 
    196139 
    197140  // This _should_ be optimized int just two calls. 
    198141  switch (itr->second.m_target) { 
    199   case target_generic:  return itr->second.m_genericSlot (itr->second.m_variable, arg); 
    200   case target_any:      return itr->second.m_anySlot     (itr->second.m_variable, target, arg); 
    201   case target_download: return itr->second.m_downloadSlot(itr->second.m_variable, (core::Download*)target.second, arg); 
    202   case target_peer:     return itr->second.m_peerSlot    (itr->second.m_variable, (torrent::Peer*)target.second, arg); 
    203   case target_tracker:  return itr->second.m_trackerSlot (itr->second.m_variable, (torrent::Tracker*)target.second, arg); 
    204   case target_file:     return itr->second.m_fileSlot    (itr->second.m_variable, (torrent::File*)target.second, arg); 
    205   case target_file_itr: return itr->second.m_fileItrSlot (itr->second.m_variable, (torrent::FileListIterator*)target.second, arg); 
     142  case Command::target_generic:  return itr->second.m_genericSlot (itr->second.m_variable, arg); 
     143  case Command::target_any:      return itr->second.m_anySlot     (itr->second.m_variable, target, arg); 
     144  case Command::target_download: return itr->second.m_downloadSlot(itr->second.m_variable, (core::Download*)target.second, arg); 
     145  case Command::target_peer:     return itr->second.m_peerSlot    (itr->second.m_variable, (torrent::Peer*)target.second, arg); 
     146  case Command::target_tracker:  return itr->second.m_trackerSlot (itr->second.m_variable, (torrent::Tracker*)target.second, arg); 
     147  case Command::target_file:     return itr->second.m_fileSlot    (itr->second.m_variable, (torrent::File*)target.second, arg); 
     148  case Command::target_file_itr: return itr->second.m_fileItrSlot (itr->second.m_variable, (torrent::FileListIterator*)target.second, arg); 
    206149  default: throw torrent::internal_error("CommandMap::call_command(...) Invalid target."); 
    207150  } 

  • trunk/rtorrent/src/rpc/command_map.h

    r970 r1041  
    4545#include "command.h" 
    4646 
    47 namespace core { 
    48   class Download; 
    49 } 
    50  
    51 namespace torrent { 
    52   class File; 
    53   class FileListIterator; 
    54   class Peer; 
    55   class Tracker; 
    56 } 
    57  
    5847namespace rpc { 
    5948 
    … …  
    6857  // 
    6958  // The any_slot should perhaps replace generic_slot? 
    70   typedef const torrent::Object (*generic_slot)  (Command*, const torrent::Object&); 
    71   typedef const torrent::Object (*any_slot)      (Command*, target_type, const torrent::Object&); 
    72   typedef const torrent::Object (*download_slot) (Command*, core::Download*, const torrent::Object&); 
    73   typedef const torrent::Object (*file_slot)     (Command*, torrent::File*, const torrent::Object&); 
    74   typedef const torrent::Object (*file_itr_slot) (Command*, torrent::FileListIterator*, const torrent::Object&); 
    75   typedef const torrent::Object (*peer_slot)     (Command*, torrent::Peer*, const torrent::Object&); 
    76   typedef const torrent::Object (*tracker_slot)  (Command*, torrent::Tracker*, const torrent::Object&); 
    7759 
    7860  command_map_data_type(Command* variable, int flags, const char* parm, const char* doc) : 
    … …  
    8466 
    8567  union { 
    86     generic_slot  m_genericSlot; 
    87     any_slot      m_anySlot; 
    88     download_slot m_downloadSlot; 
    89     file_slot     m_fileSlot; 
    90     file_itr_slot m_fileItrSlot; 
    91     peer_slot     m_peerSlot; 
    92     tracker_slot  m_trackerSlot; 
     68    Command::generic_slot  m_genericSlot; 
     69    Command::any_slot      m_anySlot; 
     70    Command::download_slot m_downloadSlot; 
     71    Command::file_slot     m_fileSlot; 
     72    Command::file_itr_slot m_fileItrSlot; 
     73    Command::peer_slot     m_peerSlot; 
     74    Command::tracker_slot  m_trackerSlot; 
    9375  }; 
    9476 
    … …  
    10486  typedef std::map<const char*, command_map_data_type, command_map_comp> base_type; 
    10587 
    106   typedef command_map_data_type::generic_slot  generic_slot; 
    107   typedef command_map_data_type::any_slot      any_slot; 
    108   typedef command_map_data_type::download_slot download_slot; 
    109   typedef command_map_data_type::file_slot     file_slot; 
    110   typedef command_map_data_type::file_itr_slot file_itr_slot; 
    111   typedef command_map_data_type::peer_slot     peer_slot; 
    112   typedef command_map_data_type::tracker_slot  tracker_slot; 
    113  
    11488  typedef torrent::Object         mapped_type; 
    11589  typedef mapped_type::value_type mapped_value_type; 
    … …  
    12498  using base_type::find; 
    12599 
    126   static const int target_generic  = 0; 
    127   static const int target_any      = 1; 
    128   static const int target_download = 2; 
    129   static const int target_peer     = 3; 
    130   static const int target_tracker  = 4; 
    131   static const int target_file     = 5; 
    132   static const int target_file_itr = 6; 
    133  
    134100  static const int flag_dont_delete   = 0x1; 
    135101  static const int flag_public_xmlrpc = 0x2; 
    … …  
    143109  iterator            insert(key_type key, Command* variable, int flags, const char* parm, const char* doc); 
    144110 
    145   void                insert_generic (key_type key, Command* variable, generic_slot targetSlot,  int flags, const char* parm, const char* doc); 
    146   void                insert_any     (key_type key, Command* variable, any_slot     targetSlot,  int flags, const char* parm, const char* doc); 
    147   void                insert_download(key_type key, Command* variable, download_slot targetSlot, int flags, const char* parm, const char* doc); 
    148   void                insert_peer    (key_type key, Command* variable, peer_slot targetSlot,     int flags, const char* parm, const char* doc); 
    149   void                insert_tracker (key_type key, Command* variable, tracker_slot targetSlot,  int flags, const char* parm, const char* doc); 
    150   void                insert_file    (key_type key, Command* variable, file_slot targetSlot,     int flags, const char* parm, const char* doc); 
    151   void                insert_file_itr(key_type key, Command* variable, file_itr_slot targetSlot, int flags, const char* parm, const char* doc); 
     111  template <typename T> 
     112  void                insert_type(key_type key, Command* variable, T targetSlot, int flags, const char* parm, const char* doc) { 
     113    iterator itr = insert(key, variable, flags, parm, doc); 
     114 
     115    itr->second.m_target      = target_type_id<T>::value;  
     116    itr->second.m_genericSlot = (Command::generic_slot)targetSlot; 
     117  } 
    152118 
    153119  void                insert(key_type key, const command_map_data_type src); 
    154120 
    155   const mapped_type   call_command  (key_type key,       const mapped_type& arg, target_type target = target_type((int)target_generic, NULL)); 
    156   const mapped_type   call_command  (const_iterator itr, const mapped_type& arg, target_type target = target_type((int)target_generic, NULL)); 
     121  const mapped_type   call_command  (key_type key,       const mapped_type& arg, target_type target = target_type((int)Command::target_generic, NULL)); 
     122  const mapped_type   call_command  (const_iterator itr, const mapped_type& arg, target_type target = target_type((int)Command::target_generic, NULL)); 
    157123 
    158   const mapped_type   call_command_d(key_type key, core::Download* download, const mapped_type& arg)  { return call_command(key, arg, target_type((int)target_download, download)); } 
    159   const mapped_type   call_command_p(key_type key, torrent::Peer* peer, const mapped_type& arg)       { return call_command(key, arg, target_type((int)target_peer, peer)); } 
    160   const mapped_type   call_command_t(key_type key, torrent::Tracker* tracker, const mapped_type& arg) { return call_command(key, arg, target_type((int)target_tracker, tracker)); } 
    161   const mapped_type   call_command_f(key_type key, torrent::File* file, const mapped_type& arg)       { return call_command(key, arg, target_type((int)target_file, file)); } 
     124  const mapped_type   call_command_d(key_type key, core::Download* download, const mapped_type& arg)  { return call_command(key, arg, target_type((int)Command::target_download, download)); } 
     125  const mapped_type   call_command_p(key_type key, torrent::Peer* peer, const mapped_type& arg)       { return call_command(key, arg, target_type((int)Command::target_peer, peer)); } 
     126  const mapped_type   call_command_t(key_type key, torrent::Tracker* tracker, const mapped_type& arg) { return call_command(key, arg, target_type((int)Command::target_tracker, tracker)); } 
     127  const mapped_type   call_command_f(key_type key, torrent::File* file, const mapped_type& arg)       { return call_command(key, arg, target_type((int)Command::target_file, file)); } 
    162128 
    163129private: 
    … …  
    166132}; 
    167133 
    168 inline target_type make_target()                                  { return target_type((int)CommandMap::target_generic, NULL); } 
    169 inline target_type make_target(core::Download* target)            { return target_type((int)CommandMap::target_download, target); } 
    170 inline target_type make_target(torrent::Peer* target)             { return target_type((int)CommandMap::target_peer, target); } 
    171 inline target_type make_target(torrent::Tracker* target)          { return target_type((int)CommandMap::target_tracker, target); } 
    172 inline target_type make_target(torrent::File* target)             { return target_type((int)CommandMap::target_file, target); } 
    173 inline target_type make_target(torrent::FileListIterator* target) { return target_type((int)CommandMap::target_file_itr, target); } 
     134inline target_type make_target()                                  { return target_type((int)Command::target_generic, NULL); } 
     135inline target_type make_target(core::Download* target)            { return target_type((int)Command::target_download, target); } 
     136inline target_type make_target(torrent::Peer* target)             { return target_type((int)Command::target_peer, target); } 
     137inline target_type make_target(torrent::Tracker* target)          { return target_type((int)Command::target_tracker, target); } 
     138inline target_type make_target(torrent::File* target)             { return target_type((int)Command::target_file, target); } 
     139inline target_type make_target(torrent::FileListIterator* target) { return target_type((int)Command::target_file_itr, target); } 
    174140inline target_type make_target(int type, void* target)            { return target_type(type, target); } 
    175141 

  • trunk/rtorrent/src/rpc/command_slot.h

    r976 r1041  
    8181 
    8282  template <int base, int unit> 
    83   static const torrent::Object call_value(Command* rawCommand, Target target, const torrent::Object& args)     { return call_value_base(rawCommand, target, args, base, unit); } 
     83  static const torrent::Object call_value_tmpl(Command* rawCommand, Target target, const torrent::Object& args)     { return call_value_base(rawCommand, target, args, base, unit); } 
    8484 
    8585//   static const torrent::Object& get_list(Command* rawCommand, const torrent::Object& args); 
    … …  
    111111 
    112112  template <int base, int unit> 
    113   static const torrent::Object call_value(Command* rawCommand, const torrent::Object& args)     { return call_value_base(rawCommand, args, base, unit); } 
     113  static const torrent::Object call_value_tmpl(Command* rawCommand, const torrent::Object& args)     { return call_value_base(rawCommand, args, base, unit); } 
    114114 
    115115//   static const torrent::Object& get_list(Command* rawCommand, const torrent::Object& args);