Changeset 660


Ignore:
Timestamp:
12/27/08 15:02:40 (11 years ago)
Author:
Eoin
Message:

FileDetail? struct converted to file_details along with other related naming changes.

Location:
trunk/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/advtabs/Files.cpp

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

    r659 r660  
    3535        {} 
    3636 
    37         FileLink(const hal::FileDetail& f) : 
     37        FileLink(const hal::file_details& f) : 
    3838                branch(f.branch), 
    3939                filename(f.filename), 
     
    8282 
    8383class FileListView : 
    84         public CHaliteSortListViewCtrl<FileListView, const hal::FileDetail>, 
     84        public CHaliteSortListViewCtrl<FileListView, const hal::file_details>, 
    8585        public hal::IniBase<FileListView>, 
    8686        private boost::noncopyable 
     
    8888public: 
    8989        typedef FileListView thisClass; 
    90         typedef const hal::FileDetail dataClass; 
     90        typedef const hal::file_details dataClass; 
    9191        typedef CHaliteSortListViewCtrl<thisClass, dataClass> listClass; 
    9292        typedef hal::IniBase<thisClass> iniClass; 
     
    193193/*      dataClass CustomItemConversion(LVCompareParam* param, int iSortCol) 
    194194        {                        
    195                 return focused_->file_details()[param->dwItemData]; 
     195                return focused_->get_file_details()[param->dwItemData]; 
    196196        }               */ 
    197197         
     
    450450        std::vector<FileLink> fileLinks_; 
    451451         
    452         hal::FileDetails file_details_; 
     452        hal::file_details_vec file_details_; 
    453453        std::pair<std::vector<FileLink>::iterator, std::vector<FileLink>::iterator> range_; 
    454454}; 
  • trunk/src/halConfig.cpp

    r641 r660  
    1010#include "Halite.hpp" 
    1111 
     12#include "global/string_conv.hpp" 
     13#include "global/wtl_app.hpp" 
     14 
     15#include "halIni.hpp" 
    1216#include "halConfig.hpp" 
    1317#include "ProgressDialog.hpp" 
     
    1519namespace hal 
    1620{ 
     21 
     22Config::Config() : 
     23        hal::IniBase<Config>("globals/bittorrent", "Config"), 
     24        globals_(), 
     25        torrent_defaults_(), 
     26        port_range_(6881,6881), 
     27        use_port_range_(false), 
     28        randomize_port_(false), 
     29        enable_dht_(true), 
     30        dht_settings_(), 
     31        dht_random_port_(0), 
     32        dht_upper_port_(0), 
     33        dht_radio_(1), 
     34        enable_ip_filter_(false), 
     35        enableProxy(false), 
     36        proxyPort(0), 
     37        default_save_folder_((hal::app().exe_path().parent_path()/L"incoming").string()), 
     38        default_move_folder_((hal::app().exe_path().parent_path()/L"completed").string()), 
     39        use_move_to_(false), 
     40        save_prompt_(true), 
     41        enable_pe_(false), 
     42        pe_settings_(), 
     43        half_connections_(true), 
     44        half_connections_limit_(10), 
     45        mapping_upnp_(false), 
     46        mapping_nat_pmp_(false), 
     47        resolve_countries_(false), 
     48        metadata_plugin_(false), 
     49        ut_metadata_plugin_(false), 
     50        ut_pex_plugin_(false), 
     51        smart_ban_plugin_(false) 
     52{ 
     53        queue_settings_ = hal::bittorrent().get_queue_settings(); 
     54        timeouts_ = hal::bittorrent().get_timeouts(); 
     55} 
    1756 
    1857bool Config::settingsChanged() 
  • trunk/src/halConfig.hpp

    r641 r660  
    77#pragma once 
    88 
    9 #include "global/string_conv.hpp" 
    10 #include "global/wtl_app.hpp" 
    11  
    12 #include "halIni.hpp" 
    13  
    149class BitTorrentOptions; 
    1510class SecurityOptions; 
     
    2015{ 
    2116 
     17struct queue_settings 
     18{ 
     19        friend class boost::serialization::access; 
     20        template<class Archive> 
     21        void serialize(Archive& ar, const unsigned int version) 
     22        {        
     23                ar & BOOST_SERIALIZATION_NVP(auto_manage_interval); 
     24                ar & BOOST_SERIALIZATION_NVP(active_downloads); 
     25                ar & BOOST_SERIALIZATION_NVP(active_seeds); 
     26                ar & BOOST_SERIALIZATION_NVP(seeds_hard_limit); 
     27                ar & BOOST_SERIALIZATION_NVP(seed_ratio_limit); 
     28                ar & BOOST_SERIALIZATION_NVP(seed_ratio_time_limit); 
     29                ar & BOOST_SERIALIZATION_NVP(seed_time_limit); 
     30                ar & BOOST_SERIALIZATION_NVP(dont_count_slow_torrents); 
     31                ar & BOOST_SERIALIZATION_NVP(auto_scrape_min_interval); 
     32                ar & BOOST_SERIALIZATION_NVP(auto_scrape_interval); 
     33                ar & BOOST_SERIALIZATION_NVP(close_redundant_connections); 
     34        } 
     35 
     36        bool operator==(const queue_settings& s) const 
     37        { 
     38                return (auto_manage_interval == s.auto_manage_interval && 
     39                        active_downloads == s.active_downloads && 
     40                        active_seeds == s.active_seeds && 
     41                        seeds_hard_limit == s.seeds_hard_limit && 
     42                        seed_ratio_limit == s.seed_ratio_limit && 
     43                        seed_ratio_time_limit == s.seed_ratio_time_limit && 
     44                        seed_time_limit == s.seed_time_limit && 
     45                        dont_count_slow_torrents == s.dont_count_slow_torrents && 
     46                        auto_scrape_min_interval == s.auto_scrape_min_interval && 
     47                        auto_scrape_interval == s.auto_scrape_interval && 
     48                        close_redundant_connections == s.close_redundant_connections); 
     49        } 
     50         
     51        bool operator!=(const queue_settings& s) const 
     52        { 
     53                return !(*this == s); 
     54        } 
     55 
     56        int auto_manage_interval; 
     57 
     58        int active_downloads; 
     59        int active_seeds; 
     60        int seeds_hard_limit; 
     61        float seed_ratio_limit; 
     62        float seed_ratio_time_limit; 
     63        int seed_time_limit; 
     64        bool dont_count_slow_torrents; 
     65 
     66        int auto_scrape_min_interval; 
     67        int auto_scrape_interval; 
     68        bool close_redundant_connections; 
     69}; 
     70 
     71struct timeouts 
     72{ 
     73        friend class boost::serialization::access; 
     74        template<class Archive> 
     75        void serialize(Archive& ar, const unsigned int version) 
     76        {        
     77                ar & BOOST_SERIALIZATION_NVP(tracker_completion_timeout); 
     78                ar & BOOST_SERIALIZATION_NVP(tracker_receive_timeout); 
     79                ar & BOOST_SERIALIZATION_NVP(stop_tracker_timeout); 
     80 
     81                ar & BOOST_SERIALIZATION_NVP(request_queue_time); 
     82                ar & BOOST_SERIALIZATION_NVP(piece_timeout); 
     83                ar & BOOST_SERIALIZATION_NVP(min_reconnect_time); 
     84 
     85                ar & BOOST_SERIALIZATION_NVP(peer_timeout); 
     86                ar & BOOST_SERIALIZATION_NVP(urlseed_timeout); 
     87                ar & BOOST_SERIALIZATION_NVP(peer_connect_timeout); 
     88                ar & BOOST_SERIALIZATION_NVP(inactivity_timeout); 
     89                ar & BOOST_SERIALIZATION_NVP(handshake_timeout); 
     90        } 
     91 
     92        int tracker_completion_timeout; 
     93        int tracker_receive_timeout; 
     94        int stop_tracker_timeout; 
     95 
     96        float request_queue_time; 
     97        int piece_timeout; 
     98        int min_reconnect_time; 
     99 
     100        int peer_timeout; 
     101        int urlseed_timeout; 
     102        int peer_connect_timeout; 
     103        int inactivity_timeout; 
     104        int handshake_timeout; 
     105}; 
     106 
     107struct dht_settings 
     108{ 
     109        dht_settings() : 
     110                max_peers_reply(50), 
     111                search_branching(5), 
     112                service_port(6881), 
     113                max_fail_count(20) 
     114        {} 
     115 
     116        friend class boost::serialization::access; 
     117        template<class Archive> 
     118        void serialize(Archive& ar, const unsigned int version) 
     119        {        
     120                ar & BOOST_SERIALIZATION_NVP(max_peers_reply); 
     121                ar & BOOST_SERIALIZATION_NVP(search_branching); 
     122                ar & BOOST_SERIALIZATION_NVP(service_port); 
     123                ar & BOOST_SERIALIZATION_NVP(max_fail_count); 
     124        } 
     125 
     126        int max_peers_reply; 
     127        int search_branching; 
     128        int service_port; 
     129        int max_fail_count; 
     130}; 
     131 
     132struct cache_settings 
     133{ 
     134        cache_settings() : 
     135                cache_size(512), 
     136                cache_expiry(60) 
     137        {} 
     138 
     139        friend class boost::serialization::access; 
     140        template<class Archive> 
     141        void serialize(Archive& ar, const unsigned int version) 
     142        {        
     143                ar & BOOST_SERIALIZATION_NVP(cache_size); 
     144                ar & BOOST_SERIALIZATION_NVP(cache_expiry); 
     145        } 
     146 
     147        int cache_size; 
     148        int cache_expiry; 
     149}; 
     150 
     151struct pe_settings 
     152{ 
     153        pe_settings() : 
     154                encrypt_level(0), 
     155                prefer_rc4(false), 
     156                conn_in_policy(1), 
     157                conn_out_policy(1) 
     158        {} 
     159 
     160        friend class boost::serialization::access; 
     161        template<class Archive> 
     162        void serialize(Archive& ar, const unsigned int version) 
     163        {        
     164                ar & BOOST_SERIALIZATION_NVP(encrypt_level); 
     165                ar & BOOST_SERIALIZATION_NVP(prefer_rc4); 
     166                ar & BOOST_SERIALIZATION_NVP(conn_in_policy); 
     167                ar & BOOST_SERIALIZATION_NVP(conn_out_policy); 
     168        } 
     169 
     170    int encrypt_level; 
     171    bool prefer_rc4; 
     172    int conn_in_policy; 
     173    int conn_out_policy; 
     174}; 
     175 
     176struct connections 
     177{ 
     178        connections() : 
     179                total(50), 
     180                uploads(10), 
     181                download_rate(-1), 
     182                upload_rate(-1) 
     183        {} 
     184 
     185        friend class boost::serialization::access; 
     186        template<class Archive> 
     187        void serialize(Archive& ar, const unsigned int version) 
     188        {        
     189                ar & BOOST_SERIALIZATION_NVP(total); 
     190                ar & BOOST_SERIALIZATION_NVP(uploads); 
     191                ar & BOOST_SERIALIZATION_NVP(download_rate); 
     192                ar & BOOST_SERIALIZATION_NVP(upload_rate); 
     193        } 
     194 
     195    int total; 
     196    int uploads; 
     197    float download_rate; 
     198    float upload_rate; 
     199}; 
     200 
     201struct cache_details 
     202{ 
     203        cache_details() : 
     204                blocks_written(-1), 
     205                writes(-1), 
     206                blocks_read(-1), 
     207                blocks_read_hit(-1), 
     208                reads(-1), 
     209                cache_size(-1), 
     210                read_cache_size(-1), 
     211                write_ratio(-1), 
     212                read_ratio(-1), 
     213                write_cache_size(-1) 
     214        {} 
     215 
     216        cache_details(size_type b_w, 
     217                        size_type w, 
     218                        size_type b_r, 
     219                        size_type b_r_h, 
     220                        size_type r, 
     221                        int c_s, 
     222                        int r_c_s) : 
     223                blocks_written(b_w), 
     224                writes(w), 
     225                blocks_read(b_r), 
     226                blocks_read_hit(b_r_h), 
     227                reads(r), 
     228                cache_size(c_s), 
     229                read_cache_size(r_c_s), 
     230                write_cache_size(cache_size-read_cache_size) 
     231        { 
     232                write_ratio = (blocks_written == 0) ? 0 : 
     233                        static_cast<double>(blocks_written-writes) / blocks_written; 
     234 
     235                read_ratio = (blocks_read == 0) ? 0 : 
     236                        static_cast<double>(blocks_read_hit) / blocks_read;} 
     237 
     238    size_type blocks_written; 
     239    size_type writes; 
     240    size_type blocks_read; 
     241    size_type blocks_read_hit; 
     242    size_type reads; 
     243    int cache_size; 
     244    int read_cache_size; 
     245 
     246        double write_ratio; 
     247        double read_ratio; 
     248        int write_cache_size; 
     249}; 
     250         
    22251class Config : 
    23252        public hal::IniBase<Config>, 
     
    25254{ 
    26255public: 
    27         Config() : 
    28                 hal::IniBase<Config>("globals/bittorrent", "Config"), 
    29                 globals_(), 
    30                 torrent_defaults_(), 
    31                 port_range_(6881,6881), 
    32                 use_port_range_(false), 
    33                 randomize_port_(false), 
    34                 enable_dht_(true), 
    35                 dht_settings_(), 
    36                 dht_random_port_(0), 
    37                 dht_upper_port_(0), 
    38                 dht_radio_(1), 
    39                 enable_ip_filter_(false), 
    40                 enableProxy(false), 
    41                 proxyPort(0), 
    42                 default_save_folder_((hal::app().exe_path().parent_path()/L"incoming").string()), 
    43                 default_move_folder_((hal::app().exe_path().parent_path()/L"completed").string()), 
    44                 use_move_to_(false), 
    45                 save_prompt_(true), 
    46                 enable_pe_(false), 
    47                 pe_settings_(), 
    48                 half_connections_(true), 
    49                 half_connections_limit_(10), 
    50                 mapping_upnp_(false), 
    51                 mapping_nat_pmp_(false), 
    52                 resolve_countries_(false), 
    53                 metadata_plugin_(false), 
    54                 ut_metadata_plugin_(false), 
    55                 ut_pex_plugin_(false), 
    56                 smart_ban_plugin_(false) 
    57         { 
    58                 queue_settings_ = hal::bittorrent().get_queue_settings(); 
    59                 timeouts_ = hal::bittorrent().get_timeouts(); 
    60         } 
     256        Config(); 
    61257         
    62258        friend class boost::serialization::access; 
  • trunk/src/halSession.hpp

    r648 r660  
    3939#include "halTypes.hpp" 
    4040#include "halEvent.hpp" 
     41#include "halConfig.hpp" 
    4142#include "halTorrentInternal.hpp" 
    4243#include "halSignaler.hpp" 
     
    358359                        return false; 
    359360                } 
    360                 catch(...) 
     361                catch (...) 
    361362                { 
    362363                        return false; 
     
    753754                resolve_countries_ = b; 
    754755 
    755                 for (TorrentManager::torrentByName::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
     756                for (torrent_manager::torrent_by_name::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
    756757                        i != e; ++i) 
    757758                { 
     
    870871                } 
    871872                 
    872                 std::pair<TorrentManager::torrentByName::iterator, bool> p = 
     873                std::pair<torrent_manager::torrent_by_name::iterator, bool> p = 
    873874                        the_torrents_.insert(TIp); 
    874875                 
     
    10261027                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Resuming torrent."))); 
    10271028                 
    1028                 for (TorrentManager::torrentByName::iterator i=the_torrents_.begin(), e=the_torrents_.end(); i != e;) 
     1029                for (torrent_manager::torrent_by_name::iterator i=the_torrents_.begin(), e=the_torrents_.end(); i != e;) 
    10291030                { 
    10301031                        wpath file = wpath(hal::app().get_working_directory())/L"torrents"/(*i).torrent->filename(); 
     
    10891090                event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Stopping all torrents..."))); 
    10901091                 
    1091                 for (TorrentManager::torrentByName::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
     1092                for (torrent_manager::torrent_by_name::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
    10921093                        i != e; ++i) 
    10931094                { 
     
    11001101                        num_active = 0; 
    11011102 
    1102                         for (TorrentManager::torrentByName::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
     1103                        for (torrent_manager::torrent_by_name::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
    11031104                                        i != e; ++i) 
    11041105                        { 
     
    11561157         
    11571158        ini_file bittorrentIni; 
    1158         TorrentManager the_torrents_;    
     1159        torrent_manager the_torrents_;   
    11591160         
    11601161        int default_torrent_max_connections_; 
  • trunk/src/halTorrent.cpp

    r659 r660  
    1919#include "halTorrentInternal.hpp" 
    2020#include "halSession.hpp" 
     21#include "halConfig.hpp" 
    2122//#include "halSessionAlert.hpp" 
    2223 
     
    4647} 
    4748 
    48 const FileDetails& torrent_details::file_details() const 
     49const file_details_vec& torrent_details::get_file_details() const 
    4950{ 
    5051        if (!file_details_filled_) 
     
    519520        torrentDetails_.torrents_.reserve(pimpl()->the_torrents_.size()); 
    520521         
    521         for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); i != e; ++i) 
     522        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); i != e; ++i) 
    522523        { 
    523524                wstring utf8Name = (*i).torrent->name(); 
     
    570571} 
    571572 
    572 void bit::get_all_file_details(const std::string& filename, FileDetails& file_details) 
     573void bit::get_all_file_details(const std::string& filename, file_details_vec& file_details) 
    573574{ 
    574575        get_all_file_details(from_utf8_safe(filename), file_details); 
    575576} 
    576577 
    577 void bit::get_all_file_details(const std::wstring& filename, FileDetails& file_details) 
     578void bit::get_all_file_details(const std::wstring& filename, file_details_vec& file_details) 
    578579{ 
    579580        try { 
     
    701702        try { 
    702703         
    703         for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); 
     704        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); 
    704705                i != e; ++i) 
    705706        {                
     
    715716        try { 
    716717         
    717         for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); 
     718        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); 
    718719                i != e; ++i) 
    719720        { 
  • trunk/src/halTorrent.hpp

    r659 r660  
    7272} 
    7373 
    74 struct queue_settings 
    75 { 
    76         friend class boost::serialization::access; 
    77         template<class Archive> 
    78         void serialize(Archive& ar, const unsigned int version) 
    79         {        
    80                 ar & BOOST_SERIALIZATION_NVP(auto_manage_interval); 
    81                 ar & BOOST_SERIALIZATION_NVP(active_downloads); 
    82                 ar & BOOST_SERIALIZATION_NVP(active_seeds); 
    83                 ar & BOOST_SERIALIZATION_NVP(seeds_hard_limit); 
    84                 ar & BOOST_SERIALIZATION_NVP(seed_ratio_limit); 
    85                 ar & BOOST_SERIALIZATION_NVP(seed_ratio_time_limit); 
    86                 ar & BOOST_SERIALIZATION_NVP(seed_time_limit); 
    87                 ar & BOOST_SERIALIZATION_NVP(dont_count_slow_torrents); 
    88                 ar & BOOST_SERIALIZATION_NVP(auto_scrape_min_interval); 
    89                 ar & BOOST_SERIALIZATION_NVP(auto_scrape_interval); 
    90                 ar & BOOST_SERIALIZATION_NVP(close_redundant_connections); 
    91         } 
    92  
    93         bool operator==(const queue_settings& s) const 
    94         { 
    95                 return (auto_manage_interval == s.auto_manage_interval && 
    96                         active_downloads == s.active_downloads && 
    97                         active_seeds == s.active_seeds && 
    98                         seeds_hard_limit == s.seeds_hard_limit && 
    99                         seed_ratio_limit == s.seed_ratio_limit && 
    100                         seed_ratio_time_limit == s.seed_ratio_time_limit && 
    101                         seed_time_limit == s.seed_time_limit && 
    102                         dont_count_slow_torrents == s.dont_count_slow_torrents && 
    103                         auto_scrape_min_interval == s.auto_scrape_min_interval && 
    104                         auto_scrape_interval == s.auto_scrape_interval && 
    105                         close_redundant_connections == s.close_redundant_connections); 
    106         } 
    107          
    108         bool operator!=(const queue_settings& s) const 
    109         { 
    110                 return !(*this == s); 
    111         } 
    112  
    113         int auto_manage_interval; 
    114  
    115         int active_downloads; 
    116         int active_seeds; 
    117         int seeds_hard_limit; 
    118         float seed_ratio_limit; 
    119         float seed_ratio_time_limit; 
    120         int seed_time_limit; 
    121         bool dont_count_slow_torrents; 
    122  
    123         int auto_scrape_min_interval; 
    124         int auto_scrape_interval; 
    125         bool close_redundant_connections; 
    126 }; 
    127  
    128 struct timeouts 
    129 { 
    130         friend class boost::serialization::access; 
    131         template<class Archive> 
    132         void serialize(Archive& ar, const unsigned int version) 
    133         {        
    134                 ar & BOOST_SERIALIZATION_NVP(tracker_completion_timeout); 
    135                 ar & BOOST_SERIALIZATION_NVP(tracker_receive_timeout); 
    136                 ar & BOOST_SERIALIZATION_NVP(stop_tracker_timeout); 
    137  
    138                 ar & BOOST_SERIALIZATION_NVP(request_queue_time); 
    139                 ar & BOOST_SERIALIZATION_NVP(piece_timeout); 
    140                 ar & BOOST_SERIALIZATION_NVP(min_reconnect_time); 
    141  
    142                 ar & BOOST_SERIALIZATION_NVP(peer_timeout); 
    143                 ar & BOOST_SERIALIZATION_NVP(urlseed_timeout); 
    144                 ar & BOOST_SERIALIZATION_NVP(peer_connect_timeout); 
    145                 ar & BOOST_SERIALIZATION_NVP(inactivity_timeout); 
    146                 ar & BOOST_SERIALIZATION_NVP(handshake_timeout); 
    147         } 
    148  
    149         int tracker_completion_timeout; 
    150         int tracker_receive_timeout; 
    151         int stop_tracker_timeout; 
    152  
    153         float request_queue_time; 
    154         int piece_timeout; 
    155         int min_reconnect_time; 
    156  
    157         int peer_timeout; 
    158         int urlseed_timeout; 
    159         int peer_connect_timeout; 
    160         int inactivity_timeout; 
    161         int handshake_timeout; 
    162 }; 
    163  
    164 struct dht_settings 
    165 { 
    166         dht_settings() : 
    167                 max_peers_reply(50), 
    168                 search_branching(5), 
    169                 service_port(6881), 
    170                 max_fail_count(20) 
    171         {} 
    172  
    173         friend class boost::serialization::access; 
    174         template<class Archive> 
    175         void serialize(Archive& ar, const unsigned int version) 
    176         {        
    177                 ar & BOOST_SERIALIZATION_NVP(max_peers_reply); 
    178                 ar & BOOST_SERIALIZATION_NVP(search_branching); 
    179                 ar & BOOST_SERIALIZATION_NVP(service_port); 
    180                 ar & BOOST_SERIALIZATION_NVP(max_fail_count); 
    181         } 
    182  
    183         int max_peers_reply; 
    184         int search_branching; 
    185         int service_port; 
    186         int max_fail_count; 
    187 }; 
    188  
    189 struct cache_settings 
    190 { 
    191         cache_settings() : 
    192                 cache_size(512), 
    193                 cache_expiry(60) 
    194         {} 
    195  
    196         friend class boost::serialization::access; 
    197         template<class Archive> 
    198         void serialize(Archive& ar, const unsigned int version) 
    199         {        
    200                 ar & BOOST_SERIALIZATION_NVP(cache_size); 
    201                 ar & BOOST_SERIALIZATION_NVP(cache_expiry); 
    202         } 
    203  
    204         int cache_size; 
    205         int cache_expiry; 
    206 }; 
    207  
    208 struct pe_settings 
    209 { 
    210         pe_settings() : 
    211                 encrypt_level(0), 
    212                 prefer_rc4(false), 
    213                 conn_in_policy(1), 
    214                 conn_out_policy(1) 
    215         {} 
    216  
    217         friend class boost::serialization::access; 
    218         template<class Archive> 
    219         void serialize(Archive& ar, const unsigned int version) 
    220         {        
    221                 ar & BOOST_SERIALIZATION_NVP(encrypt_level); 
    222                 ar & BOOST_SERIALIZATION_NVP(prefer_rc4); 
    223                 ar & BOOST_SERIALIZATION_NVP(conn_in_policy); 
    224                 ar & BOOST_SERIALIZATION_NVP(conn_out_policy); 
    225         } 
    226  
    227     int encrypt_level; 
    228     bool prefer_rc4; 
    229     int conn_in_policy; 
    230     int conn_out_policy; 
    231 }; 
    232  
    233 struct connections 
    234 { 
    235         connections() : 
    236                 total(50), 
    237                 uploads(10), 
    238                 download_rate(-1), 
    239                 upload_rate(-1) 
    240         {} 
    241  
    242         friend class boost::serialization::access; 
    243         template<class Archive> 
    244         void serialize(Archive& ar, const unsigned int version) 
    245         {        
    246                 ar & BOOST_SERIALIZATION_NVP(total); 
    247                 ar & BOOST_SERIALIZATION_NVP(uploads); 
    248                 ar & BOOST_SERIALIZATION_NVP(download_rate); 
    249                 ar & BOOST_SERIALIZATION_NVP(upload_rate); 
    250         } 
    251  
    252     int total; 
    253     int uploads; 
    254     float download_rate; 
    255     float upload_rate; 
    256 }; 
    257  
    258 struct cache_details 
    259 { 
    260         cache_details() : 
    261                 blocks_written(-1), 
    262                 writes(-1), 
    263                 blocks_read(-1), 
    264                 blocks_read_hit(-1), 
    265                 reads(-1), 
    266                 cache_size(-1), 
    267                 read_cache_size(-1), 
    268                 write_ratio(-1), 
    269                 read_ratio(-1), 
    270                 write_cache_size(-1) 
    271         {} 
    272  
    273         cache_details(size_type b_w, 
    274                         size_type w, 
    275                         size_type b_r, 
    276                         size_type b_r_h, 
    277                         size_type r, 
    278                         int c_s, 
    279                         int r_c_s) : 
    280                 blocks_written(b_w), 
    281                 writes(w), 
    282                 blocks_read(b_r), 
    283                 blocks_read_hit(b_r_h), 
    284                 reads(r), 
    285                 cache_size(c_s), 
    286                 read_cache_size(r_c_s), 
    287                 write_cache_size(cache_size-read_cache_size) 
    288         { 
    289                 write_ratio = (blocks_written == 0) ? 0 : 
    290                         static_cast<double>(blocks_written-writes) / blocks_written; 
    291  
    292                 read_ratio = (blocks_read == 0) ? 0 : 
    293                         static_cast<double>(blocks_read_hit) / blocks_read;} 
    294  
    295     size_type blocks_written; 
    296     size_type writes; 
    297     size_type blocks_read; 
    298     size_type blocks_read_hit; 
    299     size_type reads; 
    300     int cache_size; 
    301     int read_cache_size; 
    302  
    303         double write_ratio; 
    304         double read_ratio; 
    305         int write_cache_size; 
    306 }; 
    307          
    30874struct torrentBriefDetail  
    30975{ 
     
    31682}; 
    31783 
    318 struct FileDetail 
    319 { 
    320         FileDetail(boost::filesystem::wpath p, boost::int64_t s=0, boost::int64_t pg=0, int pr=1, size_t o=0, unsigned t=FileDetail::file) : 
     84struct queue_settings; 
     85struct timeouts; 
     86struct dht_settings; 
     87struct cache_settings; 
     88struct pe_settings; 
     89struct connections; 
     90struct cache_details; 
     91 
     92 
     93struct file_details 
     94{ 
     95        file_details(boost::filesystem::wpath p,  
     96                        boost::int64_t s=0,  
     97                        boost::int64_t pg=0,  
     98                        int pr=1,  
     99                        size_t o=0,  
     100                        unsigned t=file_details::file) : 
    321101                branch(p.parent_path()), 
    322102                filename(p.filename()), 
     
    328108        {} 
    329109         
    330         bool operator==(const FileDetail& file) const 
     110        bool operator==(const file_details& file) const 
    331111        { 
    332112                return (branch == file.branch); 
    333113        } 
    334114         
    335         bool operator<(const FileDetail& file) const 
     115        bool operator<(const file_details& file) const 
    336116        { 
    337117                return (branch < file.branch); 
    338118        } 
    339119         
    340         enum FileType 
     120        enum file_type 
    341121        { 
    342122                folder, 
     
    357137}; 
    358138 
    359 inline bool FileDetailNamesEqual(const FileDetail& l, const FileDetail& r) 
     139inline bool file_details_names_equal(const file_details& l, const file_details& r) 
    360140{ 
    361141        return l.filename == r.filename; 
    362142} 
    363143 
    364 inline bool FileDetailNamesLess(const FileDetail& l, const FileDetail& r) 
     144inline bool file_details_names_less(const file_details& l, const file_details& r) 
    365145{ 
    366146        return l.filename < r.filename; 
    367147} 
    368148 
    369 typedef std::vector<FileDetail> FileDetails; 
     149typedef std::vector<file_details> file_details_vec; 
    370150 
    371151 
     
    403183                total_wanted_done_(tWD), 
    404184                total_wanted_(tW), 
    405                 totalUploaded_(tU), 
     185                total_uploaded_(tU), 
    406186                total_payload_uploaded_(tpU), 
    407187                total_downloaded_(tD), 
     
    475255        const float& distributed_copies() const { return distributed_copies_; } 
    476256         
    477         size_type total_uploaded() const { return totalUploaded_; } 
     257        size_type total_uploaded() const { return total_uploaded_; } 
    478258        size_type total_payload_uploaded() const { return total_payload_uploaded_; } 
    479259        size_type total_downloaded() const { return total_downloaded_; } 
     
    493273         
    494274        const peer_details_vec& get_peer_details() const; 
    495         const FileDetails& file_details() const; 
     275        const file_details_vec& get_file_details() const; 
    496276         
    497277        const boost::posix_time::time_duration& active() { return active_; } 
     
    519299        size_type total_wanted_done_; 
    520300        size_type total_wanted_; 
    521         size_type totalUploaded_; 
     301        size_type total_uploaded_; 
    522302        size_type total_payload_uploaded_; 
    523303        size_type total_downloaded_; 
     
    547327         
    548328        mutable bool file_details_filled_; 
    549         mutable FileDetails file_details_; 
     329        mutable file_details_vec file_details_; 
    550330}; 
    551331 
     
    931711        void get_all_peer_details(const std::string& filename, peer_details_vec& peerContainer); 
    932712        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); 
     713        void get_all_file_details(const std::string& filename, file_details_vec& file_details); 
     714        void get_all_file_details(const std::wstring& filename, file_details_vec& file_details); 
    935715         
    936716        void resume_all(); 
  • trunk/src/halTorrentInternal.hpp

    r659 r660  
    329329                ratio_(0), \ 
    330330                resolve_countries_(true), \ 
    331                 totalUploaded_(0), \ 
    332                 totalBase_(0), \ 
     331                total_uploaded_(0), \ 
     332                total_base_(0), \ 
    333333                progress_(0), \ 
    334334                managed_(false), \ 
     
    372372                if (in_session()) 
    373373                { 
    374                         statusMemory_ = handle_.status(); 
    375                         progress_ = statusMemory_.progress; 
     374                        status_memory_ = handle_.status(); 
     375                        progress_ = status_memory_.progress; 
    376376 
    377377                        queue_position_ = handle_.queue_position(); 
     
    381381                        // Wipe these cause they don't make sense for a non-active torrent. 
    382382                         
    383                         statusMemory_.download_payload_rate = 0; 
    384                         statusMemory_.upload_payload_rate = 0; 
    385                         statusMemory_.next_announce = boost::posix_time::seconds(0);             
     383                        status_memory_.download_payload_rate = 0; 
     384                        status_memory_.upload_payload_rate = 0; 
     385                        status_memory_.next_announce = boost::posix_time::seconds(0);            
    386386                } 
    387387                 
     
    407407                         
    408408                default: 
    409                         switch (statusMemory_.state) 
     409                        switch (status_memory_.state) 
    410410                        { 
    411411                        case libt::torrent_status::queued_for_checking: 
     
    438438                pt::time_duration td(pt::pos_infin); 
    439439                 
    440                 if (statusMemory_.download_payload_rate != 0) 
     440                if (status_memory_.download_payload_rate != 0) 
    441441                { 
    442442                        td = boost::posix_time::seconds(         
    443                                 long(float(statusMemory_.total_wanted-statusMemory_.total_wanted_done) / statusMemory_.download_payload_rate)); 
    444                 } 
    445                  
    446                 totalUploaded_ += (statusMemory_.total_payload_upload - totalBase_); 
    447                 totalBase_ = statusMemory_.total_payload_upload; 
    448                  
    449                 uploaded_.update(statusMemory_.total_upload); 
    450                 payload_uploaded_.update(statusMemory_.total_payload_upload); 
    451                 downloaded_.update(statusMemory_.total_download); 
    452                 payload_downloaded_.update(statusMemory_.total_payload_download); 
     443                                long(float(status_memory_.total_wanted-status_memory_.total_wanted_done) / status_memory_.download_payload_rate)); 
     444                } 
     445                 
     446                total_uploaded_ += (status_memory_.total_payload_upload - total_base_); 
     447                total_base_ = status_memory_.total_payload_upload; 
     448                 
     449                uploaded_.update(status_memory_.total_upload); 
     450                payload_uploaded_.update(status_memory_.total_payload_upload); 
     451                downloaded_.update(status_memory_.total_download); 
     452                payload_downloaded_.update(status_memory_.total_payload_download); 
    453453                 
    454454                if (is_active()) 
     
    456456                        active_duration_.update(); 
    457457                         
    458                         if (libt::torrent_status::seeding == statusMemory_.state) 
     458                        if (libt::torrent_status::seeding == status_memory_.state) 
    459459                                seeding_duration_.update(); 
    460460                }        
     
    466466                        save_directory().string(),  
    467467                        state_str,  
    468                         hal::from_utf8(statusMemory_.current_tracker),  
     468                        hal::from_utf8(status_memory_.current_tracker),  
    469469                        std::pair<float, float>( 
    470                                 statusMemory_.download_payload_rate,  
    471                                 statusMemory_.upload_payload_rate), 
     470                                status_memory_.download_payload_rate,  
     471                                status_memory_.upload_payload_rate), 
    472472                        progress_,  
    473                         statusMemory_.distributed_copies,  
    474                         statusMemory_.total_wanted_done,  
    475                         statusMemory_.total_wanted,  
     473                        status_memory_.distributed_copies,  
     474                        status_memory_.total_wanted_done,  
     475                        status_memory_.total_wanted,  
    476476                        uploaded_, payload_uploaded_, 
    477477                        downloaded_, payload_downloaded_,  
     
    479479                        ratio_,  
    480480                        td,  
    481                         statusMemory_.next_announce,  
     481                        status_memory_.next_announce,  
    482482                        active_duration_, seeding_duration_,  
    483483                        start_time_, finish_time_,  
     
    960960        void set_file_priorities(std::vector<int> fileIndices, int priority) 
    961961        { 
    962                 if (!filePriorities_.empty()) 
     962                if (!file_priorities_.empty()) 
    963963                { 
    964964                        foreach(int i, fileIndices) 
    965                                 filePriorities_[i] = priority; 
     965                                file_priorities_[i] = priority; 
    966966                                 
    967967                        apply_file_priorities(); 
     
    10041004                        ar & make_nvp("downloaded", downloaded_);                        
    10051005                                         
    1006                         ar & make_nvp("file_priorities", filePriorities_); 
     1006                        ar & make_nvp("file_priorities", file_priorities_); 
    10071007                         
    10081008                        ar & make_nvp("start_time", start_time_); 
     
    10451045                        ar & make_nvp("resolve_countries", resolve_countries_); 
    10461046                         
    1047                         ar & make_nvp("file_priorities", filePriorities_); 
     1047                        ar & make_nvp("file_priorities", file_priorities_); 
    10481048                         
    10491049                        ar & make_nvp("start_time", start_time_); 
     
    11111111        } 
    11121112 
    1113         void get_file_details(FileDetails& file_details) 
    1114         { 
    1115                 if (file_detailsMemory_.empty()) 
     1113        void get_file_details(file_details_vec& files) 
     1114        { 
     1115                if (file_details_memory_.empty()) 
    11161116                { 
    11171117                        boost::intrusive_ptr<libt::torrent_info> info = info_memory(); 
     
    11211121                                std::back_inserter(files));                                      
    11221122                                 
    1123                         if (filePriorities_.size() != files.size()) 
     1123                        if (file_priorities_.size() != files.size()) 
    11241124                        { 
    1125                                 filePriorities_.clear(); 
    1126                                 filePriorities_.assign(files.size(), 1); 
     1125                                file_priorities_.clear(); 
     1126                                file_priorities_.assign(files.size(), 1); 
    11271127                        } 
    11281128                         
     
    11321132                                boost::int64_t size = static_cast<boost::int64_t>(files[i].size); 
    11331133                                 
    1134                                 file_detailsMemory_.push_back(FileDetail(fullPath, size, 0, filePriorities_[i], i)); 
     1134                                file_details_memory_.push_back(file_details(fullPath, size, 0, file_priorities_[i], i)); 
    11351135                        }        
    11361136                }                
     
    11411141                        handle_.file_progress(fileProgress); 
    11421142                         
    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_; 
     1143                        for(size_t i=0, e=file_details_memory_.size(); i<e; ++i) 
     1144                                file_details_memory_[i].progress =  fileProgress[i];                     
     1145                } 
     1146 
     1147                for(size_t i=0, e=file_details_memory_.size(); i<e; ++i) 
     1148                        file_details_memory_[i].priority =  file_priorities_[i]; 
     1149                 
     1150                files = file_details_memory_; 
    11511151        } 
    11521152         
     
    13181318                if (in_session())  
    13191319                { 
    1320                         if (!filePriorities_.empty()) 
    1321                                 handle_.prioritize_files(filePriorities_); 
     1320                        if (!file_priorities_.empty()) 
     1321                                handle_.prioritize_files(file_priorities_); 
    13221322                         
    13231323                        HAL_DEV_MSG(L"Applying File Priorities"); 
     
    14431443        } 
    14441444                 
    1445         static libt::session* the_session_; 
    1446          
     1445        static libt::session* the_session_;      
    14471446        mutable mutex_t mutex_; 
    14481447 
     
    14711470        wstring tracker_password_; 
    14721471         
    1473         boost::int64_t totalUploaded_; 
    1474         boost::int64_t totalBase_; 
     1472        boost::int64_t total_uploaded_; 
     1473        boost::int64_t total_base_; 
    14751474         
    14761475        transfer_tracker<boost::int64_t> payload_uploaded_; 
     
    14871486        std::vector<libt::announce_entry> torrent_trackers_; 
    14881487        std::vector<libt::peer_info> peers_;     
    1489         std::vector<int> filePriorities_; 
     1488        std::vector<int> file_priorities_; 
    14901489         
    14911490        float progress_; 
    14921491         
    14931492        boost::intrusive_ptr<libt::torrent_info> info_memory_; 
    1494         libt::torrent_status statusMemory_; 
    1495         FileDetails file_detailsMemory_; 
     1493        libt::torrent_status status_memory_; 
     1494        file_details_vec file_details_memory_; 
    14961495         
    14971496        int queue_position_; 
     
    15041503typedef std::pair<std::string, TorrentInternalOld> TorrentPair; 
    15051504 
    1506 class TorrentManager :  
    1507         public hal::IniBase<TorrentManager> 
     1505class torrent_manager :  
     1506        public hal::IniBase<torrent_manager> 
    15081507{ 
    1509         typedef TorrentManager thisClass; 
     1508        typedef torrent_manager thisClass; 
    15101509        typedef hal::IniBase<thisClass> iniClass; 
    15111510 
    1512         struct TorrentHolder 
     1511        struct torrent_holder 
    15131512        { 
    15141513                mutable torrent_internal_ptr torrent; 
     
    15171516                wstring name;            
    15181517                 
    1519                 TorrentHolder() 
     1518                torrent_holder() 
    15201519                {} 
    15211520                 
    1522                 explicit TorrentHolder(torrent_internal_ptr t) : 
     1521                explicit torrent_holder(torrent_internal_ptr t) : 
    15231522                        torrent(t), filename(torrent->filename()), name(torrent->name()) 
    15241523                {} 
     
    15361535        }; 
    15371536         
    1538         struct byFilename{}; 
    1539         struct byName{}; 
     1537        struct by_filename{}; 
     1538        struct by_name{}; 
    15401539         
    15411540        typedef boost::multi_index_container< 
    1542                 TorrentHolder, 
     1541                torrent_holder, 
    15431542                boost::multi_index::indexed_by< 
    15441543                        boost::multi_index::ordered_unique< 
    1545                                 boost::multi_index::tag<byFilename>, 
     1544                                boost::multi_index::tag<by_filename>, 
    15461545                                boost::multi_index::member< 
    1547                                         TorrentHolder, wstring, &TorrentHolder::filename>  
     1546                                        torrent_holder, wstring, &torrent_holder::filename>  
    15481547                                >, 
    15491548                        boost::multi_index::ordered_unique< 
    1550                                 boost::multi_index::tag<byName>, 
     1549                                boost::multi_index::tag<by_name>, 
    15511550                                boost::multi_index::member< 
    1552                                         TorrentHolder, wstring, &TorrentHolder::name>  
     1551                                        torrent_holder, wstring, &torrent_holder::name>  
    15531552                                > 
    15541553                > 
    1555         > TorrentMultiIndex; 
     1554        > torrent_multi_index; 
    15561555         
    15571556public: 
    1558         typedef TorrentMultiIndex::index<byFilename>::type torrentByFilename; 
    1559         typedef TorrentMultiIndex::index<byName>::type torrentByName; 
    1560          
    1561         TorrentManager(ini_file& ini) : 
    1562                 iniClass("bittorrent", "TorrentManager", ini) 
     1557        typedef torrent_multi_index::index<by_filename>::type torrent_by_filename; 
     1558        typedef torrent_multi_index::index<by_name>::type torrent_by_name; 
     1559         
     1560        torrent_manager(ini_file& ini) : 
     1561                iniClass("bittorrent", "torrent_manager", ini) 
    15631562        {} 
    15641563 
    1565         std::pair<torrentByName::iterator, bool> insert(const TorrentHolder& h) 
    1566         { 
    1567                 return torrents_.get<byName>().insert(h); 
    1568         } 
    1569          
    1570         std::pair<torrentByName::iterator, bool> insert(torrent_internal_ptr t) 
    1571         { 
    1572                 return insert(TorrentHolder(t)); 
    1573         } 
    1574  
    1575         torrent_internal_ptr getByFile(const wstring& filename) 
    1576         { 
    1577                 torrentByFilename::iterator it = torrents_.get<byFilename>().find(filename); 
    1578                  
    1579                 if (it != torrents_.get<byFilename>().end() && (*it).torrent) 
     1564        std::pair<torrent_by_name::iterator, bool> insert(const torrent_holder& h) 
     1565        { 
     1566                return torrents_.get<by_name>().insert(h); 
     1567        } 
     1568         
     1569        std::pair<torrent_by_name::iterator, bool> insert(torrent_internal_ptr t) 
     1570        { 
     1571                return insert(torrent_holder(t)); 
     1572        } 
     1573 
     1574        torrent_internal_ptr get_by_file(const wstring& filename) 
     1575        { 
     1576                torrent_by_filename::iterator it = torrents_.get<by_filename>().find(filename); 
     1577                 
     1578                if (it != torrents_.get<by_filename>().end() && (*it).torrent) 
    15801579                { 
    15811580                        return (*it).torrent; 
     
    15871586        torrent_internal_ptr get(const wstring& name) 
    15881587        { 
    1589                 torrentByName::iterator it = torrents_.get<byName>().find(name); 
    1590                  
    1591                 if (it != torrents_.get<byName>().end() && (*it).torrent) 
     1588                torrent_by_name::iterator it = torrents_.get<by_name>().find(name); 
     1589                 
     1590                if (it != torrents_.get<by_name>().end() && (*it).torrent) 
    15921591                { 
    15931592                        return (*it).torrent; 
     
    15971596        } 
    15981597         
    1599         torrentByName::iterator erase(torrentByName::iterator where) 
    1600         { 
    1601                 return torrents_.get<byName>().erase(where); 
     1598        torrent_by_name::iterator erase(torrent_by_name::iterator where) 
     1599        { 
     1600                return torrents_.get<by_name>().erase(where); 
    16021601        } 
    16031602         
     
    16091608        size_t erase(const wstring& name) 
    16101609        { 
    1611                 return torrents_.get<byName>().erase(name); 
     1610                return torrents_.get<by_name>().erase(name); 
    16121611        } 
    16131612         
    16141613        bool exists(const wstring& name) 
    16151614        { 
    1616                 torrentByName::iterator it = torrents_.get<byName>().find(name); 
    1617                  
    1618                 if (it != torrents_.get<byName>().end()) 
     1615                torrent_by_name::iterator it = torrents_.get<by_name>().find(name); 
     1616                 
     1617                if (it != torrents_.get<by_name>().end()) 
    16191618                        return true; 
    16201619                else 
     
    16221621        } 
    16231622         
    1624         torrentByName::iterator begin() { return torrents_.get<byName>().begin(); } 
    1625         torrentByName::iterator end() { return torrents_.get<byName>().end(); } 
     1623        torrent_by_name::iterator begin() { return torrents_.get<by_name>().begin(); } 
     1624        torrent_by_name::iterator end() { return torrents_.get<by_name>().end(); } 
    16261625         
    16271626        friend class boost::serialization::access; 
     
    16331632         
    16341633private: 
    1635         TorrentMultiIndex torrents_; 
     1634        torrent_multi_index torrents_; 
    16361635}; 
    16371636 
    16381637} // namespace hal 
    16391638 
    1640 BOOST_CLASS_VERSION(hal::TorrentManager::TorrentHolder, 1) 
     1639BOOST_CLASS_VERSION(hal::torrent_manager::torrent_holder, 1) 
Note: See TracChangeset for help on using the changeset viewer.