source: trunk/src/halTorrent.cpp @ 659

Revision 659, 23.0 KB checked in by Eoin, 11 years ago (diff)

Peer list sorting fixed and so more naming conventions consistency work.

RevLine 
[59]1
[370]2//         Copyright Eóin O'Callaghan 2006 - 2008.
[268]3// Distributed under the Boost Software License, Version 1.0.
4//    (See accompanying file LICENSE_1_0.txt or copy at
5//          http://www.boost.org/LICENSE_1_0.txt)
6
[392]7#include "stdAfx.hpp"
[656]8#include <functional>
[287]9
[348]10#include "global/wtl_app.hpp"
[122]11#include "global/string_conv.hpp"
[303]12#include "global/ini_adapter.hpp"
[83]13
[348]14#include "halTorrent.hpp"
[437]15#include "halTypes.hpp"
[348]16#include "halEvent.hpp"
[403]17#include "halSignaler.hpp"
[348]18
[479]19#include "halTorrentInternal.hpp"
20#include "halSession.hpp"
[480]21//#include "halSessionAlert.hpp"
[121]22
[128]23namespace hal
[59]24{
[437]25        libtorrent::session* torrent_internal::the_session_ = 0;
[120]26}
[84]27
[128]28namespace hal
[120]29{
30
[438]31bit& bittorrent()
[84]32{
[438]33        static bit t;
[84]34        return t;
35}
36
[659]37const peer_details_vec& torrent_details::get_peer_details() const
[231]38{
[659]39        if (!peer_details_filled_)
[231]40        {
[659]41                bittorrent().get_all_peer_details(hal::to_utf8(name_), peer_details_);
42                peer_details_filled_ = true;
[231]43        }
44       
[659]45        return peer_details_;
[231]46}
[236]47
[659]48const FileDetails& torrent_details::file_details() const
[274]49{
[659]50        if (!file_details_filled_)
[274]51        {
[659]52                bittorrent().get_all_file_details(hal::to_utf8(name_), file_details_);
53                file_details_filled_ = true;
[274]54        }
55       
[659]56        return file_details_;
[274]57}
58
[659]59/*bool nameLess(const torrent_details_ptr& left, const torrent_details_ptr& right)
[236]60{
[237]61        return left->state() < right->state();
[236]62}
[659]63*/
[656]64bool torrent_details::less(const torrent_details& r, size_t index) const
[243]65{
[654]66        switch (index)
67        {
68        case name_e: return name_ < r.name_;
69        case state_e: return state_ < r.state_;
70
71        case speed_down_e: return speed_.first < r.speed_.first;
72        case speed_up_e: return speed_.second < r.speed_.second;
73        case progress_e: return completion_ < r.completion_;
74        case distributed_copies_e: return distributed_copies_ < r.distributed_copies_;
75
76        case remaining_e: 
77                {
[659]78                boost::int64_t left = total_wanted_-total_wanted_done_;
79                boost::int64_t right = r.total_wanted_-r.total_wanted_done_;
[654]80
81                return left < right;
82                }
83
[659]84        case total_wanted_e: return total_wanted_ < r.total_wanted_;
85        case completed_e: return total_wanted_done_ < r.total_wanted_done_; 
[654]86
[659]87        case uploaded_e: return total_payload_uploaded_ < r.total_payload_uploaded_;
88        case downloaded_e: return total_payload_downloaded_ < r.total_payload_downloaded_;
[654]89
90        case peers_e: return peers_ < r.peers_;
91        case seeds_e: return seeds_ < r.seeds_;
92
93        case ratio_e: 
94                {
[659]95                float left = (total_payload_downloaded_) 
96                                ? static_cast<float>(total_payload_uploaded_)
97                                        / static_cast<float>(total_payload_downloaded_)
[654]98                                : 0;
99               
[659]100                float right = (r.total_payload_downloaded_) 
101                                ? static_cast<float>(r.total_payload_uploaded_)
102                                        / static_cast<float>(r.total_payload_downloaded_)
[654]103                                : 0;
104               
105                return left < right; 
106                }
107
[659]108        case eta_e: return estimated_time_left_ < r.estimated_time_left_;
[654]109        case tracker: return currentTracker_ < r.currentTracker_;
[659]110        case update_tracker_in_e: return update_tracker_in_ < r.update_tracker_in_;
[654]111
112        case active_time_e: return active_ < r.active_;
113        case seeding_time_e: return seeding_ < r.seeding_;
[659]114        case start_time_e: return start_time_ < r.start_time_;
115        case finish_time_e: return finish_time_ < r.finish_time_;
[654]116
117        case queue_position_e: return queue_position_ < r.queue_position_;
118        case managed_e: return managed_ < r.managed_;
119
120        default: return false; // ???
121        };
[243]122}
123
[654]124std::wstring torrent_details::to_wstring(size_t index)
125{
126        switch (index)
127        {
128        case name_e: return name_;
129        case state_e: return state_;
130
131        case progress_e: return (wform(L"%1$.2f%%") % (completion_*100)).str(); 
132        case speed_down_e: return (wform(L"%1$.2fkb/s") % (speed_.first/1024)).str(); 
133        case speed_up_e: return (wform(L"%1$.2fkb/s") % (speed_.second/1024)).str(); 
134
135        case distributed_copies_e: 
136                {
137                float copies = distributed_copies_;
138               
139                if (copies < 0)
140                        return L"Seeding"; 
141                else
142                        return (hal::wform(L"%1$.2f") % copies).str(); 
143                }
144
145        case remaining_e: 
146                {
[659]147                return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_-total_wanted_done_)/(1024*1024))).str(); 
[654]148                }
149
[659]150        case completed_e: return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_done_)/(1024*1024))).str();
[654]151
152        case total_wanted_e: 
153                {
[659]154                return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_-total_wanted_done_)/(1024*1024))).str(); 
[654]155                }
156
157        case uploaded_e: 
158                {
[659]159                return (wform(L"%1$.2fMB") % (static_cast<float>(total_payload_uploaded_)/(1024*1024))).str(); 
[654]160                }
161
162        case downloaded_e: 
163                {
[659]164                return (wform(L"%1$.2fMB") % (static_cast<float>(total_payload_downloaded_)/(1024*1024))).str(); 
[654]165                }
166
[659]167        case peers_e: return (wform(L"%1% (%2%)") % connected_peers_ % peers_).str(); 
168        case seeds_e: return (wform(L"%1% (%2%)") % connected_seeds_ % seeds_).str(); 
[654]169
170        case ratio_e: 
171                {
[659]172                        float ratio = (total_payload_downloaded_) 
173                                ? static_cast<float>(total_payload_uploaded_)
174                                        / static_cast<float>(total_payload_downloaded_)
[654]175                                : 0;
176                       
177                        return (wform(L"%1$.2f") % ratio).str(); 
178                }
179
180        case eta_e: 
181                { 
[659]182                if (!estimated_time_left_.is_special())
[654]183                        return hal::from_utf8(
[659]184                                boost::posix_time::to_simple_string(estimated_time_left_));
[654]185                else
186                        return app().res_wstr(HAL_INF);         
187                }       
188
189        case tracker: return currentTracker_;
190
191        case update_tracker_in_e:               
192                { 
[659]193                if (!update_tracker_in_.is_special())
[654]194                        return from_utf8(
[659]195                                boost::posix_time::to_simple_string(update_tracker_in_));
[654]196                else
197                        return app().res_wstr(HAL_INF);         
198                }       
199
200        case active_time_e: 
201                {
202                if (!active_.is_special())
203                        return from_utf8(
204                                boost::posix_time::to_simple_string(active_));
205                else
206                        return app().res_wstr(HAL_INF);         
207                }
208
209        case seeding_time_e: 
210                { 
211                if (!seeding_.is_special())
212                        return from_utf8(
213                                boost::posix_time::to_simple_string(seeding_));
214                else
215                        return app().res_wstr(HAL_INF);
216                }       
217
218        case start_time_e: 
219                { 
[659]220                if (!start_time_.is_special())
[654]221                        return from_utf8(
[659]222                                boost::posix_time::to_simple_string(start_time_));
[654]223                else
224                        return app().res_wstr(IDS_NA);
225                }               
226
227        case finish_time_e:             
228                { 
[659]229                if (!finish_time_.is_special())
[654]230                        return from_utf8(
[659]231                                boost::posix_time::to_simple_string(finish_time_));
[654]232                else
233                        return app().res_wstr(IDS_NA); 
234                }               
235
236        case queue_position_e: 
237                {
238                        if (queue_position_ != -1)
239                                return (wform(L"%1%") % queue_position_).str(); 
240                        else
241                                return app().res_wstr(IDS_NA);         
242                }
243
[659]244        case managed_e: return managed_ ?  L"Yes" : L"No";
[654]245
246        default: return L"(Undefined)"; // ???
247        };
248}
249
[656]250void torrent_details_manager::sort(size_t column_index, bool cmp_less) const
[654]251{
252        std::stable_sort(torrents_.begin(), torrents_.end(), 
[659]253                bind(&hal_details_ptr_compare<torrent_details_ptr>, _1, _2, column_index, cmp_less));
[654]254}
255
[432]256web_seed_or_dht_node_detail::web_seed_or_dht_node_detail() : 
257        url(L""), 
258        port(-1), 
259        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_WEB)) 
260{}
261
[431]262web_seed_or_dht_node_detail::web_seed_or_dht_node_detail(std::wstring u) : 
263        url(u), 
264        port(-1), 
265        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_WEB)) 
266{}
267
268web_seed_or_dht_node_detail::web_seed_or_dht_node_detail(std::wstring u, int p) : 
269        url(u), 
270        port(p), 
271        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_DHT)) 
272{}
[341]273
[438]274bit::bit() :
[648]275        pimpl_(new bit_impl())
[84]276{}
277
[648]278bit_impl* bit::pimpl()
279{
280        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer");
281
282        return &*pimpl_;
283}
284
285const bit_impl* bit::pimpl() const
286{
287        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer");
288
289        return &*pimpl_;
290}
291
[632]292void bit::shutdown_session()
[87]293{
[632]294        HAL_DEV_MSG(L"Commence shutdown_session()"); 
[564]295
[648]296        pimpl_.reset();
[564]297
[632]298        HAL_DEV_MSG(L"End shutdown_session()"); 
[87]299}
300
[482]301void bit::save_torrent_data()
[140]302{
[648]303        pimpl()->save_torrent_data();
[140]304}
305
[438]306bool bit::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn)
[429]307{
[648]308        return pimpl()->create_torrent(params, out_file, fn);
[429]309}
310
[438]311bit::torrent bit::get_wstr(const std::wstring& filename)
[437]312{
[648]313        return bit::torrent(pimpl()->the_torrents_.get(filename));
[437]314}
315
[482]316bool bit::listen_on(std::pair<int, int> const& range)
[84]317{
[648]318        return pimpl()->listen_on(range);
[84]319}
320
[482]321int bit::is_listening_on() 
[84]322{
[648]323        return pimpl()->is_listening_on();
[84]324}
325
[482]326void bit::stop_listening()
[84]327{
[648]328        pimpl()->stop_listening();
[84]329}
330
[541]331bool bit::ensure_dht_on(const hal::dht_settings& dht)
[114]332{
[648]333        return pimpl()->ensure_dht_on(dht);
[114]334}
335
[482]336void bit::ensure_dht_off()
[114]337{
[648]338        pimpl()->ensure_dht_off();
[114]339}
340
[542]341void bit::set_mapping(bool upnp, bool nat_pmp)
[373]342{
[648]343        pimpl()->set_mapping(upnp, nat_pmp);
[373]344}
345
[618]346std::wstring bit::upnp_router_model()
347{
[648]348        return pimpl()->upnp_router_model();
[618]349}
350
[506]351queue_settings bit::get_queue_settings()
352{
[648]353        return pimpl()->get_queue_settings();
[506]354}
355
356void bit::set_queue_settings(const queue_settings& s)
357{
[648]358        pimpl()->set_queue_settings(s);
[506]359}
360
[517]361timeouts bit::get_timeouts()
362{
[648]363        return pimpl()->get_timeouts();
[517]364}
365
366void bit::set_timeouts(const timeouts& t)
367{
[648]368        pimpl()->set_timeouts(t);
[517]369}
370
[482]371void bit::set_session_limits(int maxConn, int maxUpload)
[94]372{               
[648]373        pimpl()->set_session_limits(maxConn, maxUpload);
[94]374}
375
[482]376void bit::set_session_speed(float download, float upload)
[84]377{
[648]378        pimpl()->set_session_speed(download, upload);
[88]379}
380
[482]381bool bit::ensure_ip_filter_on(progress_callback fn)
[88]382{
[648]383        return pimpl()->ensure_ip_filter_on(fn);
[84]384}
385
[482]386void bit::ensure_ip_filter_off()
[115]387{
[648]388        pimpl()->ensure_ip_filter_off();
[115]389}
390
[641]391void bit::set_resolve_countries(bool b)
392{
[648]393        pimpl()->set_resolve_countries(b);
[641]394}
395
396void bit::start_smart_ban_plugin()
397{
[648]398        pimpl()->start_smart_ban_plugin();
[641]399}
400
401void bit::start_ut_pex_plugin()
402{
[648]403        pimpl()->start_ut_pex_plugin();
[641]404}
405
406void bit::start_ut_metadata_plugin()
407{
[648]408        pimpl()->start_ut_metadata_plugin();
[641]409}
410
411void bit::start_metadata_plugin()
412{
[648]413        pimpl()->start_metadata_plugin();
[641]414}
415
[233]416#ifndef TORRENT_DISABLE_ENCRYPTION     
[480]417
[541]418void bit::ensure_pe_on(const pe_settings& pe)
[233]419{
[648]420        pimpl()->ensure_pe_on(pe);
[233]421}
422
[482]423void bit::ensure_pe_off()
[233]424{
[648]425        pimpl()->ensure_pe_off();
[233]426}
427#endif
428
[554]429void bit::ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last)
[115]430{
[648]431        pimpl()->ip_filter_.add_rule(first, last, libt::ip_filter::blocked);
432        pimpl()->ip_filter_count();
433        pimpl()->ip_filter_changed_ = true;
[115]434}
435
[554]436void bit::ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last)
[115]437{
[648]438        pimpl()->ip_v6_filter_block(first, last);
[115]439}
440
[438]441size_t bit::ip_filter_size()
[115]442{
[648]443        return pimpl()->ip_filter_size();
[115]444}
445
[482]446void bit::clear_ip_filter()
[115]447{
[648]448        pimpl()->clear_ip_filter();
[115]449}
450
[438]451bool bit::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix)
[115]452{
[648]453        return pimpl()->ip_filter_import_dat(file, fn, octalFix);
[115]454}
455
[634]456const SessionDetail bit::get_session_details()
[114]457{
458        SessionDetail details;
459       
[648]460        details.port = pimpl()->session_.is_listening() ? pimpl()->session_.listen_port() : -1;
[115]461       
[648]462        libt::session_status status = pimpl()->session_.status();
[114]463       
[345]464        details.speed = std::pair<double, double>(status.download_rate, status.upload_rate);
[114]465       
[648]466        details.dht_on = pimpl()->dht_on_;
[117]467        details.dht_nodes = status.dht_nodes;
468        details.dht_torrents = status.dht_torrents;
[114]469       
[648]470        details.ip_filter_on = pimpl()->ip_filter_on_;
471        details.ip_ranges_filtered = pimpl()->ip_filter_count_;
[115]472       
[114]473        return details;
474}
475
[634]476void bit::set_session_half_open_limit(int halfConn)
[234]477{
[648]478        pimpl()->session_.set_max_half_open_connections(halfConn);
[375]479
[478]480        event_log.post(shared_ptr<EventDetail>(new EventMsg(
[648]481                hal::wform(L"Set half-open connections limit to %1%.") % pimpl()->session_.max_half_open_connections())));
[234]482}
483
[541]484void bit::set_torrent_defaults(const connections& defaults)
[119]485{
[648]486        pimpl()->default_torrent_max_connections_ = defaults.total;
487        pimpl()->default_torrent_max_uploads_ = defaults.uploads;
[375]488
[478]489        event_log.post(shared_ptr<EventDetail>(new EventMsg(
[541]490                hal::wform(L"Set torrent connections total %1% and uploads %2%.") 
491                        % defaults.total % defaults.uploads)));
[375]492
[648]493        pimpl()->default_torrent_download_ = defaults.download_rate;
494        pimpl()->default_torrent_upload_ = defaults.upload_rate;
[375]495
[478]496        event_log.post(shared_ptr<EventDetail>(new EventMsg(
[541]497                hal::wform(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") 
498                        % defaults.download_rate % defaults.upload_rate)));
[119]499}
500
[614]501void bit::add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool managed, allocations alloc, 
[403]502                boost::filesystem::wpath moveToDirectory, bool useMoveTo) 
[87]503{
[648]504        pimpl()->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory, useMoveTo);
[84]505}
[107]506
[507]507const torrent_details_manager& bit::torrentDetails()
[236]508{
[248]509        return torrentDetails_;
510}
511
[507]512const torrent_details_manager& bit::updatetorrent_details_manager(const wstring& focused, const std::set<wstring>& selected)
[248]513{
[264]514        try {
515       
[248]516        mutex_t::scoped_lock l(torrentDetails_.mutex_); 
[236]517       
[304]518        torrentDetails_.clearAll(l);   
[648]519        torrentDetails_.torrents_.reserve(pimpl()->the_torrents_.size());
[236]520       
[648]521        for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); i != e; ++i)
[290]522        {
[437]523                wstring utf8Name = (*i).torrent->name();
[634]524                torrent_details_ptr pT = (*i).torrent->get_torrent_details_ptr();
[243]525               
[291]526                if (selected.find(utf8Name) != selected.end())
[236]527                {
[248]528                        torrentDetails_.selectedTorrents_.push_back(pT);
[236]529                }
530               
[291]531                if (focused == utf8Name)
[248]532                        torrentDetails_.selectedTorrent_ = pT;
[236]533               
[342]534                torrentDetails_.torrentMap_[(*i).torrent->name()] = pT;
[248]535                torrentDetails_.torrents_.push_back(pT);
[236]536        }
537       
[507]538        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "updatetorrent_details_manager")
[264]539       
[248]540        return torrentDetails_;
[236]541}
542
[482]543void bit::resume_all()
[84]544{
[648]545        pimpl()->resume_all();
[84]546}
[83]547
[482]548void bit::close_all(boost::optional<report_num_active> fn)
[86]549{
[648]550        pimpl()->close_all(fn);
[86]551}
[84]552
[624]553const cache_details bit::get_cache_details() const
554{
[648]555        return pimpl()->get_cache_details();
[624]556}
557
[659]558void bit::get_all_peer_details(const std::string& filename, peer_details_vec& peer_container)
[98]559{
[659]560        get_all_peer_details(from_utf8_safe(filename), peer_container);
[292]561}
562
[659]563void bit::get_all_peer_details(const std::wstring& filename, peer_details_vec& peer_container)
[292]564{
[136]565        try {
566       
[659]567        pimpl()->the_torrents_.get(filename)->get_peer_details(peer_container);
[98]568       
[648]569        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_peer_details")
[98]570}
571
[659]572void bit::get_all_file_details(const std::string& filename, FileDetails& file_details)
[274]573{
[659]574        get_all_file_details(from_utf8_safe(filename), file_details);
[292]575}
576
[659]577void bit::get_all_file_details(const std::wstring& filename, FileDetails& file_details)
[292]578{
[274]579        try {
580       
[659]581        pimpl()->the_torrents_.get(filename)->get_file_details(file_details);
[274]582       
[648]583        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_file_details")
[274]584}
585
[634]586bool bit::is_torrent(const std::string& filename)
[104]587{       
[634]588        return is_torrent(hal::to_wstr_shim(filename));
[291]589}
590
[634]591bool bit::is_torrent(const std::wstring& filename)
[291]592{       
[136]593        try {
594       
[648]595        return pimpl()->the_torrents_.exists(filename);
[136]596       
597        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrent")
598       
599        return false;
[104]600}
601
[634]602void bit::pause_torrent(const std::string& filename)
[92]603{
[634]604        pause_torrent(hal::to_wstr_shim(filename));
[291]605}
606
[634]607void bit::pause_torrent(const std::wstring& filename)
[291]608{
[136]609        try {
610       
[648]611        pimpl()->the_torrents_.get(filename)->pause();
[92]612       
[136]613        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pauseTorrent")
[92]614}
615
[634]616void bit::resume_torrent(const std::string& filename)
[92]617{
[634]618        resume_torrent(hal::to_wstr_shim(filename));
[291]619}
620
[634]621void bit::resume_torrent(const std::wstring& filename)
[291]622{
[136]623        try {
624       
[648]625        pimpl()->the_torrents_.get(filename)->resume();
[92]626       
[136]627        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resumeTorrent")
[92]628}
629
[634]630void bit::stop_torrent(const std::string& filename)
[92]631{
[634]632        stop_torrent(hal::to_wstr_shim(filename));
[291]633}
634
[634]635void bit::stop_torrent(const std::wstring& filename)
[291]636{
[136]637        try {
638       
[648]639        pimpl()->the_torrents_.get(filename)->stop();
[121]640       
[136]641        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stopTorrent")
[121]642}
643
[634]644bool bit::is_torrent_active(const std::string& filename)
[121]645{
[634]646        return is_torrent_active(hal::to_wstr_shim(filename));
[291]647}
648
[634]649bool bit::is_torrent_active(const std::wstring& filename)
[291]650{
[136]651        try {
652       
[648]653        return pimpl()->the_torrents_.get(filename)->is_active();
[92]654       
[136]655        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrentActive")
656       
[92]657        return false; // ??? is this correct
658}
659
[634]660void bit::reannounce_torrent(const std::string& filename)
[120]661{
[634]662        reannounce_torrent(hal::to_wstr_shim(filename));
[291]663}
664
[634]665void bit::reannounce_torrent(const std::wstring& filename)
[291]666{
[136]667        try {
668       
[648]669        pimpl()->the_torrents_.get(filename)->handle().force_reannounce();
[120]670       
[291]671        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounceTorrent")
672}
673
[317]674
[634]675void bit::recheck_torrent(const std::string& filename)
[403]676{
[634]677        recheck_torrent(hal::to_wstr_shim(filename));
[403]678}
679
[634]680void bit::recheck_torrent(const std::wstring& filename)
[403]681{
682        try {
683       
[648]684        pimpl()->the_torrents_.get(filename)->force_recheck();
[403]685       
686        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheckTorrent")
687}
688
[482]689void bit::remove_torrent_wstr(const std::wstring& filename)
[121]690{
[648]691        pimpl()->remove_torrent(filename);
[121]692}
693
[482]694void bit::remove_torrent_wipe_files_wstr(const std::wstring& filename)
[94]695{
[648]696        pimpl()->remove_torrent_wipe_files(hal::to_wstr_shim(filename));
[94]697}
698
[632]699void bit::pause_all_torrents()
[94]700{       
[136]701        try {
702       
[648]703        for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
[292]704                i != e; ++i)
[246]705        {               
[441]706                if ((*i).torrent->in_session())
[342]707                        (*i).torrent->pause();
[94]708        }
[136]709       
710        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "pauseAllTorrents")
[94]711}
712
[632]713void bit::unpause_all_torrents()
[94]714{       
[136]715        try {
716       
[648]717        for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
[292]718                i != e; ++i)
[94]719        {
[632]720                if ((*i).torrent->in_session() && (*i).torrent->get_state() == torrent_details::torrent_paused)
[342]721                        (*i).torrent->resume();
[94]722        }
[136]723       
724        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "unpauseAllTorrents")
[94]725}
726
[453]727bit::torrent::torrent()
728{}
[437]729
[438]730bit::torrent::torrent(boost::shared_ptr<torrent_internal> p) :
[437]731        ptr(p)
732{}
733
[453]734bool bit::torrent::is_open() const
735{
736        return ptr;
737}
738
[438]739bit::torrent::exec_around_ptr::proxy::proxy(torrent_internal* t) : 
[437]740        t_(t),
741        l_(t->mutex_)
[427]742{
[590]743//      HAL_DEV_MSG(L"Ctor proxy");
[437]744}
745
[438]746bit::torrent::exec_around_ptr::proxy::~proxy() 
[437]747{
[590]748//      HAL_DEV_MSG(L"Dtor proxy");
[437]749}
750
[460]751const std::wstring bit::torrent::get_name() const
752{
753        try {
754       
755        return ptr->name();
756       
757        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Torrent Unknown", "torrent::get_name()")
758       
759        return 0;
760}
761
[438]762float bit::torrent::get_ratio() const
[437]763{
[427]764        try {
765       
[437]766        return ptr->get_ratio();
[427]767       
[460]768        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_ratio")
[437]769       
770        return 0;
771}
772
[438]773void bit::torrent::set_ratio(float r)
[437]774{
775        try {
776
777        ptr->set_ratio(r);
778       
[460]779        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_ratio")
[427]780}
781
[454]782std::pair<int, int> bit::torrent::get_connection_limits() const
783{
784        try {
785       
[634]786        return ptr->get_connection_limit();
[454]787       
[460]788        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_connection_limits")
[454]789       
790        return std::make_pair(-1, -1);
791}
792
793void bit::torrent::set_connection_limits(const std::pair<int, int>& l)
794{
795        try {
796       
[634]797        ptr->set_connection_limit(l.first, l.second);
[454]798       
[460]799        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_connection_limits")
[454]800}
801
802std::pair<float, float> bit::torrent::get_rate_limits() const
803{
804        try {
805       
[634]806        return ptr->get_transfer_speed();
[454]807       
[460]808        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_rate_limits")
[454]809       
810        return std::pair<float, float>(-1.0, -1.0);
811}
812
813void bit::torrent::set_rate_limits(const std::pair<float, float>& l)
814{
815        try {
816       
[642]817        ptr->set_transfer_speed(l.first, l.second);
[454]818       
[460]819        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_rate_limits")
[454]820}
821
[438]822wpath bit::torrent::get_save_directory() const
[427]823{
824        try {
825       
[437]826        return ptr->get_save_directory();
[427]827       
[460]828        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
[427]829       
[437]830        return L"";
[427]831}
832
[438]833void bit::torrent::set_save_directory(const wpath& s)
[437]834{
835        try {
836       
837        ptr->set_save_directory(s);
838       
[460]839        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_save_directory")
[437]840}
841
[438]842wpath bit::torrent::get_move_to_directory() const
[437]843{
844        try {
845       
846        return ptr->get_move_to_directory();
847       
[460]848        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
[437]849       
850        return L"";
851}
852
[438]853void bit::torrent::set_move_to_directory(const wpath& m)
[437]854{
855        try {
856       
857        ptr->set_move_to_directory(m);
858       
[460]859        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_move_to_directory")
[437]860}
861
[453]862std::pair<wstring, wstring> bit::torrent::get_tracker_login() const
863{
864        try {
865       
[634]866        return ptr->get_tracker_login();
[453]867       
[460]868        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("get_tracker_login")
[453]869       
870        return std::make_pair(L"!!! exception thrown !!!", L"!!! exception thrown !!!");
871}
872
873void bit::torrent::set_tracker_login(const std::pair<wstring, wstring>& p)
874{
875        try {
876       
[634]877        ptr->set_tracker_login(p.first, p.second);
[453]878       
[460]879        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_tracker_login")
[453]880}
881
[441]882bool bit::torrent::get_is_active() const
883{
884        try {
885       
886        return ptr->is_active();
887       
[460]888        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_is_active")
[441]889       
890        return L"";
891}
892
893bool bit::torrent::get_in_session() const
894{
895        try {
896       
897        return ptr->in_session();
898       
[460]899        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_in_session")
[441]900       
901        return L"";
902}
[292]903
[456]904std::vector<tracker_detail> bit::torrent::get_trackers() const
905{
906        try {
907       
[634]908        return ptr->get_trackers();
[456]909       
[460]910        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_trackers")
[456]911       
912        return std::vector<tracker_detail>();
913}
914
915void bit::torrent::set_trackers(const std::vector<tracker_detail>& trackers)
916{
917        try {
918       
[620]919        ptr->set_trackers(trackers);
[456]920       
[460]921        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
[456]922}
923
924void bit::torrent::reset_trackers()
925{
926        try {
927       
[620]928        ptr->reset_trackers();
[456]929       
[460]930        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
[456]931}
932
933void bit::torrent::set_file_priorities(const std::pair<std::vector<int>, int>& p)
934{
[460]935        try { 
936
[620]937        ptr->set_file_priorities(p.first, p.second);
[460]938       
939        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
[456]940}
941
[616]942void bit::torrent::adjust_queue_position(bit::queue_adjustments adjust)
943{
944        try { 
945
946        ptr->adjust_queue_position(adjust);
947       
948        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::adjust_queue_position")
949}
950
951bool bit::torrent::get_managed() const
952{
953        try {
954       
955        return ptr->is_managed();
956       
957        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_managed")
958       
959        return false;
960}
961
962void bit::torrent::set_managed(bool m)
963{
964        try {
965       
966        ptr->set_managed(m);
967       
968        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_managed")
969}
970
[634]971void bit::start_event_receiver()
[124]972{
[648]973        try {
974
[503]975        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting event handler.")));
976
[648]977        pimpl()->start_alert_handler();
978       
979        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::start_event_receiver()")
[124]980}
[126]981
[632]982void bit::stop_event_receiver()
[125]983{
[648]984        try {
985
[503]986        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event handler.")));
[474]987
[648]988        pimpl()->stop_alert_handler();
989       
990        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::stop_event_receiver()")
[127]991}
992
[648]993int bit::default_torrent_max_connections() { return pimpl()->default_torrent_max_connections_; }
994int bit::default_torrent_max_uploads() { return pimpl()->default_torrent_max_uploads_; }
995float bit::default_torrent_download() { return pimpl()->default_torrent_download_; }
996float bit::default_torrent_upload() { return pimpl()->default_torrent_upload_; }
[119]997       
[59]998};
Note: See TracBrowser for help on using the repository browser.