Ignore:
Timestamp:
12/26/08 21:23:19 (11 years ago)
Author:
Eoin
Message:

Peer list sorting fixed and so more naming conventions consistency work.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/halTorrent.cpp

    r656 r659  
    3535} 
    3636 
    37 const PeerDetails& torrent_details::peerDetails() const 
    38 { 
    39         if (!peerDetailsFilled_) 
     37const peer_details_vec& torrent_details::get_peer_details() const 
     38{ 
     39        if (!peer_details_filled_) 
    4040        { 
    41                 bittorrent().get_all_peer_details(hal::to_utf8(name_), peerDetails_); 
    42                 peerDetailsFilled_ = true; 
     41                bittorrent().get_all_peer_details(hal::to_utf8(name_), peer_details_); 
     42                peer_details_filled_ = true; 
    4343        } 
    4444         
    45         return peerDetails_; 
    46 } 
    47  
    48 const FileDetails& torrent_details::fileDetails() const 
    49 { 
    50         if (!fileDetailsFilled_) 
     45        return peer_details_; 
     46} 
     47 
     48const FileDetails& torrent_details::file_details() const 
     49{ 
     50        if (!file_details_filled_) 
    5151        { 
    52                 bittorrent().get_all_file_details(hal::to_utf8(name_), fileDetails_); 
    53                 fileDetailsFilled_ = true; 
     52                bittorrent().get_all_file_details(hal::to_utf8(name_), file_details_); 
     53                file_details_filled_ = true; 
    5454        } 
    5555         
    56         return fileDetails_; 
    57 } 
    58  
    59 bool nameLess(const torrent_details_ptr& left, const torrent_details_ptr& right) 
     56        return file_details_; 
     57} 
     58 
     59/*bool nameLess(const torrent_details_ptr& left, const torrent_details_ptr& right) 
    6060{ 
    6161        return left->state() < right->state(); 
    6262} 
    63  
     63*/ 
    6464bool torrent_details::less(const torrent_details& r, size_t index) const 
    6565{ 
     
    7676        case remaining_e:  
    7777                { 
    78                 boost::int64_t left = totalWanted_-totalWantedDone_; 
    79                 boost::int64_t right = r.totalWanted_-r.totalWantedDone_; 
     78                boost::int64_t left = total_wanted_-total_wanted_done_; 
     79                boost::int64_t right = r.total_wanted_-r.total_wanted_done_; 
    8080 
    8181                return left < right; 
    8282                } 
    8383 
    84         case total_wanted_e: return totalWanted_ < r.totalWanted_; 
    85         case completed_e: return totalWantedDone_ < r.totalWantedDone_;  
    86  
    87         case uploaded_e: return totalPayloadUploaded_ < r.totalPayloadUploaded_; 
    88         case downloaded_e: return totalPayloadDownloaded_ < r.totalPayloadDownloaded_; 
     84        case total_wanted_e: return total_wanted_ < r.total_wanted_; 
     85        case completed_e: return total_wanted_done_ < r.total_wanted_done_;  
     86 
     87        case uploaded_e: return total_payload_uploaded_ < r.total_payload_uploaded_; 
     88        case downloaded_e: return total_payload_downloaded_ < r.total_payload_downloaded_; 
    8989 
    9090        case peers_e: return peers_ < r.peers_; 
     
    9393        case ratio_e:  
    9494                { 
    95                 float left = (totalPayloadDownloaded_)  
    96                                 ? static_cast<float>(totalPayloadUploaded_) 
    97                                         / static_cast<float>(totalPayloadDownloaded_) 
     95                float left = (total_payload_downloaded_)  
     96                                ? static_cast<float>(total_payload_uploaded_) 
     97                                        / static_cast<float>(total_payload_downloaded_) 
    9898                                : 0; 
    9999                 
    100                 float right = (r.totalPayloadDownloaded_)  
    101                                 ? static_cast<float>(r.totalPayloadUploaded_) 
    102                                         / static_cast<float>(r.totalPayloadDownloaded_) 
     100                float right = (r.total_payload_downloaded_)  
     101                                ? static_cast<float>(r.total_payload_uploaded_) 
     102                                        / static_cast<float>(r.total_payload_downloaded_) 
    103103                                : 0; 
    104104                 
     
    106106                } 
    107107 
    108         case eta_e: return estimatedTimeLeft_ < r.estimatedTimeLeft_; 
     108        case eta_e: return estimated_time_left_ < r.estimated_time_left_; 
    109109        case tracker: return currentTracker_ < r.currentTracker_; 
    110         case update_tracker_in_e: return updateTrackerIn_ < r.updateTrackerIn_; 
     110        case update_tracker_in_e: return update_tracker_in_ < r.update_tracker_in_; 
    111111 
    112112        case active_time_e: return active_ < r.active_; 
    113113        case seeding_time_e: return seeding_ < r.seeding_; 
    114         case start_time_e: return startTime_ < r.startTime_; 
    115         case finish_time_e: return finishTime_ < r.finishTime_; 
     114        case start_time_e: return start_time_ < r.start_time_; 
     115        case finish_time_e: return finish_time_ < r.finish_time_; 
    116116 
    117117        case queue_position_e: return queue_position_ < r.queue_position_; 
     
    145145        case remaining_e:  
    146146                { 
    147                 return (wform(L"%1$.2fMB") % (static_cast<float>(totalWanted_-totalWantedDone_)/(1024*1024))).str();  
    148                 } 
    149  
    150         case completed_e: return (wform(L"%1$.2fMB") % (static_cast<float>(totalWantedDone_)/(1024*1024))).str(); 
     147                return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_-total_wanted_done_)/(1024*1024))).str();  
     148                } 
     149 
     150        case completed_e: return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_done_)/(1024*1024))).str(); 
    151151 
    152152        case total_wanted_e:  
    153153                { 
    154                 return (wform(L"%1$.2fMB") % (static_cast<float>(totalWanted_-totalWantedDone_)/(1024*1024))).str();  
     154                return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_-total_wanted_done_)/(1024*1024))).str();  
    155155                } 
    156156 
    157157        case uploaded_e:  
    158158                { 
    159                 return (wform(L"%1$.2fMB") % (static_cast<float>(totalPayloadUploaded_)/(1024*1024))).str();  
     159                return (wform(L"%1$.2fMB") % (static_cast<float>(total_payload_uploaded_)/(1024*1024))).str();  
    160160                } 
    161161 
    162162        case downloaded_e:  
    163163                { 
    164                 return (wform(L"%1$.2fMB") % (static_cast<float>(totalPayloadDownloaded_)/(1024*1024))).str();  
    165                 } 
    166  
    167         case peers_e: return (wform(L"%1% (%2%)") % connectedPeers_ % peers_).str();  
    168         case seeds_e: return (wform(L"%1% (%2%)") % connectedSeeds_ % seeds_).str();  
     164                return (wform(L"%1$.2fMB") % (static_cast<float>(total_payload_downloaded_)/(1024*1024))).str();  
     165                } 
     166 
     167        case peers_e: return (wform(L"%1% (%2%)") % connected_peers_ % peers_).str();  
     168        case seeds_e: return (wform(L"%1% (%2%)") % connected_seeds_ % seeds_).str();  
    169169 
    170170        case ratio_e:  
    171171                { 
    172                         float ratio = (totalPayloadDownloaded_)  
    173                                 ? static_cast<float>(totalPayloadUploaded_) 
    174                                         / static_cast<float>(totalPayloadDownloaded_) 
     172                        float ratio = (total_payload_downloaded_)  
     173                                ? static_cast<float>(total_payload_uploaded_) 
     174                                        / static_cast<float>(total_payload_downloaded_) 
    175175                                : 0; 
    176176                         
     
    180180        case eta_e:  
    181181                {  
    182                 if (!estimatedTimeLeft_.is_special()) 
     182                if (!estimated_time_left_.is_special()) 
    183183                        return hal::from_utf8( 
    184                                 boost::posix_time::to_simple_string(estimatedTimeLeft_)); 
     184                                boost::posix_time::to_simple_string(estimated_time_left_)); 
    185185                else 
    186186                        return app().res_wstr(HAL_INF);          
     
    191191        case update_tracker_in_e:                
    192192                {  
    193                 if (!updateTrackerIn_.is_special()) 
     193                if (!update_tracker_in_.is_special()) 
    194194                        return from_utf8( 
    195                                 boost::posix_time::to_simple_string(updateTrackerIn_)); 
     195                                boost::posix_time::to_simple_string(update_tracker_in_)); 
    196196                else 
    197197                        return app().res_wstr(HAL_INF);          
     
    218218        case start_time_e:  
    219219                {  
    220                 if (!startTime_.is_special()) 
     220                if (!start_time_.is_special()) 
    221221                        return from_utf8( 
    222                                 boost::posix_time::to_simple_string(startTime_)); 
     222                                boost::posix_time::to_simple_string(start_time_)); 
    223223                else 
    224224                        return app().res_wstr(IDS_NA); 
     
    227227        case finish_time_e:              
    228228                {  
    229                 if (!finishTime_.is_special()) 
     229                if (!finish_time_.is_special()) 
    230230                        return from_utf8( 
    231                                 boost::posix_time::to_simple_string(finishTime_)); 
     231                                boost::posix_time::to_simple_string(finish_time_)); 
    232232                else 
    233233                        return app().res_wstr(IDS_NA);   
     
    242242                } 
    243243 
    244         case managed_e: 
    245                 {  
    246                 if (managed_) 
    247                         return L"Yes"; 
    248                 else 
    249                         return L"No";    
    250                 }        
     244        case managed_e: return managed_ ?  L"Yes" : L"No"; 
    251245 
    252246        default: return L"(Undefined)"; // ??? 
     
    254248} 
    255249 
    256 template<typename torrent_Tptr> 
    257 bool torrent_details_compare(torrent_Tptr l, torrent_Tptr r, size_t index = 0, bool cmp_less = true) 
    258 { 
    259         if (cmp_less) 
    260                 return l->less(*r, index); 
    261         else 
    262                 return r->less(*l, index); 
    263 } 
    264  
    265250void torrent_details_manager::sort(size_t column_index, bool cmp_less) const 
    266251{ 
    267252        std::stable_sort(torrents_.begin(), torrents_.end(),  
    268                 bind(&torrent_details_compare<torrent_details_ptr>, _1, _2, column_index, cmp_less)); 
     253                bind(&hal_details_ptr_compare<torrent_details_ptr>, _1, _2, column_index, cmp_less)); 
    269254} 
    270255 
     
    566551} 
    567552 
    568 PeerDetail::PeerDetail(libt::peer_info& peerInfo) : 
    569         ipAddress(hal::from_utf8_safe(peerInfo.ip.address().to_string())), 
    570         country(L""), 
    571         speed(std::make_pair(peerInfo.payload_down_speed, peerInfo.payload_up_speed)), 
    572         client(hal::from_utf8_safe(peerInfo.client)) 
    573 { 
    574         std::vector<wstring> status_vec; 
    575          
    576 #ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES 
    577         if (peerInfo.country[0] != 0 && peerInfo.country[1] != 0) 
    578                 country = (hal::wform(L"(%1%)") % hal::from_utf8_safe(string(peerInfo.country, 2))).str().c_str(); 
    579 #endif   
    580  
    581         if (peerInfo.flags & libt::peer_info::handshake) 
    582         { 
    583                 status_vec.push_back(app().res_wstr(HAL_PEER_HANDSHAKE)); 
    584         }                
    585         else if (peerInfo.flags & libt::peer_info::connecting) 
    586         { 
    587                 status_vec.push_back(app().res_wstr(HAL_PEER_CONNECTING)); 
    588         } 
    589         else 
    590         { 
    591         #ifndef TORRENT_DISABLE_ENCRYPTION               
    592                 if (peerInfo.flags & libt::peer_info::rc4_encrypted) 
    593                         status_vec.push_back(app().res_wstr(HAL_PEER_RC4_ENCRYPTED));            
    594                 if (peerInfo.flags & libt::peer_info::plaintext_encrypted) 
    595                         status_vec.push_back(app().res_wstr(HAL_PEER_PLAINTEXT_ENCRYPTED)); 
    596         #endif 
    597                  
    598                 if (peerInfo.flags & libt::peer_info::interesting) 
    599                         status_vec.push_back(app().res_wstr(HAL_PEER_INTERESTING));      
    600                 if (peerInfo.flags & libt::peer_info::choked) 
    601                         status_vec.push_back(app().res_wstr(HAL_PEER_CHOKED));   
    602                 if (peerInfo.flags & libt::peer_info::remote_interested) 
    603                         status_vec.push_back(app().res_wstr(HAL_PEER_REMOTE_INTERESTING));       
    604                 if (peerInfo.flags & libt::peer_info::remote_choked) 
    605                         status_vec.push_back(app().res_wstr(HAL_PEER_REMOTE_CHOKED));    
    606                 if (peerInfo.flags & libt::peer_info::supports_extensions) 
    607                         status_vec.push_back(app().res_wstr(HAL_PEER_SUPPORT_EXTENSIONS));       
    608         //      if (peerInfo.flags & libt::peer_info::local_connection)                                         // Not sure whats up here? 
    609         //              status_vec.push_back(app().res_wstr(HAL_PEER_LOCAL_CONNECTION));                         
    610                 if (peerInfo.flags & libt::peer_info::queued) 
    611                         status_vec.push_back(app().res_wstr(HAL_PEER_QUEUED)); 
    612         } 
    613          
    614         seed = (peerInfo.flags & libt::peer_info::seed) ? true : false; 
    615          
    616         if (!status_vec.empty()) status = status_vec[0]; 
    617          
    618         if (status_vec.size() > 1) 
    619         { 
    620                 for (size_t i=1; i<status_vec.size(); ++i) 
    621                 { 
    622                         status += L"; "; 
    623                         status += status_vec[i]; 
    624                 } 
    625         }        
    626 } 
    627  
    628553const cache_details bit::get_cache_details() const 
    629554{ 
     
    631556} 
    632557 
    633 void bit::get_all_peer_details(const std::string& filename, PeerDetails& peerContainer) 
    634 { 
    635         get_all_peer_details(from_utf8_safe(filename), peerContainer); 
    636 } 
    637  
    638 void bit::get_all_peer_details(const std::wstring& filename, PeerDetails& peerContainer) 
    639 { 
    640         try { 
    641          
    642         pimpl()->the_torrents_.get(filename)->get_peer_details(peerContainer); 
     558void bit::get_all_peer_details(const std::string& filename, peer_details_vec& peer_container) 
     559{ 
     560        get_all_peer_details(from_utf8_safe(filename), peer_container); 
     561} 
     562 
     563void bit::get_all_peer_details(const std::wstring& filename, peer_details_vec& peer_container) 
     564{ 
     565        try { 
     566         
     567        pimpl()->the_torrents_.get(filename)->get_peer_details(peer_container); 
    643568         
    644569        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_peer_details") 
    645570} 
    646571 
    647 void bit::get_all_file_details(const std::string& filename, FileDetails& fileDetails) 
    648 { 
    649         get_all_file_details(from_utf8_safe(filename), fileDetails); 
    650 } 
    651  
    652 void bit::get_all_file_details(const std::wstring& filename, FileDetails& fileDetails) 
    653 { 
    654         try { 
    655          
    656         pimpl()->the_torrents_.get(filename)->get_file_details(fileDetails); 
     572void bit::get_all_file_details(const std::string& filename, FileDetails& file_details) 
     573{ 
     574        get_all_file_details(from_utf8_safe(filename), file_details); 
     575} 
     576 
     577void bit::get_all_file_details(const std::wstring& filename, FileDetails& file_details) 
     578{ 
     579        try { 
     580         
     581        pimpl()->the_torrents_.get(filename)->get_file_details(file_details); 
    657582         
    658583        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_file_details") 
Note: See TracChangeset for help on using the changeset viewer.