Changeset 482


Ignore:
Timestamp:
06/07/08 18:47:30 (12 years ago)
Author:
Eoin
Message:

... not yet it doesn't!

Location:
trunk/src
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/ConfigOptions.hpp

    r478 r482  
    546546        void onFilterClear(UINT, int, HWND hWnd) 
    547547        { 
    548                 hal::bittorrent().clearIpFilter(); 
     548                hal::bittorrent().clear_ip_filter(); 
    549549        } 
    550550 
  • trunk/src/HaliteDialog.cpp

    r455 r482  
    130130                string torrentName = hal::to_utf8(torrent->name()); 
    131131 
    132                 hal::bittorrent().removeTorrent(torrentName); 
     132                hal::bittorrent().remove_torrent(torrentName); 
    133133                torrentsList().clearFocused(); 
    134134        } 
  • trunk/src/HaliteListView.cpp

    r467 r482  
    146146LRESULT HaliteListViewCtrl::OnRemoveFocused(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    147147{ 
    148         hal::bittorrent().removeTorrent(hal::to_utf8(manager_.selected())); 
     148        hal::bittorrent().remove_torrent(hal::to_utf8(manager_.selected())); 
    149149 
    150150        clearFocused();  
     
    155155{ 
    156156        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    157                 bind((void (hal::bit::*)(const std::wstring&))&hal::bit::removeTorrent,  
     157                bind((void (hal::bit::*)(const std::wstring&))&hal::bit::remove_torrent,  
    158158                        &hal::bittorrent(), _1)); 
    159159 
     
    177177        { 
    178178                std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    179                         bind((void (hal::bit::*)(const std::wstring&))&hal::bit::removeTorrentWipeFiles,  
     179                        bind((void (hal::bit::*)(const std::wstring&))&hal::bit::remove_torrent_wipe_files,  
    180180                                &hal::bittorrent(), _1)); 
    181181                 
  • trunk/src/HaliteWindow.cpp

    r478 r482  
    289289 
    290290                hal::ini().save_data(); 
    291                 hal::bittorrent().saveTorrentData();     
     291                hal::bittorrent().save_torrent_data();   
    292292         
    293293                } 
     
    368368         
    369369        wpath file(lpszPath, boost::filesystem::native);         
    370         hal::bittorrent().addTorrent(file, wpath(saveDirectory), startPaused, compactStorage,  
     370        hal::bittorrent().add_torrent(file, wpath(saveDirectory), startPaused, compactStorage,  
    371371                wpath(moveToDirectory), useMoveTo); 
    372372 
     
    401401void HaliteWindow::ShutdownThread() 
    402402{ 
    403         hal::bittorrent().closeAll(0); 
     403        hal::bittorrent().close_all(0); 
    404404 
    405405        hal::bittorrent().stopEventReceiver(); 
  • trunk/src/SplashDialog.hpp

    r478 r482  
    108108        void SplashThread() 
    109109        { 
    110                 hal::bittorrent().closeAll(boost::optional<boost::function<void (int)> >(bind(&SplashDialog::ReportNumActive, this, _1))); 
     110                hal::bittorrent().close_all(boost::optional<boost::function<void (int)> >(bind(&SplashDialog::ReportNumActive, this, _1))); 
    111111                 
    112112                SetDlgItemText(HAL_CSPLASH_NUM_ACT, hal::app().res_wstr(HAL_CSPLASH_SHUTDOWN_MSG).c_str()); 
  • trunk/src/halConfig.cpp

    r478 r482  
    2626        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Applying BitTorrent session settings.")));         
    2727 
    28         bittorrent().setMapping(mappingType);    
     28        bittorrent().set_mapping(mappingType);   
    2929 
    3030        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
     
    3232        try 
    3333        { 
    34         bool success = bittorrent().listenOn( 
     34        bool success = bittorrent().listen_on( 
    3535                std::make_pair(portFrom, portTo)); 
    3636        if (!success) 
     
    5050        } 
    5151 
    52         event_log.post(shared_ptr<EventDetail>(new EventMsg(wformat(L"Opened listen port; %1%.") % bittorrent().isListeningOn()))); 
     52        event_log.post(shared_ptr<EventDetail>(new EventMsg(wformat(L"Opened listen port; %1%.") % bittorrent().is_listening_on()))); 
    5353         
    5454        try 
     
    5757        { 
    5858                ProgressDialog progDlg(L"Loading IP filters...", bind( 
    59                         &bit::ensureIpFilterOn, &bittorrent(), _1)); 
     59                        &bit::ensure_ip_filter_on, &bittorrent(), _1)); 
    6060                progDlg.DoModal(); 
    6161        } 
    6262        else 
    63                 bittorrent().ensureIpFilterOff(); 
     63                bittorrent().ensure_ip_filter_off(); 
    6464        } 
    6565        catch(const std::exception& e) 
     
    7373        if (enablePe) 
    7474        { 
    75                 bittorrent().ensurePeOn(peEncLevel, peConInPolicy, peConOutPolicy, pePerferRc4); 
     75                bittorrent().ensure_pe_on(peEncLevel, peConInPolicy, peConOutPolicy, pePerferRc4); 
    7676        } 
    7777        else 
    78                 bittorrent().ensurePeOff(); 
     78                bittorrent().ensure_pe_off(); 
    7979        } 
    8080        catch(const std::exception& e) 
     
    8686        bittorrent().setSessionHalfOpenLimit(halfConnLimit); 
    8787         
    88         bittorrent().resumeAll();        
     88        bittorrent().resume_all();       
    8989         
    90         bittorrent().setSessionLimits( 
     90        bittorrent().set_session_limits( 
    9191                maxConnections, maxUploads); 
    92         bittorrent().setSessionSpeed( 
     92        bittorrent().set_session_speed( 
    9393                downRate, upRate); 
    9494                 
     
    9797                torrentUpRate); 
    9898         
    99         bittorrent().setDhtSettings(dhtMaxPeersReply,  
     99        bittorrent().set_dht_settings(dhtMaxPeersReply,  
    100100                dhtSearchBranching, dhtServicePort,  
    101101                dhtMaxFailCount); 
    102102 
    103         bittorrent().setTimeouts(peerTimeout, trackerTimeout); 
     103        bittorrent().set_timeouts(peerTimeout, trackerTimeout); 
    104104         
    105105        if (enableDHT) 
    106106        { 
    107                 if (!bittorrent().ensureDhtOn()) 
     107                if (!bittorrent().ensure_dht_on()) 
    108108                { 
    109                         bittorrent().ensureDhtOff(); 
     109                        bittorrent().ensure_dht_off(); 
    110110                         
    111111                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     
    114114        } 
    115115        else 
    116                 bittorrent().ensureDhtOff(); 
     116                bittorrent().ensure_dht_off(); 
    117117                 
    118118        // Settings seem to have applied ok! 
  • trunk/src/halSession.cpp

    r480 r482  
    162162} 
    163163 
    164 void bit_impl::stopAlertHandler() 
     164void bit_impl::stop_alert_handler() 
    165165{ 
    166166        mutex_t::scoped_lock l(mutex_); 
     
    169169} 
    170170         
    171 void bit_impl::alertHandler() 
     171void bit_impl::alert_handler() 
    172172{ 
    173173        mutex_t::scoped_lock l(mutex_); 
     
    381381                torrent_internal_ptr get(libt::torrent_handle h) const  
    382382                {  
    383                         return bit_impl_.theTorrents.get(from_utf8_safe(h.get_torrent_info().name()));  
     383                        return bit_impl_.the_torrents_.get(from_utf8_safe(h.get_torrent_info().name()));  
    384384                } 
    385385         
     
    428428         
    429429        timer_.expires_from_now(boost::posix_time::seconds(2)); 
    430         timer_.async_wait(bind(&bit_impl::alertHandler, this)); 
    431         } 
    432 } 
    433  
    434 } 
     430        timer_.async_wait(bind(&bit_impl::alert_handler, this)); 
     431        } 
     432} 
     433 
     434} 
  • trunk/src/halSession.hpp

    r481 r482  
    237237        ~bit_impl() 
    238238        { 
    239                 stopAlertHandler(); 
    240                  
    241                 //saveTorrentData(); 
     239                stop_alert_handler(); 
     240                 
     241                //save_torrent_data(); 
    242242                 
    243243                try 
     
    268268        } 
    269269 
    270         bool listenOn(std::pair<int, int> const& range) 
     270        bool listen_on(std::pair<int, int> const& range) 
    271271        { 
    272272                try 
     
    305305        } 
    306306 
    307         int isListeningOn()  
     307        int is_listening_on()  
    308308        { 
    309309                if (!session_.is_listening()) 
     
    313313        } 
    314314 
    315         void stopListening() 
    316         { 
    317                 ensureDhtOff(); 
     315        void stop_listening() 
     316        { 
     317                ensure_dht_off(); 
    318318                session_.listen_on(std::make_pair(0, 0)); 
    319319        } 
    320320 
    321         bool ensureDhtOn() 
     321        bool ensure_dht_on() 
    322322        { 
    323323                if (!dht_on_) 
     
    334334        } 
    335335 
    336         void ensureDhtOff() 
     336        void ensure_dht_off() 
    337337        { 
    338338                if (dht_on_) 
     
    343343        } 
    344344 
    345         void setDhtSettings(int max_peers_reply, int search_branching,  
     345        void set_dht_settings(int max_peers_reply, int search_branching,  
    346346                int service_port, int max_fail_count) 
    347347        { 
     
    359359        } 
    360360 
    361         void setMapping(int mapping) 
     361        void set_mapping(int mapping) 
    362362        { 
    363363                if (mapping != bit::mappingNone) 
     
    388388        } 
    389389 
    390         void setTimeouts(int peers, int tracker) 
     390        void set_timeouts(int peers, int tracker) 
    391391        { 
    392392                libt::session_settings settings = session_.settings(); 
     
    400400        } 
    401401 
    402         void setSessionLimits(int maxConn, int maxUpload) 
     402        void set_session_limits(int maxConn, int maxUpload) 
    403403        {                
    404404                session_.set_max_uploads(maxUpload); 
     
    410410        } 
    411411 
    412         void setSessionSpeed(float download, float upload) 
     412        void set_session_speed(float download, float upload) 
    413413        { 
    414414                int down = (download > 0) ? static_cast<int>(download*1024) : -1; 
     
    422422        } 
    423423 
    424         bool ensureIpFilterOn(progress_callback fn) 
     424        bool ensure_ip_filter_on(progress_callback fn) 
    425425        { 
    426426                try 
     
    446446                                new hal::EventStdException(event_logger::critical, e, L"ensureIpFilterOn")));  
    447447 
    448                         ensureIpFilterOff(); 
     448                        ensure_ip_filter_off(); 
    449449                } 
    450450 
     
    454454        } 
    455455 
    456         void ensureIpFilterOff() 
     456        void ensure_ip_filter_off() 
    457457        { 
    458458                session_.set_ip_filter(libt::ip_filter()); 
     
    463463 
    464464        #ifndef TORRENT_DISABLE_ENCRYPTION       
    465         void ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4) 
     465        void ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4) 
    466466        { 
    467467                libt::pe_settings pe; 
     
    537537                                        new hal::EventStdException(event_logger::critical, e, L"ensurePeOn")));  
    538538                                         
    539                         ensurePeOff();           
     539                        ensure_pe_off();                 
    540540                } 
    541541                 
     
    543543        } 
    544544 
    545         void ensurePeOff() 
     545        void ensure_pe_off() 
    546546        { 
    547547                libt::pe_settings pe; 
     
    577577        } 
    578578 
    579         void clearIpFilter() 
     579        void clear_ip_filter() 
    580580        { 
    581581                ip_filter_ = libt::ip_filter(); 
     
    594594        signals; 
    595595 
    596         void stopAlertHandler(); 
    597         void alertHandler(); 
    598  
    599         void addTorrent(wpath file, wpath saveDirectory, bool startStopped, bool compactStorage,  
     596        void stop_alert_handler(); 
     597        void alert_handler(); 
     598 
     599        void add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool compactStorage,  
    600600                        boost::filesystem::wpath moveToDirectory, bool useMoveTo)  
    601601        { 
     
    635635                 
    636636                std::pair<TorrentManager::torrentByName::iterator, bool> p = 
    637                         theTorrents.insert(TIp); 
     637                        the_torrents_.insert(TIp); 
    638638                 
    639639                if (p.second) 
    640640                { 
    641                         torrent_internal_ptr me = theTorrents.get(TIp->name());          
     641                        torrent_internal_ptr me = the_torrents_.get(TIp->name());                
    642642                         
    643643                        if (!startStopped)  
     
    656656        } 
    657657 
    658         std::pair<libt::entry, libt::entry> prepTorrent(wpath filename, wpath saveDirectory) 
     658        std::pair<libt::entry, libt::entry> prep_torrent(wpath filename, wpath saveDirectory) 
    659659        { 
    660660                libt::entry metadata = haldecode(filename); 
     
    704704        } 
    705705 
    706         void resumeAll() 
     706        void removal_thread(torrent_internal_ptr pIT, bool wipeFiles) 
    707707        { 
    708708                try { 
     709 
     710                if (!wipeFiles) 
     711                { 
     712                        session_.remove_torrent(pIT->handle()); 
     713                } 
     714                else 
     715                { 
     716                        if (pIT->in_session()) 
     717                        { 
     718                                session_.remove_torrent(pIT->handle(), libt::session::delete_files); 
     719                        } 
     720                        else 
     721                        { 
     722                                libt::torrent_info m_info = pIT->infoMemory(); 
     723                                 
     724                                // delete the files from disk 
     725                                std::string error; 
     726                                std::set<std::string> directories; 
     727                                 
     728                                for (libt::torrent_info::file_iterator i = m_info.begin_files(true) 
     729                                        , end(m_info.end_files(true)); i != end; ++i) 
     730                                { 
     731                                        std::string p = (hal::path_to_utf8(pIT->saveDirectory()) / i->path).string(); 
     732                                        fs::path bp = i->path.branch_path(); 
     733                                         
     734                                        std::pair<std::set<std::string>::iterator, bool> ret; 
     735                                        ret.second = true; 
     736                                        while (ret.second && !bp.empty()) 
     737                                        { 
     738                                                std::pair<std::set<std::string>::iterator, bool> ret =  
     739                                                        directories.insert((hal::path_to_utf8(pIT->saveDirectory()) / bp).string()); 
     740                                                bp = bp.branch_path(); 
     741                                        } 
     742                                        if (!fs::remove(hal::from_utf8(p).c_str()) && errno != ENOENT) 
     743                                                error = std::strerror(errno); 
     744                                } 
     745 
     746                                // remove the directories. Reverse order to delete subdirectories first 
     747 
     748                                for (std::set<std::string>::reverse_iterator i = directories.rbegin() 
     749                                        , end(directories.rend()); i != end; ++i) 
     750                                { 
     751                                        if (!fs::remove(hal::from_utf8(*i).c_str()) && errno != ENOENT) 
     752                                                error = std::strerror(errno); 
     753                                } 
     754                        } 
     755                } 
     756 
     757                } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "removalThread") 
     758        } 
     759 
     760        void remove_torrent(const wstring& filename) 
     761        { 
     762                try { 
     763                 
     764                torrent_internal_ptr pTI = the_torrents_.get(filename); 
     765                libt::torrent_handle handle = pTI->handle(); 
     766                the_torrents_.erase(filename); 
     767                 
     768                thread_t t(bind(&bit_impl::removal_thread, this, pTI, false));   
     769                 
     770                } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "remove_torrent") 
     771        } 
     772 
     773        void remove_torrent_wipe_files(const std::wstring& filename) 
     774        { 
     775                try { 
     776                 
     777                torrent_internal_ptr pTI = the_torrents_.get(filename); 
     778                libt::torrent_handle handle = pTI->handle(); 
     779                the_torrents_.erase(filename); 
     780                 
     781                thread_t t(bind(&bit_impl::removal_thread, this, pTI, true));    
     782                 
     783                } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "remove_torrent_wipe_files") 
     784        } 
     785 
     786        void resume_all() 
     787        { 
     788                try { 
    709789                         
    710790                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Resuming torrent."))); 
    711791                 
    712                 for (TorrentManager::torrentByName::iterator i=theTorrents.begin(), e=theTorrents.end(); i != e;) 
     792                for (TorrentManager::torrentByName::iterator i=the_torrents_.begin(), e=the_torrents_.end(); i != e;) 
    713793                { 
    714794                        wpath file = wpath(workingDirectory)/L"torrents"/(*i).torrent->filename(); 
     
    750830                                                new hal::EventStdException(hal::event_logger::warning, e, L"resumeAll"))); 
    751831                                         
    752                                         theTorrents.erase(i++); 
     832                                        the_torrents_.erase(i++); 
    753833                                }                        
    754834                        } 
    755835                        else 
    756836                        { 
    757                                 theTorrents.erase(i++); 
     837                                the_torrents_.erase(i++); 
    758838                        } 
    759839                } 
     
    762842        } 
    763843 
    764         void closeAll(boost::optional<report_num_active> fn) 
     844        void close_all(boost::optional<report_num_active> fn) 
    765845        { 
    766846                try  
     
    768848                event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Saving torrent data..."))); 
    769849 
    770                 saveTorrentData(); 
     850                save_torrent_data(); 
    771851 
    772852                event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Stopping all torrents..."))); 
    773853                 
    774                 for (TorrentManager::torrentByName::iterator i=theTorrents.begin(), e=theTorrents.end();  
     854                for (TorrentManager::torrentByName::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
    775855                        i != e; ++i) 
    776856                { 
     
    783863                        num_active = 0; 
    784864 
    785                         for (TorrentManager::torrentByName::iterator i=theTorrents.begin(), e=theTorrents.end();  
     865                        for (TorrentManager::torrentByName::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
    786866                                        i != e; ++i) 
    787867                        { 
     
    802882        } 
    803883         
    804         void saveTorrentData() 
     884        void save_torrent_data() 
    805885        {        
    806886                mutex_t::scoped_lock l(mutex_); 
     
    808888                { 
    809889                 
    810                 theTorrents.save(); 
     890                the_torrents_.save(); 
    811891                bittorrentIni.save_data(); 
    812892                         
     
    837917                keepChecking_(false), 
    838918                bittorrentIni(L"BitTorrent.xml"), 
    839                 theTorrents(bittorrentIni), 
     919                the_torrents_(bittorrentIni), 
    840920                defTorrentMaxConn_(-1), 
    841921                defTorrentMaxUpload_(-1), 
     
    861941                hal::event_log.post(shared_ptr<hal::EventDetail>( 
    862942                        new hal::EventMsg(L"Loading torrent parameters.", hal::event_logger::info)));    
    863                 theTorrents.load(); 
     943                the_torrents_.load(); 
    864944                hal::event_log.post(shared_ptr<hal::EventDetail>( 
    865945                        new hal::EventMsg(L"Loading done!", hal::event_logger::info))); 
     
    878958                        ia >> boost::serialization::make_nvp("torrents", torrents); 
    879959                         
    880                         theTorrents = torrents; 
     960                        the_torrents_ = torrents; 
    881961                        } 
    882962                         
    883963                        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    884                                 wformat(L"Total %1%.") % theTorrents.size())));                          
     964                                wformat(L"Total %1%.") % the_torrents_.size())));                                
    885965                         
    886966                        fs::rename(workingDirectory/L"Torrents.xml", workingDirectory/L"Torrents.xml.safe.to.delete"); 
     
    912992                 
    913993                timer_.expires_from_now(boost::posix_time::seconds(5)); 
    914                 timer_.async_wait(bind(&bit_impl::alertHandler, this)); 
     994                timer_.async_wait(bind(&bit_impl::alert_handler, this)); 
    915995        } 
    916996 
     
    10031083        } 
    10041084         
    1005 //      std::pair<libt::entry, libt::entry> prepTorrent(wpath filename, wpath saveDirectory); 
    1006         void removalThread(torrent_internal_ptr pIT, bool wipeFiles); 
    1007          
    10081085        libt::session session_;  
    10091086        mutable mutex_t mutex_; 
     
    10151092        static wpath workingDirectory; 
    10161093        ini_file bittorrentIni; 
    1017         TorrentManager theTorrents;      
     1094        TorrentManager the_torrents_;    
    10181095         
    10191096        int defTorrentMaxConn_; 
  • trunk/src/halTorrent.cpp

    r481 r482  
    127127} 
    128128 
    129 void bit::saveTorrentData() 
    130 { 
    131         pimpl->saveTorrentData(); 
     129void bit::save_torrent_data() 
     130{ 
     131        pimpl->save_torrent_data(); 
    132132} 
    133133 
     
    139139bit::torrent bit::get_wstr(const std::wstring& filename) 
    140140{ 
    141         return bit::torrent(pimpl->theTorrents.get(filename)); 
    142 } 
    143  
    144 bool bit::listenOn(std::pair<int, int> const& range) 
    145 { 
    146         return pimpl->listenOn(range); 
    147 } 
    148  
    149 int bit::isListeningOn()  
    150 { 
    151         return pimpl->isListeningOn(); 
    152 } 
    153  
    154 void bit::stopListening() 
    155 { 
    156         pimpl->stopListening(); 
    157 } 
    158  
    159 bool bit::ensureDhtOn() 
    160 { 
    161         return pimpl->ensureDhtOn(); 
    162 } 
    163  
    164 void bit::ensureDhtOff() 
    165 { 
    166         pimpl->ensureDhtOff(); 
    167 } 
    168  
    169 void bit::setDhtSettings(int max_peers_reply, int search_branching,  
     141        return bit::torrent(pimpl->the_torrents_.get(filename)); 
     142} 
     143 
     144bool bit::listen_on(std::pair<int, int> const& range) 
     145{ 
     146        return pimpl->listen_on(range); 
     147} 
     148 
     149int bit::is_listening_on()  
     150{ 
     151        return pimpl->is_listening_on(); 
     152} 
     153 
     154void bit::stop_listening() 
     155{ 
     156        pimpl->stop_listening(); 
     157} 
     158 
     159bool bit::ensure_dht_on() 
     160{ 
     161        return pimpl->ensure_dht_on(); 
     162} 
     163 
     164void bit::ensure_dht_off() 
     165{ 
     166        pimpl->ensure_dht_off(); 
     167} 
     168 
     169void bit::set_dht_settings(int max_peers_reply, int search_branching,  
    170170        int service_port, int max_fail_count) 
    171171{ 
    172         pimpl->setDhtSettings(max_peers_reply, search_branching, service_port, max_fail_count); 
    173 } 
    174  
    175 void bit::setMapping(int mapping) 
    176 { 
    177         pimpl->setMapping(mapping); 
    178 } 
    179  
    180 void bit::setTimeouts(int peers, int tracker) 
    181 { 
    182         pimpl->setTimeouts(peers, tracker); 
    183 } 
    184  
    185 void bit::setSessionLimits(int maxConn, int maxUpload) 
     172        pimpl->set_dht_settings(max_peers_reply, search_branching, service_port, max_fail_count); 
     173} 
     174 
     175void bit::set_mapping(int mapping) 
     176{ 
     177        pimpl->set_mapping(mapping); 
     178} 
     179 
     180void bit::set_timeouts(int peers, int tracker) 
     181{ 
     182        pimpl->set_timeouts(peers, tracker); 
     183} 
     184 
     185void bit::set_session_limits(int maxConn, int maxUpload) 
    186186{                
    187         pimpl->setSessionLimits(maxConn, maxUpload); 
    188 } 
    189  
    190 void bit::setSessionSpeed(float download, float upload) 
    191 { 
    192         pimpl->setSessionSpeed(download, upload); 
    193 } 
    194  
    195 bool bit::ensureIpFilterOn(progress_callback fn) 
    196 { 
    197         return pimpl->ensureIpFilterOn(fn); 
    198 } 
    199  
    200 void bit::ensureIpFilterOff() 
    201 { 
    202         pimpl->ensureIpFilterOff(); 
     187        pimpl->set_session_limits(maxConn, maxUpload); 
     188} 
     189 
     190void bit::set_session_speed(float download, float upload) 
     191{ 
     192        pimpl->set_session_speed(download, upload); 
     193} 
     194 
     195bool bit::ensure_ip_filter_on(progress_callback fn) 
     196{ 
     197        return pimpl->ensure_ip_filter_on(fn); 
     198} 
     199 
     200void bit::ensure_ip_filter_off() 
     201{ 
     202        pimpl->ensure_ip_filter_off(); 
    203203} 
    204204 
    205205#ifndef TORRENT_DISABLE_ENCRYPTION       
    206206 
    207 void bit::ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4) 
    208 { 
    209         pimpl->ensurePeOn(enc_level, in_enc_policy, out_enc_policy, prefer_rc4); 
    210 } 
    211  
    212 void bit::ensurePeOff() 
    213 { 
    214         pimpl->ensurePeOff(); 
     207void bit::ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4) 
     208{ 
     209        pimpl->ensure_pe_on(enc_level, in_enc_policy, out_enc_policy, prefer_rc4); 
     210} 
     211 
     212void bit::ensure_pe_off() 
     213{ 
     214        pimpl->ensure_pe_off(); 
    215215} 
    216216#endif 
     
    233233} 
    234234 
    235 void bit::clearIpFilter() 
    236 { 
    237         pimpl->clearIpFilter(); 
     235void bit::clear_ip_filter() 
     236{ 
     237        pimpl->clear_ip_filter(); 
    238238} 
    239239 
     
    286286} 
    287287 
    288 void bit::addTorrent(wpath file, wpath saveDirectory, bool startStopped, bool compactStorage,  
     288void bit::add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool compactStorage,  
    289289                boost::filesystem::wpath moveToDirectory, bool useMoveTo)  
    290290{ 
    291         pimpl->addTorrent(file, saveDirectory, startStopped, compactStorage, moveToDirectory, useMoveTo); 
     291        pimpl->add_torrent(file, saveDirectory, startStopped, compactStorage, moveToDirectory, useMoveTo); 
    292292} 
    293293 
     
    304304         
    305305        torrentDetails_.clearAll(l);     
    306         torrentDetails_.torrents_.reserve(pimpl->theTorrents.size()); 
    307          
    308         for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); i != e; ++i) 
     306        torrentDetails_.torrents_.reserve(pimpl->the_torrents_.size()); 
     307         
     308        for (TorrentManager::torrentByName::iterator i=pimpl->the_torrents_.begin(), e=pimpl->the_torrents_.end(); i != e; ++i) 
    309309        { 
    310310                wstring utf8Name = (*i).torrent->name(); 
     
    328328} 
    329329 
    330 void bit::resumeAll() 
    331 { 
    332         pimpl->resumeAll(); 
    333 } 
    334  
    335 void bit::closeAll(boost::optional<report_num_active> fn) 
    336 { 
    337         pimpl->closeAll(fn); 
     330void bit::resume_all() 
     331{ 
     332        pimpl->resume_all(); 
     333} 
     334 
     335void bit::close_all(boost::optional<report_num_active> fn) 
     336{ 
     337        pimpl->close_all(fn); 
    338338} 
    339339 
     
    407407        try { 
    408408         
    409         pimpl->theTorrents.get(filename)->getPeerDetails(peerContainer); 
     409        pimpl->the_torrents_.get(filename)->getPeerDetails(peerContainer); 
    410410         
    411411        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllPeerDetails") 
     
    421421        try { 
    422422         
    423         pimpl->theTorrents.get(filename)->getFileDetails(fileDetails); 
     423        pimpl->the_torrents_.get(filename)->getFileDetails(fileDetails); 
    424424         
    425425        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllFileDetails") 
     
    435435        try { 
    436436         
    437         return pimpl->theTorrents.exists(filename); 
     437        return pimpl->the_torrents_.exists(filename); 
    438438         
    439439        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrent") 
     
    451451        try { 
    452452         
    453         pimpl->theTorrents.get(filename)->pause(); 
     453        pimpl->the_torrents_.get(filename)->pause(); 
    454454         
    455455        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pauseTorrent") 
     
    465465        try { 
    466466         
    467         pimpl->theTorrents.get(filename)->resume(); 
     467        pimpl->the_torrents_.get(filename)->resume(); 
    468468         
    469469        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resumeTorrent") 
     
    479479        try { 
    480480         
    481         pimpl->theTorrents.get(filename)->stop(); 
     481        pimpl->the_torrents_.get(filename)->stop(); 
    482482         
    483483        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stopTorrent") 
     
    493493        try { 
    494494         
    495         return pimpl->theTorrents.get(filename)->is_active(); 
     495        return pimpl->the_torrents_.get(filename)->is_active(); 
    496496         
    497497        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrentActive") 
     
    509509        try { 
    510510         
    511         pimpl->theTorrents.get(filename)->handle().force_reannounce(); 
     511        pimpl->the_torrents_.get(filename)->handle().force_reannounce(); 
    512512         
    513513        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounceTorrent") 
    514514} 
    515515 
    516 void bit_impl::removalThread(torrent_internal_ptr pIT, bool wipeFiles) 
    517 { 
    518         try { 
    519  
    520         if (!wipeFiles) 
    521         { 
    522                 session_.remove_torrent(pIT->handle()); 
    523         } 
    524         else 
    525         { 
    526                 if (pIT->in_session()) 
    527                 { 
    528                         session_.remove_torrent(pIT->handle(), libt::session::delete_files); 
    529                 } 
    530                 else 
    531                 { 
    532                         libt::torrent_info m_info = pIT->infoMemory(); 
    533                          
    534                         // delete the files from disk 
    535                         std::string error; 
    536                         std::set<std::string> directories; 
    537                          
    538                         for (libt::torrent_info::file_iterator i = m_info.begin_files(true) 
    539                                 , end(m_info.end_files(true)); i != end; ++i) 
    540                         { 
    541                                 std::string p = (hal::path_to_utf8(pIT->saveDirectory()) / i->path).string(); 
    542                                 fs::path bp = i->path.branch_path(); 
    543                                  
    544                                 std::pair<std::set<std::string>::iterator, bool> ret; 
    545                                 ret.second = true; 
    546                                 while (ret.second && !bp.empty()) 
    547                                 { 
    548                                         std::pair<std::set<std::string>::iterator, bool> ret =  
    549                                                 directories.insert((hal::path_to_utf8(pIT->saveDirectory()) / bp).string()); 
    550                                         bp = bp.branch_path(); 
    551                                 } 
    552                                 if (!fs::remove(hal::from_utf8(p).c_str()) && errno != ENOENT) 
    553                                         error = std::strerror(errno); 
    554                         } 
    555  
    556                         // remove the directories. Reverse order to delete subdirectories first 
    557  
    558                         for (std::set<std::string>::reverse_iterator i = directories.rbegin() 
    559                                 , end(directories.rend()); i != end; ++i) 
    560                         { 
    561                                 if (!fs::remove(hal::from_utf8(*i).c_str()) && errno != ENOENT) 
    562                                         error = std::strerror(errno); 
    563                         } 
    564                 } 
    565         } 
    566  
    567         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "removalThread") 
    568 } 
    569  
    570 void bit::removeTorrent(const std::string& filename) 
    571 { 
    572         removeTorrent(hal::to_wstr_shim(filename)); 
    573 } 
    574  
    575 void bit::removeTorrent(const std::wstring& filename) 
    576 { 
    577         try { 
    578          
    579         torrent_internal_ptr pTI = pimpl->theTorrents.get(filename); 
    580         libt::torrent_handle handle = pTI->handle(); 
    581         pimpl->theTorrents.erase(filename); 
    582          
    583         thread_t t(bind(&bit_impl::removalThread, &*pimpl, pTI, false));         
    584          
    585         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "removeTorrent") 
    586 } 
    587516 
    588517void bit::recheckTorrent(const std::string& filename) 
     
    595524        try { 
    596525         
    597         pimpl->theTorrents.get(filename)->force_recheck(); 
     526        pimpl->the_torrents_.get(filename)->force_recheck(); 
    598527         
    599528        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheckTorrent") 
    600529} 
    601530 
    602 void bit::removeTorrentWipeFiles(const std::string& filename) 
    603 { 
    604         removeTorrentWipeFiles(hal::to_wstr_shim(filename)); 
    605 } 
    606  
    607 void bit::removeTorrentWipeFiles(const std::wstring& filename) 
    608 { 
    609         try { 
    610          
    611         torrent_internal_ptr pTI = pimpl->theTorrents.get(filename); 
    612         libt::torrent_handle handle = pTI->handle(); 
    613         pimpl->theTorrents.erase(filename); 
    614          
    615         thread_t t(bind(&bit_impl::removalThread, &*pimpl, pTI, true));  
    616          
    617         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "removeTorrentWipeFiles") 
     531void bit::remove_torrent_wstr(const std::wstring& filename) 
     532{ 
     533        pimpl->remove_torrent(filename); 
     534} 
     535 
     536void bit::remove_torrent_wipe_files_wstr(const std::wstring& filename) 
     537{ 
     538        pimpl->remove_torrent_wipe_files(hal::to_wstr_shim(filename)); 
    618539} 
    619540 
     
    622543        try { 
    623544         
    624         for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); 
     545        for (TorrentManager::torrentByName::iterator i=pimpl->the_torrents_.begin(), e=pimpl->the_torrents_.end(); 
    625546                i != e; ++i) 
    626547        {                
     
    636557        try { 
    637558         
    638         for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); 
     559        for (TorrentManager::torrentByName::iterator i=pimpl->the_torrents_.begin(), e=pimpl->the_torrents_.end(); 
    639560                i != e; ++i) 
    640561        { 
     
    871792        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event Handler."))); 
    872793 
    873         pimpl->stopAlertHandler(); 
     794        pimpl->stop_alert_handler(); 
    874795} 
    875796 
  • trunk/src/halTorrent.hpp

    r474 r482  
    556556 
    557557        void shutDownSession(); 
    558         void saveTorrentData(); 
     558        void save_torrent_data(); 
    559559 
    560560        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn); 
     
    574574                        return torrent(); 
    575575        }        
    576  
    577         torrent get_wstr(const std::wstring& filename); 
    578          
    579         bool listenOn(std::pair<int, int> const& portRange); 
    580         int isListeningOn(); 
    581         void stopListening(); 
    582          
    583         bool ensureDhtOn(); 
    584         void ensureDhtOff(); 
    585          
    586         void ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4); 
    587         void ensurePeOff(); 
    588          
    589         bool ensureIpFilterOn(progress_callback fn); 
    590         void ensureIpFilterOff(); 
    591  
    592         void setMapping(int mapping); 
     576         
     577        bool listen_on(std::pair<int, int> const& portRange); 
     578        int is_listening_on(); 
     579        void stop_listening(); 
     580         
     581        bool ensure_dht_on(); 
     582        void ensure_dht_off(); 
     583         
     584        void ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4); 
     585        void ensure_pe_off(); 
     586         
     587        bool ensure_ip_filter_on(progress_callback fn); 
     588        void ensure_ip_filter_off(); 
     589 
     590        void set_mapping(int mapping); 
    593591 
    594592        void ip_v4_filter_block(asio::ip::address_v4 first, asio::ip::address_v4 last); 
     
    596594        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix); 
    597595        size_t ip_filter_size(); 
    598         void clearIpFilter();    
     596        void clear_ip_filter();  
    599597         
    600598        void setSessionHalfOpenLimit(int halfConn); 
    601         void setSessionLimits(int maxConn, int maxUpload); 
    602         void setSessionSpeed(float download, float upload); 
    603         void setDhtSettings(int max_peers_reply, int search_branching,  
     599        void set_session_limits(int maxConn, int maxUpload); 
     600        void set_session_speed(float download, float upload); 
     601        void set_dht_settings(int max_peers_reply, int search_branching,  
    604602                int service_port, int max_fail_count); 
    605         void setTimeouts(int peers, int tracker); 
     603        void set_timeouts(int peers, int tracker); 
    606604         
    607605        const SessionDetail getSessionDetails(); 
    608606 
    609607        void setTorrentDefaults(int maxConn, int maxUpload, float download, float upload);       
    610         void addTorrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory,  
     608        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory,  
    611609                bool startPaused=false, bool compactStorage=false,  
    612610                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false); 
     
    617615        void getAllFileDetails(const std::wstring& filename, FileDetails& fileDetails); 
    618616         
    619         void resumeAll(); 
    620         void closeAll(boost::optional<report_num_active> fn); 
     617        void resume_all(); 
     618        void close_all(boost::optional<report_num_active> fn); 
    621619         
    622620        bool isTorrent(const std::string& filename); 
     
    638636        void pauseAllTorrents(); 
    639637        void unpauseAllTorrents(); 
    640          
    641         void removeTorrent(const std::string& filename); 
    642         void removeTorrent(const std::wstring&  filename); 
    643         void removeTorrentWipeFiles(const std::string& filename); 
    644         void removeTorrentWipeFiles(const std::wstring&  filename); 
     638 
     639        template<typename S> 
     640        void remove_torrent(S filename) 
     641        {  
     642                remove_torrent_wstr(to_wstr_shim(filename));  
     643        }        
     644 
     645        template<typename S> 
     646        void remove_torrent_wipe_files(S filename) 
     647        {  
     648                remove_torrent_wipe_files_wstr(to_wstr_shim(filename));  
     649        }        
    645650 
    646651        void startEventReceiver(); 
     
    660665        bit(); 
    661666        boost::scoped_ptr<bit_impl> pimpl; 
     667 
     668        torrent get_wstr(const std::wstring& filename); 
     669         
     670        void remove_torrent_wstr(const std::wstring& filename); 
     671        void remove_torrent_wipe_files_wstr(const std::wstring&  filename); 
    662672         
    663673        TorrentDetails torrentDetails_; 
Note: See TracChangeset for help on using the changeset viewer.