source: trunk/src/halTorrent.cpp @ 660

Revision 660, 23.1 KB checked in by Eoin, 11 years ago (diff)

FileDetail? struct converted to file_details along with other related naming changes.

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