Changeset 659


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.

Location:
trunk
Files:
2 added
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/sln/Halite/Halite.vcproj

    r655 r659  
    606606                        </File> 
    607607                        <File 
     608                                RelativePath="..\..\src\halPeers.cpp" 
     609                                > 
     610                        </File> 
     611                        <File 
    608612                                RelativePath="..\..\src\halSession.cpp" 
    609613                                > 
     
    12561260                        </File> 
    12571261                        <File 
     1262                                RelativePath="..\..\src\halPeers.hpp" 
     1263                                > 
     1264                        </File> 
     1265                        <File 
    12581266                                RelativePath="..\..\src\halSession.hpp" 
    12591267                                > 
  • trunk/src/Halite.cpp

    r604 r659  
    1616#include <winstl/registry/reg_key.hpp> 
    1717#include <winstl/registry/reg_value.hpp> 
    18  
    19 #include <boost/filesystem/convenience.hpp> 
    2018 
    2119#include "WinAPIMutex.hpp" 
  • trunk/src/HaliteDialog.cpp

    r658 r659  
    162162        if (lock)  
    163163        {                
    164                 peerDetails_ = tD.focusedTorrent()->peerDetails(); 
    165                  
    166                 std::sort(peerDetails_.begin(), peerDetails_.end()); 
     164                peer_details_ = tD.focusedTorrent()->get_peer_details(); 
     165                 
     166                std::sort(peer_details_.begin(), peer_details_.end()); 
    167167                 
    168168                // Wipe details not present 
     
    172172                        GetItemText(i, 0, ip_address.c_array(), MAX_PATH); 
    173173                         
    174                         hal::PeerDetail ip(ip_address.data()); 
    175                         hal::PeerDetails::iterator iter =  
    176                                 std::lower_bound(peerDetails_.begin(), peerDetails_.end(), ip); 
    177                          
    178                         if (iter == peerDetails_.end() || !((*iter) == ip)) 
     174                        hal::peer_detail ip(ip_address.data()); 
     175                        hal::peer_details_vec::iterator iter =  
     176                                std::lower_bound(peer_details_.begin(), peer_details_.end(), ip); 
     177                         
     178                        if (iter == peer_details_.end() || !((*iter) == ip)) 
    179179                        { 
    180180                                DeleteItem(i); 
     
    182182                        else 
    183183                        { 
    184                                 SetItemData(i, std::distance(peerDetails_.begin(), iter)); 
     184                                SetItemData(i, std::distance(peer_details_.begin(), iter)); 
    185185                                ++i; 
    186186                        } 
     
    188188                 
    189189                // Add additional details 
    190                 for (hal::PeerDetails::iterator i=peerDetails_.begin(), e=peerDetails_.end(); 
     190                for (hal::peer_details_vec::iterator i=peer_details_.begin(), e=peer_details_.end(); 
    191191                        i != e; ++i) 
    192192                {                        
    193193                        LV_FINDINFO findInfo;  
    194194                        findInfo.flags = LVFI_STRING; 
    195                         findInfo.psz = const_cast<LPTSTR>((*i).ipAddress.c_str()); 
     195                        findInfo.psz = const_cast<LPTSTR>((*i).ip_address.c_str()); 
    196196                         
    197197                        int itemPos = FindItem(&findInfo, -1); 
    198198                        if (itemPos < 0) 
    199                                 itemPos = AddItem(GetItemCount(), 0, (*i).ipAddress.c_str(), 0); 
    200                          
    201                         SetItemData(itemPos, std::distance(peerDetails_.begin(), i)); 
     199                                itemPos = AddItem(GetItemCount(), 0, (*i).ip_address.c_str(), 0); 
     200                         
     201                        SetItemData(itemPos, std::distance(peer_details_.begin(), i)); 
    202202                         
    203203                        SetItemText(itemPos, 1, (*i).country.c_str()); 
     
    282282                 
    283283                SetDlgItemText(HAL_NAME, torrent->name().c_str()); 
    284                 SetDlgItemText(HAL_TRACKER, torrent->currentTracker().c_str()); 
     284                SetDlgItemText(HAL_TRACKER, torrent->current_tracker().c_str()); 
    285285                SetDlgItemText(HAL_STATUS, torrent->state().c_str()); 
    286286                m_prog.SetPos(static_cast<int>(torrent->completion()*100)); 
    287287                 
    288                 if (!torrent->estimatedTimeLeft().is_special()) 
     288                if (!torrent->estimated_time_left().is_special()) 
    289289                { 
    290290                        SetDlgItemText(HAL_AVAIL, 
    291291                                (hal::from_utf8(boost::posix_time::to_simple_string( 
    292                                         torrent->estimatedTimeLeft())).c_str())); 
     292                                        torrent->estimated_time_left())).c_str())); 
    293293                } 
    294294                else 
     
    299299                SetDlgItemText(HAL_COMPLETE, 
    300300                        (hal::wform(L"%1$.2fmb of %2$.2fmb")  
    301                                 % (static_cast<float>(torrent->totalWantedDone())/(1024*1024)) 
    302                                 % (static_cast<float>(torrent->totalWanted())/(1024*1024)) 
     301                                % (static_cast<float>(torrent->total_wanted_done())/(1024*1024)) 
     302                                % (static_cast<float>(torrent->total_wanted())/(1024*1024)) 
    303303                        ).str().c_str()); 
    304304                 
  • trunk/src/HaliteDialog.hpp

    r651 r659  
    4242                 
    4343        class DialogListView : 
    44                 public CHaliteSortListViewCtrl<DialogListView, const hal::PeerDetail>, 
     44                public CHaliteSortListViewCtrl<DialogListView, const hal::peer_detail>, 
    4545                public hal::IniBase<DialogListView>, 
    4646                private boost::noncopyable 
     
    4949                typedef HaliteDialog::DialogListView thisClass; 
    5050                typedef hal::IniBase<thisClass> iniClass; 
    51                 typedef CHaliteSortListViewCtrl<DialogListView, const hal::PeerDetail> listClass; 
    52                 typedef const hal::PeerDetail pD; 
     51                typedef CHaliteSortListViewCtrl<DialogListView, const hal::peer_detail> listClass; 
     52                typedef const hal::peer_detail pD; 
    5353         
    5454                friend class listClass; 
     
    149149/*              pD CustomItemConversion(LVCompareParam* param, int iSortCol) 
    150150                {                        
    151                         return peerDetails_[param->dwItemData]; 
     151                        return peer_details_[param->dwItemData]; 
    152152                }               */ 
    153153                 
     
    155155                 
    156156        private: 
    157                 hal::PeerDetails peerDetails_; 
     157                hal::peer_details_vec peer_details_; 
    158158        }; 
    159159         
  • trunk/src/advtabs/Files.cpp

    r658 r659  
    112112void FileTreeView::OnMenuPriority(UINT uCode, int nCtrlID, HWND hwndCtrl) 
    113113{        
    114         hal::FileDetails fileDetails; 
     114        hal::FileDetails file_details; 
    115115         
    116116        if (hal::torrent_details_ptr torrent = hal::bittorrent().torrentDetails().focusedTorrent()) 
    117117        { 
    118                 std::copy(torrent->fileDetails().begin(), torrent->fileDetails().end(),  
    119                         std::back_inserter(fileDetails)); 
     118                std::copy(torrent->file_details().begin(), torrent->file_details().end(),  
     119                        std::back_inserter(file_details)); 
    120120        } 
    121121 
     
    138138        std::vector<int> indices; 
    139139         
    140         for (hal::FileDetails::iterator i=fileDetails.begin(), e=fileDetails.end(); 
     140        for (hal::FileDetails::iterator i=file_details.begin(), e=file_details.end(); 
    141141                i != e; ++i) 
    142142        {                        
     
    250250        list_.setFocused(focusedTorrent()); 
    251251         
    252         if (fileLinks_.empty() || !(focusedTorrent() && !focusedTorrent()->fileDetails().empty()))  
     252        if (fileLinks_.empty() || !(focusedTorrent() && !focusedTorrent()->file_details().empty()))  
    253253        { 
    254254                list_.DeleteAllItems(); 
     
    284284                        i != e; ++i) 
    285285                { 
    286                         hal::FileDetail fileD = focusedTorrent()->fileDetails()[(*i).order()]; 
     286                        hal::FileDetail fileD = focusedTorrent()->file_details()[(*i).order()]; 
    287287                         
    288288                        LV_FINDINFO findInfo;  
     
    311311        if (pT) 
    312312        { 
    313                 std::copy(pT->fileDetails().begin(), pT->fileDetails().end(),  
     313                std::copy(pT->file_details().begin(), pT->file_details().end(),  
    314314                        std::back_inserter(fileLinks_)); 
    315315        } 
  • trunk/src/advtabs/Files.hpp

    r651 r659  
    193193/*      dataClass CustomItemConversion(LVCompareParam* param, int iSortCol) 
    194194        {                        
    195                 return focused_->fileDetails()[param->dwItemData]; 
     195                return focused_->file_details()[param->dwItemData]; 
    196196        }               */ 
    197197         
     
    450450        std::vector<FileLink> fileLinks_; 
    451451         
    452         hal::FileDetails fileDetails_; 
     452        hal::FileDetails file_details_; 
    453453        std::pair<std::vector<FileLink>::iterator, std::vector<FileLink>::iterator> range_; 
    454454}; 
  • trunk/src/advtabs/Peers.cpp

    r658 r659  
    1818        if (lock)  
    1919        {                
    20                 peerDetails_.clear(); 
     20                peer_details_.clear(); 
    2121                 
    2222                foreach (const hal::torrent_details_ptr torrent, tD.selectedTorrents()) 
    2323                { 
    24                         std::copy(torrent->peerDetails().begin(), torrent->peerDetails().end(),  
    25                                 std::back_inserter(peerDetails_)); 
     24                        std::copy(torrent->get_peer_details().begin(), torrent->get_peer_details().end(),  
     25                                std::back_inserter(peer_details_)); 
    2626                } 
    2727                 
    28                 std::sort(peerDetails_.begin(), peerDetails_.end()); 
     28                std::sort(peer_details_.begin(), peer_details_.end()); 
    2929                 
    3030                // Wipe details not present 
     
    3434                        GetItemText(i, 0, ip_address.c_array(), MAX_PATH); 
    3535                         
    36                         hal::PeerDetail ip(ip_address.data()); 
    37                         hal::PeerDetails::iterator iter =  
    38                                 std::lower_bound(peerDetails_.begin(), peerDetails_.end(), ip); 
     36                        hal::peer_detail ip(ip_address.data()); 
     37                        hal::peer_details_vec::iterator iter =  
     38                                std::lower_bound(peer_details_.begin(), peer_details_.end(), ip); 
    3939                         
    40                         if (iter == peerDetails_.end() || !((*iter) == ip)) 
     40                        if (iter == peer_details_.end() || !((*iter) == ip)) 
    4141                        { 
    4242                                DeleteItem(i); 
     
    4444                        else 
    4545                        { 
    46                                 SetItemData(i, std::distance(peerDetails_.begin(), iter)); 
     46                                SetItemData(i, std::distance(peer_details_.begin(), iter)); 
    4747                                ++i; 
    4848                        } 
    4949                } 
    50                  
     50                         
    5151                int col_sort_index = GetSortColumn(); 
    5252 
    53                 // Add additional details 
    54                 for (hal::PeerDetails::iterator i=peerDetails_.begin(), e=peerDetails_.end(); 
    55                         i != e; ++i) 
    56                 {                        
    57                         LV_FINDINFO findInfo;  
    58                         findInfo.flags = LVFI_STRING; 
    59                         findInfo.psz = const_cast<LPTSTR>((*i).ipAddress.c_str()); 
     53                if (col_sort_index != -1) 
     54                {                
     55                        int index = GetColumnSortType(col_sort_index); 
    6056                         
    61                         int itemPos = FindItem(&findInfo, -1); 
    62                         if (itemPos < 0) 
    63                                 itemPos = AddItem(GetItemCount(), 0, (*i).ipAddress.c_str(), 0); 
     57                        HAL_DEV_MSG(hal::wform(L"col_sort_index() = %1%, index() = %2%")  
     58                                % col_sort_index % index); 
     59 
     60                        if (index > WTL::LVCOLSORT_LAST) 
     61                                hal::peer_details_sort(peer_details_, index - (WTL::LVCOLSORT_LAST+1+hal::peer_detail::ip_address_e),  
     62                                        IsSortDescending()); 
     63                } 
     64 
     65                bool sort_once = IsSortOnce(); 
     66 
     67                // Add additional details        
     68                for (size_t index = 0, e = peer_details_.size(); index < e; ++index) 
     69                { 
     70                        hal::peer_detail& pd = peer_details_[index]; 
     71                 
     72                        int item_pos = index; 
     73                 
     74                        HAL_DEV_SORT_MSG(hal::wform(L"AutoSort() = %1%, SortOnce() = %2%, !AutoSort() && !SortOnce() = %3%")  
     75                                % AutoSort() % sort_once % (!AutoSort() && !sort_once)); 
     76 
     77                        if (!AutoSort() && !sort_once) 
     78                        { 
     79                                LV_FINDINFO findInfo;  
     80                                findInfo.flags = LVFI_STRING; 
     81                                findInfo.psz = const_cast<LPTSTR>(pd.to_wstring(hal::peer_detail::ip_address_e).c_str()); 
     82                                 
     83                                item_pos = FindItem(&findInfo, -1); 
     84                        } 
     85 
     86                        if (item_pos == -1 || item_pos > GetItemCount()) 
     87                                item_pos = AddItem(GetItemCount(), 0, pd.to_wstring(hal::peer_detail::ip_address_e).c_str(), 0); 
    6488                         
    65                         SetItemData(itemPos, std::distance(peerDetails_.begin(), i)); 
    6689                         
    67                         SetItemText(itemPos, 1, (*i).country.c_str()); 
    68                          
    69                         SetItemText(itemPos, 2, getColumnAdapter(2)->print(*i).c_str()); 
    70                          
    71                         SetItemText(itemPos, 3, getColumnAdapter(3)->print(*i).c_str()); 
    72                          
    73                         if ((*i).seed) 
    74                                 SetItemText(itemPos, 4, L"Seed"); 
    75                          
    76                         SetItemText(itemPos, 5, (*i).client.c_str()); 
    77                          
    78                         SetItemText(itemPos, 6, (*i).status.c_str()); 
     90                        HAL_DEV_SORT_MSG(hal::wform(L"item_pos = %1%") % item_pos); 
     91 
     92                        SetItemData(item_pos, index);                    
     93 
     94                        for (size_t i = 0; i < 7; ++i) 
     95                        { 
     96                                SetItemText(item_pos, i, pd.to_wstring(i).c_str()); 
     97                        } 
    7998                } 
    8099                 
     
    85104                } 
    86105        } 
     106} 
     107 
     108LRESULT PeerListView::OnSortChanged(int, LPNMHDR pnmh, BOOL&) 
     109{ 
     110        halite_window_.issueUiUpdate(); 
     111         
     112        return 0; 
    87113} 
    88114 
  • trunk/src/advtabs/Peers.hpp

    r651 r659  
    1818 
    1919class PeerListView : 
    20         public CHaliteSortListViewCtrl<PeerListView, const hal::PeerDetail>, 
     20        public CHaliteSortListViewCtrl<PeerListView>, 
    2121        public hal::IniBase<PeerListView>, 
    2222        private boost::noncopyable 
     
    2525        typedef PeerListView thisClass; 
    2626        typedef hal::IniBase<thisClass> iniClass; 
    27         typedef CHaliteSortListViewCtrl<thisClass, const hal::PeerDetail> listClass; 
    28         typedef const hal::PeerDetail pD; 
     27        typedef CHaliteSortListViewCtrl<thisClass> listClass; 
    2928 
    3029        friend class listClass; 
    3130         
    32         struct ColumnAdapters 
    33         { 
    34          
    35         typedef listClass::ColumnAdapter ColAdapter_t; 
    36          
    37         struct SpeedDown : public ColAdapter_t 
    38         { 
    39                 virtual int compare(pD& l, pD& r)       { return hal::compare(l.speed.first, r.speed.first); }           
    40                 virtual std::wstring print(pD& p)  
    41                 { 
    42                         return (hal::wform(L"%1$.2fkb/s") % (p.speed.first/1024)).str();  
    43                 }                
    44         }; 
    45          
    46         struct SpeedUp : public ColAdapter_t 
    47         { 
    48                 virtual int compare(pD& l, pD& r)       { return hal::compare(l.speed.second, r.speed.second); }                 
    49                 virtual std::wstring print(pD& p)  
    50                 { 
    51                         return (hal::wform(L"%1$.2fkb/s") % (p.speed.second/1024)).str();  
    52                 }                
    53         }; 
    54          
    55         }; 
    56  
    5731public:  
    5832        enum {  
     
    6438        BEGIN_MSG_MAP_EX(thisClass) 
    6539                MSG_WM_DESTROY(OnDestroy) 
     40                REFLECTED_NOTIFY_CODE_HANDLER(SLVN_SORTCHANGED, OnSortChanged) 
    6641 
    6742                CHAIN_MSG_MAP(listClass) 
     
    6944        END_MSG_MAP() 
    7045 
    71         thisClass() : 
    72                 iniClass("listviews/advPeers", "PeerListView") 
     46        PeerListView(HaliteWindow& halWindow) : 
     47                iniClass("listviews/advPeers", "PeerListView"), 
     48                halite_window_(halWindow) 
    7349        {} 
    7450         
     
    10177                }        
    10278                                         
    103                 load_from_ini(); 
     79                load_from_ini();                 
    10480                 
    105                 SetColumnSortType(2, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::SpeedDown()); 
    106                 SetColumnSortType(3, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::SpeedUp()); 
     81                SetColumnSortType(2, hal::peer_detail::speed_down_e + (WTL::LVCOLSORT_LAST+1+hal::peer_detail::ip_address_e), NULL);             
     82                SetColumnSortType(3, hal::peer_detail::speed_up_e + (WTL::LVCOLSORT_LAST+1+hal::peer_detail::ip_address_e), NULL); 
    10783                 
    10884                return true; 
     
    11389                saveSettings(); 
    11490        } 
     91 
     92        LRESULT OnSortChanged(int, LPNMHDR pnmh, BOOL&); 
    11593         
    11694        friend class boost::serialization::access; 
     
    12199                        boost::serialization::base_object<listClass>(*this)); 
    122100        } 
    123          
    124 /*      pD CustomItemConversion(LVCompareParam* param, int iSortCol) 
    125         {                        
    126                 return peerDetails_[param->dwItemData]; 
    127         }               */ 
    128101 
    129102        void uiUpdate(const hal::torrent_details_manager& tD); 
    130103         
    131104private: 
    132         hal::PeerDetails peerDetails_; 
     105        hal::peer_details_vec peer_details_; 
     106        HaliteWindow& halite_window_; 
    133107}; 
    134108 
     
    148122 
    149123        AdvPeerDialog(HaliteWindow& halWindow) : 
    150                 dialogBaseClass(halWindow) 
     124                dialogBaseClass(halWindow), 
     125                peerList_(halWindow) 
    151126        {} 
    152127 
     
    175150        LRESULT OnInitDialog(HWND, LPARAM); 
    176151        void OnClose(); 
    177          
    178152        void uiUpdate(const hal::torrent_details_manager& tD); 
    179153 
  • trunk/src/advtabs/Torrent.cpp

    r531 r659  
    173173                SetDlgItemInfo(HAL_PEERS, 
    174174                        hal::wform(L"%1% (%2%)") 
    175                                 % torrent->peersConnected() 
     175                                % torrent->peers_connected() 
    176176                                % torrent->peers()); 
    177177 
    178178                SetDlgItemInfo(HAL_SEEDS, 
    179179                        hal::wform(L"%1% (%2%)") 
    180                                 % torrent->seedsConnected() 
     180                                % torrent->seeds_connected() 
    181181                                % torrent->seeds()); 
    182182 
    183183                SetDlgItemInfo(HAL_TRANSFERED, 
    184184                        hal::wform(hal::app().res_wstr(HAL_TRANSFERED))  
    185                                 % (static_cast<float>(torrent->totalPayloadDownloaded())/(1024*1024)) 
    186                                 % (static_cast<float>(torrent->totalPayloadUploaded())/(1024*1024))); 
     185                                % (static_cast<float>(torrent->total_payload_downloaded())/(1024*1024)) 
     186                                % (static_cast<float>(torrent->total_payload_uploaded())/(1024*1024))); 
    187187 
    188188                SetDlgItemInfo(HAL_OVERHEAD, 
    189189                        hal::wform(L"%1$.2fMB - %2$.2fMB")  
    190                                 % (static_cast<float>(torrent->totalDownloaded() - torrent->totalPayloadDownloaded())/(1024*1024)) 
    191                                 % (static_cast<float>(torrent->totalUploaded() - torrent->totalPayloadUploaded())/(1024*1024))); 
     190                                % (static_cast<float>(torrent->total_downloaded() - torrent->total_payload_downloaded())/(1024*1024)) 
     191                                % (static_cast<float>(torrent->total_uploaded() - torrent->total_payload_uploaded())/(1024*1024))); 
    192192 
    193193                SetDlgItemInfo(HAL_REMAINING, 
    194194                        hal::wform(hal::app().res_wstr(HAL_REMAINING)) 
    195                                 % (static_cast<float>(torrent->totalWanted()-torrent->totalWantedDone())/(1024*1024)) 
    196                                 % (static_cast<float>(torrent->totalWanted())/(1024*1024))); 
     195                                % (static_cast<float>(torrent->total_wanted()-torrent->total_wanted_done())/(1024*1024)) 
     196                                % (static_cast<float>(torrent->total_wanted())/(1024*1024))); 
    197197                 
    198198                wstring eta = hal::app().res_wstr(HAL_INF);      
    199                 if (!torrent->estimatedTimeLeft().is_special()) 
    200                         eta = hal::from_utf8(boost::posix_time::to_simple_string(torrent->estimatedTimeLeft())); 
     199                if (!torrent->estimated_time_left().is_special()) 
     200                        eta = hal::from_utf8(boost::posix_time::to_simple_string(torrent->estimated_time_left())); 
    201201                 
    202202                SetDlgItemInfo(HAL_ETA, eta); 
     
    207207                                % (torrent->speed().second/1024)); 
    208208                                 
    209                 float ratio = (torrent->totalPayloadDownloaded())  
    210                         ? static_cast<float>(torrent->totalPayloadUploaded()) 
    211                                 / static_cast<float>(torrent->totalPayloadDownloaded()) 
     209                float ratio = (torrent->total_payload_downloaded())  
     210                        ? static_cast<float>(torrent->total_payload_uploaded()) 
     211                                / static_cast<float>(torrent->total_payload_downloaded()) 
    212212                        : 0; 
    213213                 
     
    217217                m_prog.SetPos(static_cast<int>(torrent->completion()*100));      
    218218                 
    219                 SetDlgItemText(HAL_TRACKER, torrent->currentTracker().c_str()); 
    220                  
    221                 if (!torrent->updateTrackerIn().is_special()) 
     219                SetDlgItemText(HAL_TRACKER, torrent->current_tracker().c_str()); 
     220                 
     221                if (!torrent->update_tracker_in().is_special()) 
    222222                { 
    223223                        SetDlgItemText(HAL_UPDATE,       
    224                                 (hal::from_utf8(boost::posix_time::to_simple_string(torrent->updateTrackerIn())).c_str())); 
     224                                (hal::from_utf8(boost::posix_time::to_simple_string(torrent->update_tracker_in())).c_str())); 
    225225                } 
    226226                else SetDlgItemText(HAL_UPDATE, hal::app().res_wstr(HAL_NA).c_str());            
  • 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") 
  • trunk/src/halTorrent.hpp

    r656 r659  
    77#pragma once 
    88 
    9 #include <string> 
     9/*#include <string> 
    1010#include <vector> 
    1111#include <set> 
     
    1818 
    1919#include <boost/smart_ptr.hpp> 
    20  
    2120#include <boost/noncopyable.hpp> 
    2221 
     
    2625 
    2726#include <boost/smart_ptr.hpp> 
    28 #include <boost/algorithm/string.hpp> 
    2927 
    3028#include <boost/filesystem/path.hpp> 
    3129#include <boost/filesystem/operations.hpp> 
    3230#include <boost/filesystem/fstream.hpp> 
     31*/ 
     32 
     33#include <boost/algorithm/string.hpp> 
    3334 
    3435#include <stlsoft/properties/method_properties.hpp> 
    3536#include <stlsoft/util/operator_bool_adaptor.hpp> 
    3637 
    37  
    38 //#if BOOST_VERSION < 103500 
    39 //#include <asio/ip/tcp.hpp> 
    40 //#include <asio/ip/udp.hpp> 
    41 //#else 
    4238#include <boost/asio/ip/tcp.hpp> 
    4339#include <boost/asio/ip/udp.hpp> 
    44 //#endif 
    4540 
    4641#include "halTypes.hpp" 
    47  
    48 namespace libtorrent { struct peer_info; } 
     42#include "halPeers.hpp" 
    4943 
    5044namespace hal  
    5145{ 
     46 
     47template<typename T> 
     48bool hal_details_ptr_compare(T l, T r, size_t index = 0, bool cmp_less = true) 
     49{ 
     50        if (cmp_less) 
     51                return l->less(*r, index); 
     52        else 
     53                return r->less(*l, index); 
     54} 
     55 
     56template<typename T> 
     57bool hal_details_compare(T l, T r, size_t index = 0, bool cmp_less = true) 
     58{ 
     59        if (cmp_less) 
     60                return l.less(r, index); 
     61        else 
     62                return r.less(l, index); 
     63} 
    5264 
    5365inline boost::wformat wform(const std::wstring & f_string)  
     
    304316}; 
    305317 
    306 struct PeerDetail  
    307 { 
    308         PeerDetail(const std::wstring& ip_address) : 
    309                 ipAddress(ip_address) 
    310         {} 
    311         PeerDetail(libtorrent::peer_info& peerInfo); 
    312          
    313         bool operator==(const PeerDetail& peer) const 
    314         { 
    315                 return (ipAddress == peer.ipAddress); 
    316         } 
    317          
    318         bool operator<(const PeerDetail& peer) const 
    319         { 
    320                 return (ipAddress < peer.ipAddress); 
    321         } 
    322          
    323         std::wstring ipAddress; 
    324         std::wstring country; 
    325         std::pair<float,float> speed; 
    326         bool seed; 
    327         std::wstring client; 
    328         std::wstring status; 
    329 }; 
    330  
    331 typedef boost::shared_ptr<PeerDetail> PeerDetail_ptr; 
    332 typedef std::vector<PeerDetail> PeerDetails; 
    333  
    334318struct FileDetail 
    335319{ 
     
    384368 
    385369typedef std::vector<FileDetail> FileDetails; 
     370 
    386371 
    387372class torrent_details  
     
    416401                completion_(c), 
    417402                distributed_copies_(d), 
    418                 totalWantedDone_(tWD), 
    419                 totalWanted_(tW), 
     403                total_wanted_done_(tWD), 
     404                total_wanted_(tW), 
    420405                totalUploaded_(tU), 
    421                 totalPayloadUploaded_(tpU), 
    422                 totalDownloaded_(tD), 
    423                 totalPayloadDownloaded_(tpD), 
     406                total_payload_uploaded_(tpU), 
     407                total_downloaded_(tD), 
     408                total_payload_downloaded_(tpD), 
    424409                peers_(connections.get<0>()), 
    425                 connectedPeers_(connections.get<1>()), 
     410                connected_peers_(connections.get<1>()), 
    426411                seeds_(connections.get<2>()), 
    427                 connectedSeeds_(connections.get<3>()), 
     412                connected_seeds_(connections.get<3>()), 
    428413                ratio_(r), 
    429                 estimatedTimeLeft_(eta), 
    430                 updateTrackerIn_(uIn), 
    431                 peerDetailsFilled_(false), 
    432                 fileDetailsFilled_(false), 
     414                estimated_time_left_(eta), 
     415                update_tracker_in_(uIn), 
     416                peer_details_filled_(false), 
     417                file_details_filled_(false), 
    433418                active_(actve), 
    434419                seeding_(seding), 
    435                 startTime_(srt), 
    436                 finishTime_(fin), 
     420                start_time_(srt), 
     421                finish_time_(fin), 
    437422                queue_position_(q_p), 
    438423                managed_(man) 
     
    440425 
    441426        torrent_details() :      
    442                 peerDetailsFilled_(false), 
    443                 fileDetailsFilled_(false) 
     427                peer_details_filled_(false), 
     428                file_details_filled_(false) 
    444429        {};      
    445430         
     
    479464                queue_position_e 
    480465        }; 
    481  
    482466         
    483467//      const std::wstring& filename() const { return filename_; } 
     
    485469        const std::wstring& save_directory() const { return saveDir_; } 
    486470        const std::wstring& state() const { return state_; } 
    487         const std::wstring& currentTracker() const { return currentTracker_; } 
     471        const std::wstring& current_tracker() const { return currentTracker_; } 
    488472         
    489473        std::pair<float,float> speed() const { return speed_; } 
    490474        const float& completion() const { return completion_; } 
    491         const float& distributedCopies() const { return distributed_copies_; } 
    492          
    493         size_type totalUploaded() const { return totalUploaded_; } 
    494         size_type totalPayloadUploaded() const { return totalPayloadUploaded_; } 
    495         size_type totalDownloaded() const { return totalDownloaded_; } 
    496         size_type totalPayloadDownloaded() const { return totalPayloadDownloaded_; } 
    497         size_type totalWantedDone() const { return totalWantedDone_; } 
    498         size_type totalWanted() const { return totalWanted_; } 
     475        const float& distributed_copies() const { return distributed_copies_; } 
     476         
     477        size_type total_uploaded() const { return totalUploaded_; } 
     478        size_type total_payload_uploaded() const { return total_payload_uploaded_; } 
     479        size_type total_downloaded() const { return total_downloaded_; } 
     480        size_type total_payload_downloaded() const { return total_payload_downloaded_; } 
     481        size_type total_wanted_done() const { return total_wanted_done_; } 
     482        size_type total_wanted() const { return total_wanted_; } 
    499483         
    500484        size_type peers() const { return peers_; } 
    501         size_type peersConnected() const { return connectedPeers_; } 
     485        size_type peers_connected() const { return connected_peers_; } 
    502486        size_type seeds() const { return seeds_; } 
    503         size_type seedsConnected() const { return connectedSeeds_; } 
     487        size_type seeds_connected() const { return connected_seeds_; } 
    504488         
    505489        float ratio() { return ratio_; } 
    506490         
    507         const boost::posix_time::time_duration& estimatedTimeLeft() { return estimatedTimeLeft_; } 
    508         const boost::posix_time::time_duration& updateTrackerIn() { return updateTrackerIn_; } 
    509          
    510         const PeerDetails& peerDetails() const; 
    511         const FileDetails& fileDetails() const; 
     491        const boost::posix_time::time_duration& estimated_time_left() { return estimated_time_left_; } 
     492        const boost::posix_time::time_duration& update_tracker_in() { return update_tracker_in_; } 
     493         
     494        const peer_details_vec& get_peer_details() const; 
     495        const FileDetails& file_details() const; 
    512496         
    513497        const boost::posix_time::time_duration& active() { return active_; } 
    514498        const boost::posix_time::time_duration& seeding() { return seeding_; } 
    515         const boost::posix_time::ptime& startTime() { return startTime_; } 
    516         const boost::posix_time::ptime& finishTime() { return finishTime_; } 
     499        const boost::posix_time::ptime& start_time() { return start_time_; } 
     500        const boost::posix_time::ptime& finish_time() { return finish_time_; } 
    517501 
    518502        int queue_position() const { return queue_position_; } 
     
    533517        float distributed_copies_; 
    534518         
    535         size_type totalWantedDone_; 
    536         size_type totalWanted_; 
     519        size_type total_wanted_done_; 
     520        size_type total_wanted_; 
    537521        size_type totalUploaded_; 
    538         size_type totalPayloadUploaded_; 
    539         size_type totalDownloaded_; 
    540         size_type totalPayloadDownloaded_; 
     522        size_type total_payload_uploaded_; 
     523        size_type total_downloaded_; 
     524        size_type total_payload_downloaded_; 
    541525         
    542526        size_type peers_; 
    543         size_type connectedPeers_; 
     527        size_type connected_peers_; 
    544528        size_type seeds_; 
    545         size_type connectedSeeds_; 
     529        size_type connected_seeds_; 
    546530         
    547531        float ratio_; 
    548532         
    549         boost::posix_time::time_duration estimatedTimeLeft_; 
    550         boost::posix_time::time_duration updateTrackerIn_; 
     533        boost::posix_time::time_duration estimated_time_left_; 
     534        boost::posix_time::time_duration update_tracker_in_; 
    551535         
    552536        boost::posix_time::time_duration active_; 
    553537        boost::posix_time::time_duration seeding_; 
    554         boost::posix_time::ptime startTime_; 
    555         boost::posix_time::ptime finishTime_; 
     538        boost::posix_time::ptime start_time_; 
     539        boost::posix_time::ptime finish_time_; 
    556540 
    557541        int queue_position_; 
     
    559543         
    560544private: 
    561         mutable bool peerDetailsFilled_; 
    562         mutable PeerDetails peerDetails_; 
    563          
    564         mutable bool fileDetailsFilled_; 
    565         mutable FileDetails fileDetails_; 
     545        mutable bool peer_details_filled_; 
     546        mutable peer_details_vec peer_details_; 
     547         
     548        mutable bool file_details_filled_; 
     549        mutable FileDetails file_details_; 
    566550}; 
    567551 
     
    945929                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false); 
    946930         
    947         void get_all_peer_details(const std::string& filename, PeerDetails& peerContainer); 
    948         void get_all_peer_details(const std::wstring& filename, PeerDetails& peerContainer); 
    949         void get_all_file_details(const std::string& filename, FileDetails& fileDetails); 
    950         void get_all_file_details(const std::wstring& filename, FileDetails& fileDetails); 
     931        void get_all_peer_details(const std::string& filename, peer_details_vec& peerContainer); 
     932        void get_all_peer_details(const std::wstring& filename, peer_details_vec& peerContainer); 
     933        void get_all_file_details(const std::string& filename, FileDetails& file_details); 
     934        void get_all_file_details(const std::wstring& filename, FileDetails& file_details); 
    951935         
    952936        void resume_all(); 
  • trunk/src/halTorrentInternal.hpp

    r648 r659  
    333333                progress_(0), \ 
    334334                managed_(false), \ 
    335                 startTime_(boost::posix_time::second_clock::universal_time()), \ 
     335                start_time_(boost::posix_time::second_clock::universal_time()), \ 
    336336                in_session_(false), \ 
    337337                queue_position_(0) 
     
    481481                        statusMemory_.next_announce,  
    482482                        active_duration_, seeding_duration_,  
    483                         startTime_, finishTime_,  
     483                        start_time_, finish_time_,  
    484484                        queue_position_, 
    485485                        is_managed())); 
     
    886886        void finished() 
    887887        { 
    888                 if (finishTime_.is_special()) 
    889                         finishTime_ = boost::posix_time::second_clock::universal_time(); 
     888                if (finish_time_.is_special()) 
     889                        finish_time_ = boost::posix_time::second_clock::universal_time(); 
    890890 
    891891                if (is_finished()) 
     
    10061006                        ar & make_nvp("file_priorities", filePriorities_); 
    10071007                         
    1008                         ar & make_nvp("start_time", startTime_); 
    1009                         ar & make_nvp("finish_time", finishTime_); 
     1008                        ar & make_nvp("start_time", start_time_); 
     1009                        ar & make_nvp("finish_time", finish_time_); 
    10101010                        ar & make_nvp("active_duration", active_duration_); 
    10111011                        ar & make_nvp("seeding_duration", seeding_duration_); 
     
    10471047                        ar & make_nvp("file_priorities", filePriorities_); 
    10481048                         
    1049                         ar & make_nvp("startTime", startTime_); 
     1049                        ar & make_nvp("start_time", start_time_); 
    10501050                        ar & make_nvp("activeDuration", active_duration_); 
    10511051                        ar & make_nvp("seedingDuration", seeding_duration_); 
     
    10531053                        ar & make_nvp("name", name_); 
    10541054                        ar & make_nvp("compactStorage", compact_storage_); 
    1055                         ar & make_nvp("finishTime", finishTime_); 
     1055                        ar & make_nvp("finish_time", finish_time_); 
    10561056                         
    10571057                        ar & make_nvp("progress", progress_); 
     
    11001100        } 
    11011101         
    1102         void get_peer_details(PeerDetails& peerDetails) const 
     1102        void get_peer_details(peer_details_vec& peer_details) const 
    11031103        { 
    11041104                if (in_session()) 
     
    11061106                        foreach (libt::peer_info peer, peers_)  
    11071107                        { 
    1108                                 peerDetails.push_back(peer); 
     1108                                peer_details.push_back(peer); 
    11091109                        }        
    11101110                } 
    11111111        } 
    11121112 
    1113         void get_file_details(FileDetails& fileDetails) 
    1114         { 
    1115                 if (fileDetailsMemory_.empty()) 
     1113        void get_file_details(FileDetails& file_details) 
     1114        { 
     1115                if (file_detailsMemory_.empty()) 
    11161116                { 
    11171117                        boost::intrusive_ptr<libt::torrent_info> info = info_memory(); 
     
    11321132                                boost::int64_t size = static_cast<boost::int64_t>(files[i].size); 
    11331133                                 
    1134                                 fileDetailsMemory_.push_back(FileDetail(fullPath, size, 0, filePriorities_[i], i)); 
     1134                                file_detailsMemory_.push_back(FileDetail(fullPath, size, 0, filePriorities_[i], i)); 
    11351135                        }        
    11361136                }                
     
    11411141                        handle_.file_progress(fileProgress); 
    11421142                         
    1143                         for(size_t i=0, e=fileDetailsMemory_.size(); i<e; ++i) 
    1144                                 fileDetailsMemory_[i].progress =  fileProgress[i];                       
    1145                 } 
    1146  
    1147                 for(size_t i=0, e=fileDetailsMemory_.size(); i<e; ++i) 
    1148                         fileDetailsMemory_[i].priority =  filePriorities_[i]; 
    1149                  
    1150                 fileDetails = fileDetailsMemory_; 
     1143                        for(size_t i=0, e=file_detailsMemory_.size(); i<e; ++i) 
     1144                                file_detailsMemory_[i].progress =  fileProgress[i];                      
     1145                } 
     1146 
     1147                for(size_t i=0, e=file_detailsMemory_.size(); i<e; ++i) 
     1148                        file_detailsMemory_[i].priority =  filePriorities_[i]; 
     1149                 
     1150                file_details = file_detailsMemory_; 
    11511151        } 
    11521152         
     
    14791479        transfer_tracker<boost::int64_t> downloaded_; 
    14801480         
    1481         pt::ptime startTime_; 
    1482         pt::ptime finishTime_; 
     1481        pt::ptime start_time_; 
     1482        pt::ptime finish_time_; 
    14831483        duration_tracker active_duration_; 
    14841484        duration_tracker seeding_duration_; 
     
    14931493        boost::intrusive_ptr<libt::torrent_info> info_memory_; 
    14941494        libt::torrent_status statusMemory_; 
    1495         FileDetails fileDetailsMemory_; 
     1495        FileDetails file_detailsMemory_; 
    14961496         
    14971497        int queue_position_; 
  • trunk/src/stdAfx.hpp

    r658 r659  
    8888#include <boost/filesystem/path.hpp> 
    8989#include <boost/filesystem/operations.hpp> 
     90#include <boost/filesystem/fstream.hpp> 
     91#include <boost/filesystem/convenience.hpp> 
    9092 
    9193#include <boost/xpressive/xpressive.hpp> 
Note: See TracChangeset for help on using the changeset viewer.