Changeset 696


Ignore:
Timestamp:
01/21/09 18:45:01 (10 years ago)
Author:
kavika
Message:

Refactored some torrent_internal code to a cpp file.

Location:
trunk
Files:
1 added
4 edited

Legend:

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

    r686 r696  
    618618                        </File> 
    619619                        <File 
     620                                RelativePath="..\..\src\halTorrentInternal.cpp" 
     621                                > 
     622                        </File> 
     623                        <File 
    620624                                RelativePath="..\..\src\halTorrentIntStates.cpp" 
    621625                                > 
  • trunk/src/halSession.cpp

    r695 r696  
    3434        session_(libt::fingerprint(HALITE_FINGERPRINT)), 
    3535        keepChecking_(false), 
    36         bittorrentIni(L"BitTorrent.xml"), 
    37         the_torrents_(bittorrentIni), 
     36        bittorrent_ini_(L"BitTorrent.xml"), 
     37        the_torrents_(bittorrent_ini_), 
    3838        default_torrent_max_connections_(-1), 
    3939        default_torrent_max_uploads_(-1), 
     
    5959        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    6060                new hal::EventMsg(L"Loading BitTorrent.xml.", hal::event_logger::info)));                
    61         bittorrentIni.load_data(); 
     61        bittorrent_ini_.load_data(); 
    6262        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    6363                new hal::EventMsg(L"Loading torrent parameters.", hal::event_logger::info)));    
     
    6666                new hal::EventMsg(L"Loading done!", hal::event_logger::info))); 
    6767         
     68#       if 0 
    6869        try 
    6970        {                                                
     
    7172        { 
    7273                assert(false); 
    73 #if 0 
    7474                { 
    7575                fs::wifstream ifs(hal::app().get_working_directory()/L"Torrents.xml"); 
     
    8888                 
    8989                fs::rename(hal::app().get_working_directory()/L"Torrents.xml", hal::app().get_working_directory()/L"Torrents.xml.safe.to.delete"); 
    90 #endif 
     90 
    9191        }                        
    9292        } 
     
    9696                        new EventStdException(event_logger::fatal, e, L"Loading Old Torrents.xml"))); 
    9797        }                
    98                          
     98#       endif 
     99 
    99100        if (exists(hal::app().get_working_directory()/L"DHTState.bin")) 
    100101        { 
     
    188189} 
    189190 
    190 void  bit_impl::ip_filter_import(std::vector<libt::ip_range<boost::asio::ip::address_v4> >& v4, 
     191void bit_impl::ip_filter_import(std::vector<libt::ip_range<boost::asio::ip::address_v4> >& v4, 
    191192        std::vector<libt::ip_range<boost::asio::ip::address_v6> >& v6) 
    192193{ 
     
    260261                                try 
    261262                                {                        
    262                                 ip_filter_.add_rule(boost::asio::ip::address_v4::from_string(first), 
    263                                         boost::asio::ip::address_v4::from_string(last), libt::ip_filter::blocked);       
     263                                        ip_filter_.add_rule(boost::asio::ip::address_v4::from_string(first), 
     264                                                boost::asio::ip::address_v4::from_string(last), libt::ip_filter::blocked);       
    264265                                } 
    265266                                catch(...) 
     
    519520                        get(a.handle)->locked_process_event(ev_error_alert(err)); 
    520521                } 
    521  
    522522        } 
    523523         
     
    609609        void operator()(libt::tracker_announce_alert const& a) const 
    610610        { 
    611                 HAL_DEV_MSG(hal::wform(L"HAL_TRACKER_ANNOUNCE_ALERT")); 
    612  
    613611                event_log.post(shared_ptr<EventDetail>( 
    614612                        new EventMsg((hal::wform(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT))  
  • trunk/src/halSession.hpp

    r695 r696  
    10941094                 
    10951095                the_torrents_.save_to_ini(); 
    1096                 bittorrentIni.save_data(); 
     1096                bittorrent_ini_.save_data(); 
    10971097                         
    10981098                if (dht_on_)  
     
    11231123        bool keepChecking_; 
    11241124         
    1125         ini_file bittorrentIni; 
     1125        ini_file bittorrent_ini_; 
    11261126        torrent_manager the_torrents_;   
    11271127         
  • trunk/src/halTorrentInternal.hpp

    r695 r696  
    363363        } 
    364364         
    365         torrent_details_ptr get_torrent_details_ptr() 
    366         {        
    367                 mutex_t::scoped_lock l(mutex_); 
    368  
    369                 try 
    370                 { 
    371  
    372                 if (in_session()) 
    373                 { 
    374                         status_memory_ = handle_.status(); 
    375                         progress_ = status_memory_.progress; 
    376  
    377                         queue_position_ = handle_.queue_position(); 
    378                 } 
    379                 else 
    380                 { 
    381                         // Wipe these cause they don't make sense for a non-active torrent. 
    382                          
    383                         status_memory_.download_payload_rate = 0; 
    384                         status_memory_.upload_payload_rate = 0; 
    385                         status_memory_.next_announce = boost::posix_time::seconds(0);            
    386                 } 
    387                  
    388                 wstring state_str; 
    389                  
    390                 switch (state()) 
    391                 { 
    392                 case torrent_details::torrent_paused: 
    393                         state_str = app().res_wstr(HAL_TORRENT_PAUSED); 
    394                         break; 
    395                          
    396                 case torrent_details::torrent_pausing: 
    397                         state_str = app().res_wstr(HAL_TORRENT_PAUSING); 
    398                         break; 
    399                          
    400                 case torrent_details::torrent_stopped: 
    401                         state_str = app().res_wstr(HAL_TORRENT_STOPPED); 
    402                         break; 
    403                          
    404                 case torrent_details::torrent_stopping: 
    405                         state_str = app().res_wstr(HAL_TORRENT_STOPPING); 
    406                         break; 
    407                          
    408                 case torrent_details::torrent_in_error: 
    409                         state_str = app().res_wstr(HAL_TORRENT_IN_ERROR); 
    410                         break; 
    411                          
    412                 default: 
    413                         switch (status_memory_.state) 
    414                         { 
    415                         case libt::torrent_status::queued_for_checking: 
    416                                 state_str = app().res_wstr(HAL_TORRENT_QUEUED_CHECKING); 
    417                                 break; 
    418                         case libt::torrent_status::checking_files: 
    419                                 state_str = app().res_wstr(HAL_TORRENT_CHECKING_FILES); 
    420                                 break; 
    421 //                      case libt::torrent_status::connecting_to_tracker: 
    422 //                              state = app().res_wstr(HAL_TORRENT_CONNECTING); 
    423 //                              break; 
    424                         case libt::torrent_status::downloading_metadata: 
    425                                 state_str = app().res_wstr(HAL_TORRENT_METADATA); 
    426                                 break; 
    427                         case libt::torrent_status::downloading: 
    428                                 state_str = app().res_wstr(HAL_TORRENT_DOWNLOADING); 
    429                                 break; 
    430                         case libt::torrent_status::finished: 
    431                                 state_str = app().res_wstr(HAL_TORRENT_FINISHED); 
    432                                 break; 
    433                         case libt::torrent_status::seeding: 
    434                                 state_str = app().res_wstr(HAL_TORRENT_SEEDING); 
    435                                 break; 
    436                         case libt::torrent_status::allocating: 
    437                                 state_str = app().res_wstr(HAL_TORRENT_ALLOCATING); 
    438                                 break; 
    439                         }        
    440                 } 
    441                  
    442                 pt::time_duration td(pt::pos_infin); 
    443                  
    444                 if (status_memory_.download_payload_rate != 0) 
    445                 { 
    446                         td = boost::posix_time::seconds(         
    447                                 long(float(status_memory_.total_wanted-status_memory_.total_wanted_done) / status_memory_.download_payload_rate)); 
    448                 } 
    449                  
    450                 total_uploaded_ += (status_memory_.total_payload_upload - total_base_); 
    451                 total_base_ = status_memory_.total_payload_upload; 
    452                  
    453                 uploaded_.update(status_memory_.total_upload); 
    454                 payload_uploaded_.update(status_memory_.total_payload_upload); 
    455                 downloaded_.update(status_memory_.total_download); 
    456                 payload_downloaded_.update(status_memory_.total_payload_download); 
    457                  
    458                 if (is_active()) 
    459                 { 
    460                         active_duration_.update(); 
    461                          
    462                         if (libt::torrent_status::seeding == status_memory_.state) 
    463                                 seeding_duration_.update(); 
    464                 }        
    465                  
    466                 boost::tuple<size_t, size_t, size_t, size_t> connections = update_peers();       
    467  
    468                 return torrent_details_ptr(new torrent_details( 
    469                         name_, filename_,  
    470                         save_directory().string(),  
    471                         state_str,  
    472                         hal::from_utf8(status_memory_.current_tracker),  
    473                         std::pair<float, float>( 
    474                                 status_memory_.download_payload_rate,  
    475                                 status_memory_.upload_payload_rate), 
    476                         progress_,  
    477                         status_memory_.distributed_copies,  
    478                         status_memory_.total_wanted_done,  
    479                         status_memory_.total_wanted,  
    480                         uploaded_, payload_uploaded_, 
    481                         downloaded_, payload_downloaded_,  
    482                         connections,  
    483                         ratio_,  
    484                         td,  
    485                         status_memory_.next_announce,  
    486                         active_duration_, seeding_duration_,  
    487                         start_time_, finish_time_,  
    488                         queue_position_, 
    489                         is_managed())); 
    490  
    491                 } 
    492                 catch (const libt::invalid_handle&) 
    493                 { 
    494                         event_log.post(shared_ptr<EventDetail>( 
    495                                 new EventInvalidTorrent(event_logger::critical, event_logger::invalid_torrent, to_utf8(name_), "get_torrent_details_ptr"))); 
    496                 } 
    497                 catch (const std::exception& e) 
    498                 { 
    499                         event_log.post(shared_ptr<EventDetail>( 
    500                                 new EventTorrentException(event_logger::critical, event_logger::torrentException, e.what(), to_utf8(name_), "get_torrent_details_ptr"))); 
    501                 } 
    502                  
    503                 return torrent_details_ptr(new torrent_details( 
    504                         name_, filename_,  
    505                         save_directory().string(),  
    506                         app().res_wstr(HAL_TORRENT_STOPPED),  
    507                         app().res_wstr(HAL_NA))); 
    508         } 
    509  
    510         void adjust_queue_position(bit::queue_adjustments adjust) 
    511         { 
    512                 if (in_session() && is_managed()) 
    513                 { 
    514                         switch (adjust) 
    515                         { 
    516                         case bit::move_up: 
    517                                 handle_.queue_position_up(); 
    518                                 break; 
    519                         case bit::move_down: 
    520                                 handle_.queue_position_down(); 
    521                                 break; 
    522                         case bit::move_to_top: 
    523                                 handle_.queue_position_top(); 
    524                                 break; 
    525                         case bit::move_to_bottom: 
    526                                 handle_.queue_position_bottom(); 
    527                                 break; 
    528                         }; 
    529                 } 
    530         } 
     365        torrent_details_ptr get_torrent_details_ptr(); 
     366 
     367        void adjust_queue_position(bit::queue_adjustments adjust); 
    531368 
    532369        void set_transfer_speed(float down, float up) 
     
    592429        } 
    593430         
    594         void add_to_session(bool paused = false) 
    595         { 
    596                 try 
    597                 { 
    598                 HAL_DEV_MSG(hal::wform(L"add_to_session() paused=%1%") % paused); 
    599  
    600                 mutex_t::scoped_lock l(mutex_);  
    601                 assert(the_session_ != 0); 
    602  
    603                 process_event(ev_add_to_session(paused)); 
    604                  
    605                 assert(in_session()); 
    606                 HAL_DEV_MSG(L"Added to session"); 
    607  
    608                 } 
    609                 catch(std::exception& e) 
    610                 { 
    611                         hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    612                                 new hal::EventStdException(event_logger::critical, e, L"add_to_session")));  
    613                 } 
    614         } 
    615          
    616         bool remove_from_session(bool write_data=true) 
    617         { 
    618                 try 
    619                 { 
    620                 HAL_DEV_MSG(hal::wform(L"remove_from_session() write_data=%1%") % write_data); 
    621  
    622                 mutex_t::scoped_lock l(mutex_); 
    623                  
    624                 process_event(ev_remove_from_session(write_data)); 
    625  
    626                 return true; 
    627  
    628                 } 
    629                 catch(std::exception& e) 
    630                 { 
    631                         hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    632                                 new hal::EventStdException(event_logger::critical, e, L"remove_from_session()")));  
    633                         return false; 
    634                 } 
    635         } 
     431        void add_to_session(bool paused = false); 
     432         
     433        bool remove_from_session(bool write_data=true); 
    636434 
    637435        bool in_session() const 
     
    706504                if (exists(resume_file)) 
    707505                        remove(resume_file); 
    708  
    709 //              resumedata_ = libt::entry(); 
    710506        } 
    711507 
     
    759555                                                s == libt::torrent_status::finished); 
    760556                } 
    761                 else return false; 
     557                else  
     558                        return false; 
    762559        } 
    763560         
     
    852649    template<class Archive> 
    853650    void serialize(Archive& ar, const unsigned int version) 
    854     { 
     651        { 
    855652                using boost::serialization::make_nvp; 
    856653 
     
    866663                        ar & make_nvp("progress", progress_); 
    867664                        ar & make_nvp("state", state_); 
    868 //                      ar & make_nvp("compact_storage", compact_storage_);      
     665        //                      ar & make_nvp("compact_storage", compact_storage_);      
    869666                        ar & make_nvp("allocation_type", allocation_);   
    870667                        ar & make_nvp("resolve_countries", resolve_countries_);  
     
    888685                        ar & make_nvp("active_duration", active_duration_); 
    889686                        ar & make_nvp("seeding_duration", seeding_duration_); 
    890                         ar & make_nvp("managed", managed_); 
    891                                          
     687                        ar & make_nvp("managed", managed_);                              
    892688                }  
    893689                else  
    894690                { 
    895                     ar & make_nvp("transferLimit", transfer_limit_); 
     691                        ar & make_nvp("transferLimit", transfer_limit_); 
    896692                        ar & make_nvp("connections", connections_); 
    897693                        ar & make_nvp("uploads", uploads_);                      
     
    934730                         
    935731                        ar & make_nvp("progress", progress_); 
    936         } 
    937     } 
     732                } 
     733        } 
    938734 
    939735        void set_entry_data(boost::intrusive_ptr<libt::torrent_info> metadata, libtorrent::entry resumedata) 
    940736        {                
    941737                info_memory_ = metadata; 
    942 //              resumedata_ = resumedata; 
    943738        } 
    944739 
    945740        std::vector<libt::peer_info>& peers() { return peers_; } 
    946741         
    947         boost::tuple<size_t, size_t, size_t, size_t> update_peers() 
    948         { 
    949                 if (in_session()) 
    950                         handle_.get_peer_info(peers_); 
    951                  
    952                 size_t totalPeers = 0; 
    953                 size_t peersConnected = 0; 
    954                 size_t totalSeeds = 0; 
    955                 size_t seedsConnected = 0; 
    956                  
    957                 foreach (libt::peer_info& peer, peers_)  
    958                 { 
    959                         float speedSum = peer.down_speed + peer.up_speed; 
    960                          
    961                         if (!(peer.flags & libt::peer_info::seed)) 
    962                         { 
    963                                 ++totalPeers; 
    964                                  
    965                                 if (speedSum > 0) 
    966                                         ++peersConnected; 
    967                         } 
    968                         else 
    969                         { 
    970                                 ++totalSeeds; 
    971                                  
    972                                 if (speedSum > 0) 
    973                                         ++seedsConnected; 
    974                         } 
    975                 }        
    976                  
    977                 return boost::make_tuple(totalPeers, peersConnected, totalSeeds, seedsConnected); 
    978         } 
     742        boost::tuple<size_t, size_t, size_t, size_t> update_peers(); 
    979743         
    980744        void get_peer_details(peer_details_vec& peer_details) const 
     
    989753        } 
    990754 
    991         void get_file_details(file_details_vec& files) 
    992         { 
    993                 if (file_details_memory_.empty()) 
    994                 { 
    995                         boost::intrusive_ptr<libt::torrent_info> info = info_memory(); 
    996                         std::vector<libt::file_entry> files; 
    997                          
    998                         std::copy(info->begin_files(), info->end_files(),  
    999                                 std::back_inserter(files));                                      
    1000                                  
    1001                         if (file_priorities_.size() != files.size()) 
    1002                         { 
    1003                                 file_priorities_.clear(); 
    1004                                 file_priorities_.assign(files.size(), 1); 
    1005                         } 
    1006                          
    1007                         for(size_t i=0, e=files.size(); i<e; ++i) 
    1008                         { 
    1009                                 wstring fullPath = hal::from_utf8(files[i].path.string()); 
    1010                                 boost::int64_t size = static_cast<boost::int64_t>(files[i].size); 
    1011                                  
    1012                                 file_details_memory_.push_back(file_details(fullPath, size, 0, file_priorities_[i], i)); 
    1013                         }        
    1014                 }                
    1015                  
    1016                 if (in_session()) 
    1017                 {                        
    1018                         std::vector<libt::size_type> fileProgress;                       
    1019                         handle_.file_progress(fileProgress); 
    1020                          
    1021                         for(size_t i=0, e=file_details_memory_.size(); i<e; ++i) 
    1022                                 file_details_memory_[i].progress =  fileProgress[i];                     
    1023                 } 
    1024  
    1025                 for(size_t i=0, e=file_details_memory_.size(); i<e; ++i) 
    1026                         file_details_memory_[i].priority =  file_priorities_[i]; 
    1027                  
    1028                 files = file_details_memory_; 
    1029         } 
    1030          
    1031         void prepare(wpath filename) 
    1032         { 
    1033                 mutex_t::scoped_lock l(mutex_); 
    1034                  
    1035                 if (fs::exists(filename))  
    1036                         info_memory_ = new libt::torrent_info(path_to_utf8(filename)); 
    1037                  
    1038                 extract_names(info_memory());                    
    1039                  
    1040                 const wpath resumeFile = hal::app().get_working_directory()/L"resume"/filename_; 
    1041                 const wpath torrentFile = hal::app().get_working_directory()/L"torrents"/filename_; 
    1042                  
    1043                 event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    1044                         hal::wform(L"File: %1%, %2%.") % resumeFile % torrentFile))); 
    1045                  
    1046         //      if (exists(resumeFile))  
    1047         //              resumedata_ = haldecode(resumeFile); 
    1048  
    1049                 if (!exists(hal::app().get_working_directory()/L"torrents")) 
    1050                         create_directory(hal::app().get_working_directory()/L"torrents"); 
    1051  
    1052                 if (!exists(torrentFile)) 
    1053                         copy_file(filename.string(), torrentFile); 
    1054  
    1055                 if (!fs::exists(save_directory_)) 
    1056                         fs::create_directory(save_directory_); 
    1057  
    1058                 // These here should not make state changes based on torrent  
    1059                 // session status since it has not been initialized yet. 
    1060                 if (state_ == torrent_details::torrent_stopping) 
    1061                         state(torrent_details::torrent_stopped); 
    1062                 else if (state_ == torrent_details::torrent_pausing) 
    1063                         state(torrent_details::torrent_paused); 
    1064         } 
     755        void get_file_details(file_details_vec& files); 
     756         
     757        void prepare(wpath filename); 
    1065758 
    1066759        void set_resolve_countries(bool b) 
     
    1070763        } 
    1071764         
    1072         void extract_names(boost::intrusive_ptr<libt::torrent_info> metadata) 
    1073         { 
    1074                 mutex_t::scoped_lock l(mutex_); 
    1075                                  
    1076                 name_ = hal::from_utf8_safe(metadata->name()); 
    1077                  
    1078                 filename_ = name_; 
    1079                 if (!boost::find_last(filename_, L".torrent"))  
    1080                                 filename_ += L".torrent"; 
    1081                  
    1082                 event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    1083                         hal::wform(L"Loaded names: %1%, %2%") % name_ % filename_))); 
    1084         } 
     765        void extract_names(boost::intrusive_ptr<libt::torrent_info> metadata); 
    1085766         
    1086767        boost::intrusive_ptr<libt::torrent_info> info_memory() 
    1087768        { 
    1088769                if (!info_memory_)  
    1089                         info_memory_ =  
    1090                                 boost::intrusive_ptr<libt::torrent_info>(new libt::torrent_info(path_to_utf8(filename()))); 
     770                        info_memory_ = boost::intrusive_ptr<libt::torrent_info> 
     771                                (new libt::torrent_info(path_to_utf8(filename()))); 
    1091772                 
    1092773                return info_memory_; 
     
    1101782        unsigned state() const  
    1102783        {  
    1103                 if (in_session()) 
    1104                 { 
    1105 /*                      if (handle_.is_paused()) 
    1106                         { 
    1107                                 if (state_ != torrent_details::torrent_paused) 
    1108                                 {                        
    1109                                         HAL_DEV_MSG(L"Should really be paused!"); 
    1110                                         state_ = torrent_details::torrent_paused; 
    1111                                 } 
    1112                         } 
    1113                         else                             
    1114                         {                        
    1115                                 if (state_ != torrent_details::torrent_active && 
    1116                                         state_ != torrent_details::torrent_pausing && 
    1117                                         state_ != torrent_details::torrent_stopping) 
    1118                                 {                        
    1119                                         HAL_DEV_MSG(L"Should really be active!"); 
    1120                                         state_ = torrent_details::torrent_active; 
    1121                                 } 
    1122                         }                       */               
    1123                 } 
    1124                 else 
     784                if (!in_session()) 
    1125785                { 
    1126786                        if (state_ != torrent_details::torrent_stopped) 
     
    1149809        static libt::session* the_session_;      
    1150810 
    1151 private:         
     811private: 
     812        void apply_settings();   
     813        void apply_transfer_speed(); 
     814        void apply_connection_limit();   
     815        void apply_ratio();      
     816        void apply_trackers();   
     817        void apply_tracker_login();      
     818        void apply_file_priorities();    
     819        void apply_resolve_countries(); 
     820        void state(unsigned s); 
     821 
     822        mutable mutex_t mutex_; 
    1152823        signalers signals_; 
    1153  
    1154         void apply_settings() 
    1155         {                
    1156                 apply_transfer_speed(); 
    1157                 apply_connection_limit(); 
    1158                 apply_ratio(); 
    1159                 apply_trackers(); 
    1160                 apply_tracker_login(); 
    1161                 apply_file_priorities(); 
    1162                 apply_resolve_countries(); 
    1163         } 
    1164          
    1165         void apply_transfer_speed() 
    1166         { 
    1167                 mutex_t::scoped_lock l(mutex_); 
    1168                 if (in_session()) 
    1169                 { 
    1170                         int down = (transfer_limit_.first > 0) ? static_cast<int>(transfer_limit_.first*1024) : -1; 
    1171                         handle_.set_download_limit(down); 
    1172                          
    1173                         int up = (transfer_limit_.second > 0) ? static_cast<int>(transfer_limit_.second*1024) : -1; 
    1174                         handle_.set_upload_limit(up); 
    1175  
    1176                         HAL_DEV_MSG(hal::wform(L"Applying Transfer Speed %1% - %2%") % down % up); 
    1177                 } 
    1178         } 
    1179  
    1180         void apply_connection_limit() 
    1181         { 
    1182                 mutex_t::scoped_lock l(mutex_); 
    1183                 if (in_session()) 
    1184                 { 
    1185                         handle_.set_max_connections(connections_); 
    1186                         handle_.set_max_uploads(uploads_); 
    1187  
    1188                         HAL_DEV_MSG(hal::wform(L"Applying Connection Limit %1% - %2%") % connections_ % uploads_); 
    1189                 } 
    1190         } 
    1191          
    1192         void apply_ratio() 
    1193         {  
    1194                 mutex_t::scoped_lock l(mutex_); 
    1195                 if (in_session()) 
    1196                 { 
    1197                         handle_.set_ratio(ratio_); 
    1198  
    1199                         HAL_DEV_MSG(hal::wform(L"Applying Ratio %1%") % ratio_); 
    1200                 } 
    1201         } 
    1202          
    1203         void apply_trackers() 
    1204         { 
    1205                 mutex_t::scoped_lock l(mutex_); 
    1206                 if (in_session()) 
    1207                 { 
    1208                         if (torrent_trackers_.empty()) 
    1209                                 torrent_trackers_ = handle_.trackers(); 
    1210                          
    1211                         if (!trackers_.empty()) 
    1212                         { 
    1213                                 std::vector<libt::announce_entry> trackers; 
    1214                                  
    1215                                 foreach (const tracker_detail& tracker, trackers_) 
    1216                                 { 
    1217                                         trackers.push_back( 
    1218                                                 libt::announce_entry(hal::to_utf8(tracker.url))); 
    1219                                         trackers.back().tier = tracker.tier; 
    1220                                 } 
    1221                                 handle_.replace_trackers(trackers); 
    1222                         } 
    1223                          
    1224                         HAL_DEV_MSG(L"Applying Trackers"); 
    1225                 } 
    1226         } 
    1227          
    1228         void apply_tracker_login() 
    1229         { 
    1230                 mutex_t::scoped_lock l(mutex_); 
    1231                 if (in_session()) 
    1232                 { 
    1233                         if (tracker_username_ != L"") 
    1234                         { 
    1235                                 handle_.set_tracker_login(hal::to_utf8(tracker_username_), 
    1236                                         hal::to_utf8(tracker_password_)); 
    1237                         } 
    1238  
    1239                         HAL_DEV_MSG(hal::wform(L"Applying Tracker Login User: %1%, Pass: %2%") 
    1240                                 % tracker_username_ % tracker_password_ ); 
    1241                 } 
    1242         } 
    1243          
    1244         void apply_file_priorities() 
    1245         {                
    1246                 mutex_t::scoped_lock l(mutex_); 
    1247                 if (in_session())  
    1248                 { 
    1249                         if (!file_priorities_.empty()) 
    1250                                 handle_.prioritize_files(file_priorities_); 
    1251                          
    1252                         HAL_DEV_MSG(L"Applying File Priorities"); 
    1253                 } 
    1254         }        
    1255          
    1256         void apply_resolve_countries() 
    1257         { 
    1258                 mutex_t::scoped_lock l(mutex_); 
    1259                 if (in_session()) 
    1260                 { 
    1261                         handle_.resolve_countries(resolve_countries_); 
    1262                          
    1263                         HAL_DEV_MSG(hal::wform(L"Applying Resolve Countries %1%") % resolve_countries_); 
    1264                 } 
    1265         } 
    1266  
    1267         void state(unsigned s) 
    1268         { 
    1269                 switch (s) 
    1270                 { 
    1271                 case torrent_details::torrent_stopped: 
    1272                         HAL_DEV_MSG(L"state() - stopped"); 
    1273                         break; 
    1274                 case torrent_details::torrent_stopping: 
    1275                         HAL_DEV_MSG(L"state() - stopping"); 
    1276                         break; 
    1277                 case torrent_details::torrent_pausing: 
    1278                         HAL_DEV_MSG(L"state() - pausing"); 
    1279                         break; 
    1280                 case torrent_details::torrent_active: 
    1281                         HAL_DEV_MSG(L"state() - active"); 
    1282                         break; 
    1283                 case torrent_details::torrent_paused: 
    1284                         HAL_DEV_MSG(L"state() - paused"); 
    1285                         break; 
    1286                 case torrent_details::torrent_in_error: 
    1287                         HAL_DEV_MSG(L"state() - in error"); 
    1288                         break; 
    1289                 default: 
    1290                         HAL_DEV_MSG(L"state() - unknown"); 
    1291                         break; 
    1292                 }; 
    1293                 state_ = s; 
    1294         } 
    1295                  
    1296         mutable mutex_t mutex_; 
    1297824         
    1298825        std::pair<float, float> transfer_limit_; 
     
    1300827        mutable unsigned state_; 
    1301828        bool awaiting_resume_data_; 
    1302  
    1303829        int connections_; 
    1304830        int uploads_; 
     
    1313839        wstring original_filename_; 
    1314840        libt::torrent_handle handle_;    
    1315          
    1316 //      boost::intrusive_ptr<libt::torrent_info> metadata_; 
    1317 //      boost::shared_ptr<libt::entry> resumedata_; 
    1318          
    1319841        wstring tracker_username_;       
    1320842        wstring tracker_password_; 
     
    1338860        std::vector<int> file_priorities_; 
    1339861         
    1340         float progress_; 
    1341          
    1342         boost::intrusive_ptr<libt::torrent_info> info_memory_; 
    1343         libt::torrent_status status_memory_; 
    1344         file_details_vec file_details_memory_; 
    1345          
     862        float progress_;         
    1346863        int queue_position_; 
    1347864        bool compact_storage_; 
    1348865        bool managed_; 
    1349866        bit::allocations allocation_; 
     867         
     868        boost::intrusive_ptr<libt::torrent_info> info_memory_; 
     869        libt::torrent_status status_memory_; 
     870        file_details_vec file_details_memory_; 
    1350871}; 
    1351872 
Note: See TracChangeset for help on using the changeset viewer.