Changeset 648


Ignore:
Timestamp:
12/16/08 12:53:23 (11 years ago)
Author:
Eoin
Message:
 
Location:
trunk/src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/SplashDialog.hpp

    r632 r648  
    9797        void OnForceClose(UINT, int, HWND hWnd) 
    9898        {                
     99                HAL_DEV_MSG(L"SplashDialog::OnForceClose()"); 
     100 
    99101                thread_splash->interrupt(); 
    100                 thread_splash = boost::none; 
    101                 Sleep(2000); 
     102                Sleep(20); 
    102103                 
    103104                RequiredToEnd(); 
     
    112113                HAL_DEV_MSG(L"SplashThread() calling hal::bittorrent().shutdown_session()"); 
    113114                hal::bittorrent().shutdown_session(); 
     115                HAL_DEV_MSG(L"SplashThread() Session shutdown"); 
    114116 
    115117                DoDataExchange(true); 
  • trunk/src/advtabs/Files.cpp

    r531 r648  
    9494        if (menu_) 
    9595        { 
    96                 assert (menu_.IsMenu()); 
    97  
    98                 POINT ptPoint; 
    99                 GetCursorPos(&ptPoint); 
    100                 menu_.TrackPopupMenu(0, ptPoint.x, ptPoint.y, m_hWnd); 
     96                assert(menu_.IsMenu()); 
     97 
     98                WTL::CPoint cur_pt; 
     99                GetCursorPos(&cur_pt); 
     100 
     101                WTL::CPoint pt = cur_pt;                         
     102                ScreenToClient(&pt); 
     103 
     104                WTL::CTreeItem ti = HitTest(pt, 0); 
     105 
     106                menu_.TrackPopupMenu(0, pt.x, pt.y, m_hWnd); 
    101107        } 
    102108 
  • trunk/src/global/ini.cpp

    r590 r648  
    143143 
    144144ini_file::ini_file(std::wstring filename) : 
    145         pimpl(new ini_impl(filename)) 
     145        pimpl_(new ini_impl(filename)) 
    146146{} 
    147147 
     
    151151void ini_file::load_data() 
    152152{ 
    153         pimpl->load_data(); 
     153        pimpl_->load_data(); 
    154154} 
    155155 
    156156void ini_file::save_data() 
    157157{ 
    158         pimpl->save_data(); 
     158        pimpl_->save_data(); 
    159159} 
    160160 
    161161bool ini_file::save(boost::filesystem::path location, std::string data) 
    162162{ 
    163         return pimpl->save(location, data); 
     163        return pimpl_->save(location, data); 
    164164} 
    165165 
    166166bool ini_file::save(boost::filesystem::path location, xml::node* data) 
    167167{ 
    168         return pimpl->save(location, data); 
     168        return pimpl_->save(location, data); 
    169169} 
    170170 
    171171xml::node* ini_file::load(boost::filesystem::path location) 
    172172{ 
    173         return pimpl->load(location); 
     173        return pimpl_->load(location); 
    174174} 
    175175 
  • trunk/src/global/ini.hpp

    r536 r648  
    3838         
    3939private:         
    40         std::auto_ptr<ini_impl> pimpl; 
     40        std::auto_ptr<ini_impl> pimpl_; 
    4141}; 
    4242 
  • trunk/src/global/wtl_app.cpp

    r634 r648  
    8383 
    8484app_module::app_module() : 
    85         pimpl(new app_impl()) 
     85        pimpl_(new app_impl()) 
    8686{} 
    8787 
    8888const std::wstring& app_module::exe_string() const  
    8989{  
    90         return pimpl->exe_string_;  
     90        return pimpl_->exe_string_;  
    9191} 
    9292 
    9393const boost::filesystem::wpath& app_module::exe_path() const  
    9494{  
    95         return pimpl->exe_path_;  
     95        return pimpl_->exe_path_;  
    9696} 
    9797 
    9898const boost::filesystem::wpath& app_module::initial_path() const  
    9999{  
    100         return pimpl->initial_path_;  
     100        return pimpl_->initial_path_;  
    101101} 
    102102 
    103103const boost::filesystem::wpath& app_module::get_working_directory() const  
    104104{  
    105         return pimpl->working_directory_;  
     105        return pimpl_->working_directory_;  
    106106} 
    107107 
    108108void app_module::set_working_directory(const boost::filesystem::wpath& p)  
    109109{  
    110         pimpl->working_directory_ = p;  
     110        pimpl_->working_directory_ = p;  
    111111} 
    112112 
    113113const boost::optional<boost::filesystem::wpath>& app_module::get_local_appdata() const  
    114114{  
    115         if (!pimpl->local_appdata_) 
     115        if (!pimpl_->local_appdata_) 
    116116        { 
    117117                wchar_t displayName[_MAX_PATH + 1]; 
     
    127127 
    128128                        ::SHGetPathFromIDList(iil, displayName); 
    129                         pimpl->local_appdata_ = std::wstring(displayName); 
     129                        pimpl_->local_appdata_ = std::wstring(displayName); 
    130130                } 
    131131        } 
    132132 
    133         return pimpl->local_appdata_;  
     133        return pimpl_->local_appdata_;  
    134134} 
    135135         
    136136const std::vector<std::wstring>& app_module::command_args() const  
    137137{  
    138         return pimpl->command_args_;  
     138        return pimpl_->command_args_;  
    139139} 
    140140         
    141141void app_module::res_revert() 
    142142{ 
    143         if (pimpl->hmod_) FreeLibrary(pimpl->hmod_); 
    144         _Module.SetResourceInstance(pimpl->instance_); 
     143        if (pimpl_->hmod_) FreeLibrary(pimpl_->hmod_); 
     144        _Module.SetResourceInstance(pimpl_->instance_); 
    145145} 
    146146 
    147147void app_module::res_set_dll(std::wstring dll) 
    148148{ 
    149         if (pimpl->hmod_) FreeLibrary(pimpl->hmod_); 
    150         pimpl->res_dll_ = dll; 
     149        if (pimpl_->hmod_) FreeLibrary(pimpl_->hmod_); 
     150        pimpl_->res_dll_ = dll; 
    151151         
    152152        HMODULE hmod_ = ::LoadLibraryEx(dll.c_str(), 0, LOAD_LIBRARY_AS_DATAFILE); 
  • trunk/src/global/wtl_app.hpp

    r558 r648  
    5656         
    5757private: 
    58         boost::scoped_ptr<app_impl> pimpl; 
     58        boost::scoped_ptr<app_impl> pimpl_; 
    5959         
    6060        app_module(); 
  • trunk/src/halSession.cpp

    r647 r648  
    129129        //save_torrent_data(); 
    130130         
     131        HAL_DEV_MSG(L"Handler stopped!");  
    131132        if (ip_filter_changed_) 
    132133        {        
     134                HAL_DEV_MSG(L"IP Filter needs saving.");  
     135 
    133136                fs::ofstream ofs(hal::app().get_working_directory()/L"IPFilter.bin", std::ios::binary); 
    134137//              boost::archive::binary_oarchive oba(ofs); 
     
    401404 
    402405                alert_checker_->interrupt(); 
     406                alert_checker_->join(); 
    403407                alert_checker_ = boost::none; 
    404408        } 
     
    740744                        // These are logged as debug because they are rarely important to act on! 
    741745                        event_log.post(shared_ptr<EventDetail>(\ 
    742                                 new EventStdException(event_logger::debug, e, L"alertHandler"))); 
     746                                new EventStdException(event_logger::debug, e, L"bit_impl::alert_handler()"))); 
    743747                } 
    744748                 
     
    751755         
    752756        } 
    753  
    754         } HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::alert_handler()") 
    755 } 
    756  
    757 } 
     757         
     758        boost::this_thread::interruption_point(); 
     759 
     760        }  
     761        catch(boost::thread_interrupted&) 
     762        { 
     763                // Not an error! 
     764 
     765                event_log.post(shared_ptr<EventDetail>( 
     766                        new EventMsg(L"thread_interrupted exception", event_logger::info))); 
     767 
     768                return; 
     769        } 
     770        HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::alert_handler()") 
     771} 
     772 
     773} 
  • trunk/src/halSession.hpp

    r642 r648  
    289289        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
    290290                new hal::EventMsg(hal::wform(L"Generic Torrent %1% catch all") % hal::from_utf8(FUNCTION), \ 
     291                        hal::event_logger::critical))); \ 
     292} 
     293 
     294#define HAL_GENERIC_PIMPL_EXCEPTION_CATCH(FUNCTION) \ 
     295catch (const access_violation& e) \ 
     296{ \ 
     297        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     298                new hal::EventMsg(hal::wform(L"Generic Session Pimpl %1% access_violation (code %2$x) at %3$x. Bad address %4$x") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress(), \ 
     299                        hal::event_logger::critical))); \ 
     300} \ 
     301catch (const win32_exception& e) \ 
     302{ \ 
     303        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     304                new hal::EventMsg(hal::wform(L"Generic Session Pimpl %1% win32_exception (code %2$x) at %3$x") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where(), \ 
     305                        hal::event_logger::critical))); \ 
     306} \ 
     307catch (const std::exception& e) \ 
     308{ \ 
     309        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     310        new hal::EventMsg(hal::wform(L"Generic Session Pimpl %1% std_exception: %2%") % hal::from_utf8(FUNCTION) % hal::from_utf8(e.what()), \ 
     311                        hal::event_logger::critical))); \ 
     312} \ 
     313catch (...) \ 
     314{ \ 
     315        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     316                new hal::EventMsg(hal::wform(L"Generic Session Pimpl %1% catch all") % hal::from_utf8(FUNCTION), \ 
    291317                        hal::event_logger::critical))); \ 
    292318} 
  • trunk/src/halTorrent.cpp

    r642 r648  
    8686 
    8787bit::bit() : 
    88         pimpl(new bit_impl()) 
     88        pimpl_(new bit_impl()) 
    8989{} 
    9090 
     91bit_impl* bit::pimpl() 
     92{ 
     93        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer"); 
     94 
     95        return &*pimpl_; 
     96} 
     97 
     98const bit_impl* bit::pimpl() const 
     99{ 
     100        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer"); 
     101 
     102        return &*pimpl_; 
     103} 
     104 
    91105void bit::shutdown_session() 
    92106{ 
    93107        HAL_DEV_MSG(L"Commence shutdown_session()");  
    94108 
    95         pimpl.reset(); 
     109        pimpl_.reset(); 
    96110 
    97111        HAL_DEV_MSG(L"End shutdown_session()");  
     
    100114void bit::save_torrent_data() 
    101115{ 
    102         pimpl->save_torrent_data(); 
     116        pimpl()->save_torrent_data(); 
    103117} 
    104118 
    105119bool bit::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn) 
    106120{ 
    107         return pimpl->create_torrent(params, out_file, fn); 
     121        return pimpl()->create_torrent(params, out_file, fn); 
    108122} 
    109123 
    110124bit::torrent bit::get_wstr(const std::wstring& filename) 
    111125{ 
    112         return bit::torrent(pimpl->the_torrents_.get(filename)); 
     126        return bit::torrent(pimpl()->the_torrents_.get(filename)); 
    113127} 
    114128 
    115129bool bit::listen_on(std::pair<int, int> const& range) 
    116130{ 
    117         return pimpl->listen_on(range); 
     131        return pimpl()->listen_on(range); 
    118132} 
    119133 
    120134int bit::is_listening_on()  
    121135{ 
    122         return pimpl->is_listening_on(); 
     136        return pimpl()->is_listening_on(); 
    123137} 
    124138 
    125139void bit::stop_listening() 
    126140{ 
    127         pimpl->stop_listening(); 
     141        pimpl()->stop_listening(); 
    128142} 
    129143 
    130144bool bit::ensure_dht_on(const hal::dht_settings& dht) 
    131145{ 
    132         return pimpl->ensure_dht_on(dht); 
     146        return pimpl()->ensure_dht_on(dht); 
    133147} 
    134148 
    135149void bit::ensure_dht_off() 
    136150{ 
    137         pimpl->ensure_dht_off(); 
     151        pimpl()->ensure_dht_off(); 
    138152} 
    139153 
    140154void bit::set_mapping(bool upnp, bool nat_pmp) 
    141155{ 
    142         pimpl->set_mapping(upnp, nat_pmp); 
     156        pimpl()->set_mapping(upnp, nat_pmp); 
    143157} 
    144158 
    145159std::wstring bit::upnp_router_model() 
    146160{ 
    147         return pimpl->upnp_router_model(); 
     161        return pimpl()->upnp_router_model(); 
    148162} 
    149163 
    150164queue_settings bit::get_queue_settings() 
    151165{ 
    152         return pimpl->get_queue_settings(); 
     166        return pimpl()->get_queue_settings(); 
    153167} 
    154168 
    155169void bit::set_queue_settings(const queue_settings& s) 
    156170{ 
    157         pimpl->set_queue_settings(s); 
     171        pimpl()->set_queue_settings(s); 
    158172} 
    159173 
    160174timeouts bit::get_timeouts() 
    161175{ 
    162         return pimpl->get_timeouts(); 
     176        return pimpl()->get_timeouts(); 
    163177} 
    164178 
    165179void bit::set_timeouts(const timeouts& t) 
    166180{ 
    167         pimpl->set_timeouts(t); 
     181        pimpl()->set_timeouts(t); 
    168182} 
    169183 
    170184void bit::set_session_limits(int maxConn, int maxUpload) 
    171185{                
    172         pimpl->set_session_limits(maxConn, maxUpload); 
     186        pimpl()->set_session_limits(maxConn, maxUpload); 
    173187} 
    174188 
    175189void bit::set_session_speed(float download, float upload) 
    176190{ 
    177         pimpl->set_session_speed(download, upload); 
     191        pimpl()->set_session_speed(download, upload); 
    178192} 
    179193 
    180194bool bit::ensure_ip_filter_on(progress_callback fn) 
    181195{ 
    182         return pimpl->ensure_ip_filter_on(fn); 
     196        return pimpl()->ensure_ip_filter_on(fn); 
    183197} 
    184198 
    185199void bit::ensure_ip_filter_off() 
    186200{ 
    187         pimpl->ensure_ip_filter_off(); 
     201        pimpl()->ensure_ip_filter_off(); 
    188202} 
    189203 
    190204void bit::set_resolve_countries(bool b) 
    191205{ 
    192         pimpl->set_resolve_countries(b); 
     206        pimpl()->set_resolve_countries(b); 
    193207} 
    194208 
    195209void bit::start_smart_ban_plugin() 
    196210{ 
    197         pimpl->start_smart_ban_plugin(); 
     211        pimpl()->start_smart_ban_plugin(); 
    198212} 
    199213 
    200214void bit::start_ut_pex_plugin() 
    201215{ 
    202         pimpl->start_ut_pex_plugin(); 
     216        pimpl()->start_ut_pex_plugin(); 
    203217} 
    204218 
    205219void bit::start_ut_metadata_plugin() 
    206220{ 
    207         pimpl->start_ut_metadata_plugin(); 
     221        pimpl()->start_ut_metadata_plugin(); 
    208222} 
    209223 
    210224void bit::start_metadata_plugin() 
    211225{ 
    212         pimpl->start_metadata_plugin(); 
     226        pimpl()->start_metadata_plugin(); 
    213227} 
    214228 
     
    217231void bit::ensure_pe_on(const pe_settings& pe) 
    218232{ 
    219         pimpl->ensure_pe_on(pe); 
     233        pimpl()->ensure_pe_on(pe); 
    220234} 
    221235 
    222236void bit::ensure_pe_off() 
    223237{ 
    224         pimpl->ensure_pe_off(); 
     238        pimpl()->ensure_pe_off(); 
    225239} 
    226240#endif 
     
    228242void bit::ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last) 
    229243{ 
    230         pimpl->ip_filter_.add_rule(first, last, libt::ip_filter::blocked); 
    231         pimpl->ip_filter_count(); 
    232         pimpl->ip_filter_changed_ = true; 
     244        pimpl()->ip_filter_.add_rule(first, last, libt::ip_filter::blocked); 
     245        pimpl()->ip_filter_count(); 
     246        pimpl()->ip_filter_changed_ = true; 
    233247} 
    234248 
    235249void bit::ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last) 
    236250{ 
    237         pimpl->ip_v6_filter_block(first, last); 
     251        pimpl()->ip_v6_filter_block(first, last); 
    238252} 
    239253 
    240254size_t bit::ip_filter_size() 
    241255{ 
    242         return pimpl->ip_filter_size(); 
     256        return pimpl()->ip_filter_size(); 
    243257} 
    244258 
    245259void bit::clear_ip_filter() 
    246260{ 
    247         pimpl->clear_ip_filter(); 
     261        pimpl()->clear_ip_filter(); 
    248262} 
    249263 
    250264bool bit::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix) 
    251265{ 
    252         return pimpl->ip_filter_import_dat(file, fn, octalFix); 
     266        return pimpl()->ip_filter_import_dat(file, fn, octalFix); 
    253267} 
    254268 
     
    257271        SessionDetail details; 
    258272         
    259         details.port = pimpl->session_.is_listening() ? pimpl->session_.listen_port() : -1; 
    260          
    261         libt::session_status status = pimpl->session_.status(); 
     273        details.port = pimpl()->session_.is_listening() ? pimpl()->session_.listen_port() : -1; 
     274         
     275        libt::session_status status = pimpl()->session_.status(); 
    262276         
    263277        details.speed = std::pair<double, double>(status.download_rate, status.upload_rate); 
    264278         
    265         details.dht_on = pimpl->dht_on_; 
     279        details.dht_on = pimpl()->dht_on_; 
    266280        details.dht_nodes = status.dht_nodes; 
    267281        details.dht_torrents = status.dht_torrents; 
    268282         
    269         details.ip_filter_on = pimpl->ip_filter_on_; 
    270         details.ip_ranges_filtered = pimpl->ip_filter_count_; 
     283        details.ip_filter_on = pimpl()->ip_filter_on_; 
     284        details.ip_ranges_filtered = pimpl()->ip_filter_count_; 
    271285         
    272286        return details; 
     
    275289void bit::set_session_half_open_limit(int halfConn) 
    276290{ 
    277         pimpl->session_.set_max_half_open_connections(halfConn); 
     291        pimpl()->session_.set_max_half_open_connections(halfConn); 
    278292 
    279293        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    280                 hal::wform(L"Set half-open connections limit to %1%.") % pimpl->session_.max_half_open_connections()))); 
     294                hal::wform(L"Set half-open connections limit to %1%.") % pimpl()->session_.max_half_open_connections()))); 
    281295} 
    282296 
    283297void bit::set_torrent_defaults(const connections& defaults) 
    284298{ 
    285         pimpl->default_torrent_max_connections_ = defaults.total; 
    286         pimpl->default_torrent_max_uploads_ = defaults.uploads; 
     299        pimpl()->default_torrent_max_connections_ = defaults.total; 
     300        pimpl()->default_torrent_max_uploads_ = defaults.uploads; 
    287301 
    288302        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
     
    290304                        % defaults.total % defaults.uploads))); 
    291305 
    292         pimpl->default_torrent_download_ = defaults.download_rate; 
    293         pimpl->default_torrent_upload_ = defaults.upload_rate; 
     306        pimpl()->default_torrent_download_ = defaults.download_rate; 
     307        pimpl()->default_torrent_upload_ = defaults.upload_rate; 
    294308 
    295309        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
     
    301315                boost::filesystem::wpath moveToDirectory, bool useMoveTo)  
    302316{ 
    303         pimpl->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory, useMoveTo); 
     317        pimpl()->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory, useMoveTo); 
    304318} 
    305319 
     
    316330         
    317331        torrentDetails_.clearAll(l);     
    318         torrentDetails_.torrents_.reserve(pimpl->the_torrents_.size()); 
    319          
    320         for (TorrentManager::torrentByName::iterator i=pimpl->the_torrents_.begin(), e=pimpl->the_torrents_.end(); i != e; ++i) 
     332        torrentDetails_.torrents_.reserve(pimpl()->the_torrents_.size()); 
     333         
     334        for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); i != e; ++i) 
    321335        { 
    322336                wstring utf8Name = (*i).torrent->name(); 
     
    342356void bit::resume_all() 
    343357{ 
    344         pimpl->resume_all(); 
     358        pimpl()->resume_all(); 
    345359} 
    346360 
    347361void bit::close_all(boost::optional<report_num_active> fn) 
    348362{ 
    349         pimpl->close_all(fn); 
     363        pimpl()->close_all(fn); 
    350364} 
    351365 
     
    412426const cache_details bit::get_cache_details() const 
    413427{ 
    414         return pimpl->get_cache_details(); 
     428        return pimpl()->get_cache_details(); 
    415429} 
    416430 
     
    424438        try { 
    425439         
    426         pimpl->the_torrents_.get(filename)->get_peer_details(peerContainer); 
    427          
    428         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllPeerDetails") 
     440        pimpl()->the_torrents_.get(filename)->get_peer_details(peerContainer); 
     441         
     442        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_peer_details") 
    429443} 
    430444 
     
    438452        try { 
    439453         
    440         pimpl->the_torrents_.get(filename)->get_file_details(fileDetails); 
    441          
    442         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllFileDetails") 
     454        pimpl()->the_torrents_.get(filename)->get_file_details(fileDetails); 
     455         
     456        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_file_details") 
    443457} 
    444458 
     
    452466        try { 
    453467         
    454         return pimpl->the_torrents_.exists(filename); 
     468        return pimpl()->the_torrents_.exists(filename); 
    455469         
    456470        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrent") 
     
    468482        try { 
    469483         
    470         pimpl->the_torrents_.get(filename)->pause(); 
     484        pimpl()->the_torrents_.get(filename)->pause(); 
    471485         
    472486        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pauseTorrent") 
     
    482496        try { 
    483497         
    484         pimpl->the_torrents_.get(filename)->resume(); 
     498        pimpl()->the_torrents_.get(filename)->resume(); 
    485499         
    486500        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resumeTorrent") 
     
    496510        try { 
    497511         
    498         pimpl->the_torrents_.get(filename)->stop(); 
     512        pimpl()->the_torrents_.get(filename)->stop(); 
    499513         
    500514        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stopTorrent") 
     
    510524        try { 
    511525         
    512         return pimpl->the_torrents_.get(filename)->is_active(); 
     526        return pimpl()->the_torrents_.get(filename)->is_active(); 
    513527         
    514528        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrentActive") 
     
    526540        try { 
    527541         
    528         pimpl->the_torrents_.get(filename)->handle().force_reannounce(); 
     542        pimpl()->the_torrents_.get(filename)->handle().force_reannounce(); 
    529543         
    530544        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounceTorrent") 
     
    541555        try { 
    542556         
    543         pimpl->the_torrents_.get(filename)->force_recheck(); 
     557        pimpl()->the_torrents_.get(filename)->force_recheck(); 
    544558         
    545559        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheckTorrent") 
     
    548562void bit::remove_torrent_wstr(const std::wstring& filename) 
    549563{ 
    550         pimpl->remove_torrent(filename); 
     564        pimpl()->remove_torrent(filename); 
    551565} 
    552566 
    553567void bit::remove_torrent_wipe_files_wstr(const std::wstring& filename) 
    554568{ 
    555         pimpl->remove_torrent_wipe_files(hal::to_wstr_shim(filename)); 
     569        pimpl()->remove_torrent_wipe_files(hal::to_wstr_shim(filename)); 
    556570} 
    557571 
     
    560574        try { 
    561575         
    562         for (TorrentManager::torrentByName::iterator i=pimpl->the_torrents_.begin(), e=pimpl->the_torrents_.end(); 
     576        for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); 
    563577                i != e; ++i) 
    564578        {                
     
    574588        try { 
    575589         
    576         for (TorrentManager::torrentByName::iterator i=pimpl->the_torrents_.begin(), e=pimpl->the_torrents_.end(); 
     590        for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); 
    577591                i != e; ++i) 
    578592        { 
     
    830844void bit::start_event_receiver() 
    831845{ 
     846        try { 
     847 
    832848        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting event handler."))); 
    833849 
    834         pimpl->start_alert_handler(); 
     850        pimpl()->start_alert_handler(); 
     851         
     852        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::start_event_receiver()") 
    835853} 
    836854 
    837855void bit::stop_event_receiver() 
    838856{ 
     857        try { 
     858 
    839859        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event handler."))); 
    840860 
    841         pimpl->stop_alert_handler(); 
    842 } 
    843  
    844 int bit::default_torrent_max_connections() { return pimpl->default_torrent_max_connections_; } 
    845 int bit::default_torrent_max_uploads() { return pimpl->default_torrent_max_uploads_; } 
    846 float bit::default_torrent_download() { return pimpl->default_torrent_download_; } 
    847 float bit::default_torrent_upload() { return pimpl->default_torrent_upload_; } 
     861        pimpl()->stop_alert_handler(); 
     862         
     863        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::stop_event_receiver()") 
     864} 
     865 
     866int bit::default_torrent_max_connections() { return pimpl()->default_torrent_max_connections_; } 
     867int bit::default_torrent_max_uploads() { return pimpl()->default_torrent_max_uploads_; } 
     868float bit::default_torrent_download() { return pimpl()->default_torrent_download_; } 
     869float bit::default_torrent_upload() { return pimpl()->default_torrent_upload_; } 
    848870         
    849871}; 
  • trunk/src/halTorrent.hpp

    r642 r648  
    968968private: 
    969969        bit(); 
    970         boost::scoped_ptr<bit_impl> pimpl; 
     970 
     971        bit_impl* pimpl(); 
     972        const bit_impl* pimpl() const; 
     973        boost::scoped_ptr<bit_impl> pimpl_; 
    971974         
    972975        void remove_torrent_wstr(const std::wstring& filename); 
  • trunk/src/halTorrentInternal.hpp

    r642 r648  
    582582                if (in_session()) 
    583583                { 
    584                         assert(managed_ == handle_.is_auto_managed()); 
     584                        managed_ = handle_.is_auto_managed(); 
    585585                } 
    586586 
Note: See TracChangeset for help on using the changeset viewer.