source: trunk/src/halTorrent.cpp @ 661

Revision 661, 24.8 KB checked in by Eoin, 11 years ago (diff)

File list working but very slow.

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