source: trunk/src/halTorrent.hpp @ 531

Revision 531, 21.2 KB checked in by Eoin, 11 years ago (diff)

Switched trunk to hal::wform.

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#pragma once
8
9#include <string>
10#include <vector>
11#include <set>
12
13#include <boost/foreach.hpp>
14#include <boost/format.hpp>
15#include <boost/array.hpp>
16#include <boost/lexical_cast.hpp>
17#include <boost/bind.hpp>
18
19#include <boost/smart_ptr.hpp>
20
21#include <boost/noncopyable.hpp>
22
23#include <boost/signal.hpp>
24#include <boost/optional.hpp>
25#include <boost/function.hpp>
26
27#include <boost/smart_ptr.hpp>
28#include <boost/algorithm/string.hpp>
29
30#include <boost/filesystem/path.hpp>
31#include <boost/filesystem/operations.hpp>
32#include <boost/filesystem/fstream.hpp>
33
34#include <stlsoft/properties/method_properties.hpp>
35#include <stlsoft/util/operator_bool_adaptor.hpp>
36
37
38//#if BOOST_VERSION < 103500
39//#include <asio/ip/tcp.hpp>
40//#include <asio/ip/udp.hpp>
41//#else
42#include <boost/asio/ip/tcp.hpp>
43#include <boost/asio/ip/udp.hpp>
44//#endif
45
46#include "halTypes.hpp"
47
48namespace libtorrent { struct peer_info; }
49
50namespace hal
51{
52
53inline boost::wformat wform(const std::wstring & f_string) 
54{
55    using namespace boost::io;
56
57        boost::wformat fmter(f_string);
58    fmter.exceptions( no_error_bits  );
59    return fmter;
60}
61
62struct queue_settings
63{
64        friend class boost::serialization::access;
65        template<class Archive>
66        void serialize(Archive& ar, const unsigned int version)
67        {       
68                ar & BOOST_SERIALIZATION_NVP(auto_manage_interval);
69                ar & BOOST_SERIALIZATION_NVP(active_downloads);
70                ar & BOOST_SERIALIZATION_NVP(active_seeds);
71                ar & BOOST_SERIALIZATION_NVP(seeds_hard_limit);
72                ar & BOOST_SERIALIZATION_NVP(seed_ratio_limit);
73                ar & BOOST_SERIALIZATION_NVP(seed_ratio_time_limit);
74                ar & BOOST_SERIALIZATION_NVP(seed_time_limit);
75                ar & BOOST_SERIALIZATION_NVP(dont_count_slow_torrents);
76                ar & BOOST_SERIALIZATION_NVP(auto_scrape_min_interval);
77                ar & BOOST_SERIALIZATION_NVP(auto_scrape_interval);
78                ar & BOOST_SERIALIZATION_NVP(close_redundant_connections);
79        }
80
81        bool operator==(const queue_settings& s) const
82        {
83                return (auto_manage_interval == s.auto_manage_interval &&
84                        active_downloads == s.active_downloads &&
85                        active_seeds == s.active_seeds &&
86                        seeds_hard_limit == s.seeds_hard_limit &&
87                        seed_ratio_limit == s.seed_ratio_limit &&
88                        seed_ratio_time_limit == s.seed_ratio_time_limit &&
89                        seed_time_limit == s.seed_time_limit &&
90                        dont_count_slow_torrents == s.dont_count_slow_torrents &&
91                        auto_scrape_min_interval == s.auto_scrape_min_interval &&
92                        auto_scrape_interval == s.auto_scrape_interval &&
93                        close_redundant_connections == s.close_redundant_connections);
94        }
95       
96        bool operator!=(const queue_settings& s) const
97        {
98                return !(*this == s);
99        }
100
101        int auto_manage_interval;
102
103        int active_downloads;
104        int active_seeds;
105        int seeds_hard_limit;
106        float seed_ratio_limit;
107        float seed_ratio_time_limit;
108        int seed_time_limit;
109        bool dont_count_slow_torrents;
110
111        int auto_scrape_min_interval;
112        int auto_scrape_interval;
113        bool close_redundant_connections;
114};
115
116struct timeouts
117{
118        friend class boost::serialization::access;
119        template<class Archive>
120        void serialize(Archive& ar, const unsigned int version)
121        {       
122                ar & BOOST_SERIALIZATION_NVP(tracker_completion_timeout);
123                ar & BOOST_SERIALIZATION_NVP(tracker_receive_timeout);
124                ar & BOOST_SERIALIZATION_NVP(stop_tracker_timeout);
125
126                ar & BOOST_SERIALIZATION_NVP(request_queue_time);
127                ar & BOOST_SERIALIZATION_NVP(piece_timeout);
128                ar & BOOST_SERIALIZATION_NVP(min_reconnect_time);
129
130                ar & BOOST_SERIALIZATION_NVP(peer_timeout);
131                ar & BOOST_SERIALIZATION_NVP(urlseed_timeout);
132                ar & BOOST_SERIALIZATION_NVP(peer_connect_timeout);
133                ar & BOOST_SERIALIZATION_NVP(inactivity_timeout);
134                ar & BOOST_SERIALIZATION_NVP(handshake_timeout);
135        }
136
137        int tracker_completion_timeout;
138        int tracker_receive_timeout;
139        int stop_tracker_timeout;
140
141        float request_queue_time;
142        int piece_timeout;
143        int min_reconnect_time;
144
145        int peer_timeout;
146        int urlseed_timeout;
147        int peer_connect_timeout;
148        int inactivity_timeout;
149        int handshake_timeout;
150};
151       
152struct torrentBriefDetail
153{
154        std::wstring filename;
155        std::wstring status;
156        std::pair<float,float> speed;
157        float completion;
158        int peers;
159        int seeds;
160};
161
162struct PeerDetail
163{
164        PeerDetail(const std::wstring& ip_address) :
165                ipAddress(ip_address)
166        {}
167        PeerDetail(libtorrent::peer_info& peerInfo);
168       
169        bool operator==(const PeerDetail& peer) const
170        {
171                return (ipAddress == peer.ipAddress);
172        }
173       
174        bool operator<(const PeerDetail& peer) const
175        {
176                return (ipAddress < peer.ipAddress);
177        }
178       
179        std::wstring ipAddress;
180        std::wstring country;
181        std::pair<float,float> speed;
182        bool seed;
183        std::wstring client;
184        std::wstring status;
185};
186
187typedef boost::shared_ptr<PeerDetail> PeerDetail_ptr;
188typedef std::vector<PeerDetail> PeerDetails;
189
190struct FileDetail
191{
192        FileDetail(boost::filesystem::wpath p, boost::int64_t s=0, float pg=0, int pr=1, size_t o=0, unsigned t=FileDetail::file) :
193                branch(p.branch_path()),
194                filename(p.leaf()),
195                type(t),
196                size(s),
197                progress(pg),
198                priority(pr),
199                order_(o)
200        {}
201       
202        bool operator==(const FileDetail& file) const
203        {
204                return (branch == file.branch);
205        }
206       
207        bool operator<(const FileDetail& file) const
208        {
209                return (branch < file.branch);
210        }
211       
212        enum FileType
213        {
214                folder,
215                file
216        };
217       
218        size_t order() const { return order_; }
219       
220        boost::filesystem::wpath branch;
221        std::wstring filename;
222        unsigned type;
223        boost::int64_t size;
224        float progress;
225        int priority;
226       
227private:
228        size_t order_;
229};
230
231inline bool FileDetailNamesEqual(const FileDetail& l, const FileDetail& r)
232{
233        return l.filename == r.filename;
234}
235
236inline bool FileDetailNamesLess(const FileDetail& l, const FileDetail& r)
237{
238        return l.filename < r.filename;
239}
240
241typedef std::vector<FileDetail> FileDetails;
242
243class torrent_details 
244{
245public:
246        torrent_details(std::wstring n, std::wstring f, std::wstring sd, std::wstring s, std::wstring cT, std::pair<float,float> sp=std::pair<float,float>(0,0),
247                        float c=0, float d=0, size_type tWD=0, size_type tW=0, size_type tU=0, size_type tpU=0, size_type tD=0, size_type tpD=0, boost::tuple<size_type, size_type, size_type, size_type> connections = boost::tuple<size_type, size_type, size_type, size_type>(0,0,0,0), float r=0, 
248                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0), boost::posix_time::time_duration uIn=boost::posix_time::seconds(0),
249                        boost::posix_time::time_duration actve=boost::posix_time::seconds(0), boost::posix_time::time_duration seding=boost::posix_time::seconds(0), boost::posix_time::ptime srt=boost::posix_time::second_clock::universal_time(), boost::posix_time::ptime fin=boost::posix_time::second_clock::universal_time(), int q_p=-1) :
250                filename_(f),
251                name_(n),
252                saveDir_(sd),
253                state_(s),
254                currentTracker_(cT),
255                speed_(sp),
256                completion_(c),
257                distributed_copies_(d),
258                totalWantedDone_(tWD),
259                totalWanted_(tW),
260                totalUploaded_(tU),
261                totalPayloadUploaded_(tpU),
262                totalDownloaded_(tD),
263                totalPayloadDownloaded_(tpD),
264                peers_(connections.get<0>()),
265                connectedPeers_(connections.get<1>()),
266                seeds_(connections.get<2>()),
267                connectedSeeds_(connections.get<3>()),
268                ratio_(r),
269                estimatedTimeLeft_(eta),
270                updateTrackerIn_(uIn),
271                peerDetailsFilled_(false),
272                fileDetailsFilled_(false),
273                active_(actve),
274                seeding_(seding),
275                startTime_(srt),
276                finishTime_(fin),
277                queue_position_(q_p)
278        {}
279
280        torrent_details() :     
281                peerDetailsFilled_(false),
282                fileDetailsFilled_(false)
283        {};     
284       
285        enum state
286        {
287                torrent_active = 0,
288                torrent_paused,
289                torrent_stopped,
290                torrent_pausing,
291                torrent_stopping
292        };
293       
294//      const std::wstring& filename() const { return filename_; }
295        const std::wstring& name() const { return name_; }
296        const std::wstring& saveDirectory() const { return saveDir_; }
297        const std::wstring& state() const { return state_; }
298        const std::wstring& currentTracker() const { return currentTracker_; }
299       
300        std::pair<float,float> speed() const { return speed_; }
301        const float& completion() const { return completion_; }
302        const float& distributedCopies() const { return distributed_copies_; }
303       
304        size_type totalUploaded() const { return totalUploaded_; }
305        size_type totalPayloadUploaded() const { return totalPayloadUploaded_; }
306        size_type totalDownloaded() const { return totalDownloaded_; }
307        size_type totalPayloadDownloaded() const { return totalPayloadDownloaded_; }
308        size_type totalWantedDone() const { return totalWantedDone_; }
309        size_type totalWanted() const { return totalWanted_; }
310       
311        size_type peers() const { return peers_; }
312        size_type peersConnected() const { return connectedPeers_; }
313        size_type seeds() const { return seeds_; }
314        size_type seedsConnected() const { return connectedSeeds_; }
315       
316        float ratio() { return ratio_; }
317       
318        const boost::posix_time::time_duration& estimatedTimeLeft() { return estimatedTimeLeft_; }
319        const boost::posix_time::time_duration& updateTrackerIn() { return updateTrackerIn_; }
320       
321        const PeerDetails& peerDetails() const;
322        const FileDetails& fileDetails() const;
323       
324        const boost::posix_time::time_duration& active() { return active_; }
325        const boost::posix_time::time_duration& seeding() { return seeding_; }
326        const boost::posix_time::ptime& startTime() { return startTime_; }
327        const boost::posix_time::ptime& finishTime() { return finishTime_; }
328
329        int queue_position() const { return queue_position_; }
330       
331public:
332        std::wstring filename_;
333        std::wstring name_;
334        std::wstring saveDir_;
335        std::wstring state_;
336        std::wstring currentTracker_;
337
338        std::pair<float,float> speed_;         
339        float completion_;     
340        float distributed_copies_;
341       
342        size_type totalWantedDone_;
343        size_type totalWanted_;
344        size_type totalUploaded_;
345        size_type totalPayloadUploaded_;
346        size_type totalDownloaded_;
347        size_type totalPayloadDownloaded_;
348       
349        size_type peers_;
350        size_type connectedPeers_;
351        size_type seeds_;
352        size_type connectedSeeds_;
353       
354        float ratio_;
355       
356        boost::posix_time::time_duration estimatedTimeLeft_;
357        boost::posix_time::time_duration updateTrackerIn_;
358       
359        boost::posix_time::time_duration active_;
360        boost::posix_time::time_duration seeding_;
361        boost::posix_time::ptime startTime_;
362        boost::posix_time::ptime finishTime_;
363
364        int queue_position_;
365       
366private:
367        mutable bool peerDetailsFilled_;
368        mutable PeerDetails peerDetails_;
369       
370        mutable bool fileDetailsFilled_;
371        mutable FileDetails fileDetails_;
372};
373
374typedef boost::shared_ptr<torrent_details> torrent_details_ptr;
375typedef boost::scoped_ptr<torrent_details> torrent_details_sptr;
376typedef boost::weak_ptr<torrent_details> torrent_details_wptr;
377typedef std::vector<torrent_details_ptr> torrent_details_vec;
378typedef std::map<std::wstring, torrent_details_ptr> torrent_details_map;
379
380class torrent_details_manager
381{
382public: 
383        void sort(boost::function<bool (const torrent_details_ptr&, const torrent_details_ptr&)> fn) const;
384       
385        const torrent_details_vec torrents() const 
386        {
387                mutex_t::scoped_lock l(mutex_); 
388                return torrents_; 
389        }
390       
391        const torrent_details_vec selectedTorrents() const 
392        { 
393                mutex_t::scoped_lock l(mutex_); 
394                return selectedTorrents_; 
395        }
396       
397        const torrent_details_ptr focusedTorrent() const 
398        {
399                mutex_t::scoped_lock l(mutex_); 
400                return selectedTorrent_; 
401        }
402       
403        const torrent_details_ptr get(std::wstring filename) const
404        {
405                mutex_t::scoped_lock l(mutex_); 
406               
407                torrent_details_map::const_iterator i = torrentMap_.find(filename);
408               
409                if (i != torrentMap_.end())
410                        return i->second;
411                else
412                        return torrent_details_ptr();
413        }
414       
415        friend class bit;
416
417private:
418        void clearAll(const mutex_t::scoped_lock&)
419        {
420                // !! No mutex lock, it should only be call from functions which
421                // have the lock themselves, hence the unused function param
422               
423                torrents_.clear();
424                torrentMap_.clear();
425                selectedTorrents_.clear();
426                selectedTorrent_.reset();
427        }
428
429        mutable torrent_details_vec torrents_;
430       
431        torrent_details_map torrentMap_;
432        torrent_details_vec selectedTorrents_;
433        torrent_details_ptr selectedTorrent_;
434       
435        mutable mutex_t mutex_;
436};
437
438struct tracker_detail
439{
440        tracker_detail() {}
441        tracker_detail(std::wstring u, int t) : url(u), tier(t) {}
442       
443        bool operator<(const tracker_detail& t) const
444        {
445                return (tier < t.tier);
446        }
447       
448        std::wstring url;
449        int tier;
450};
451
452typedef std::vector<tracker_detail> tracker_details_t;
453
454struct web_seed_or_dht_node_detail
455{
456        web_seed_or_dht_node_detail();
457        web_seed_or_dht_node_detail(std::wstring u);
458        web_seed_or_dht_node_detail(std::wstring u, int p);
459               
460        std::wstring url;
461        int port;
462        std::wstring type;
463};
464
465typedef std::vector<pair<fs::wpath, size_type> > file_size_pairs_t;
466
467struct dht_node_detail
468{
469        dht_node_detail() {}
470        dht_node_detail(std::wstring u, int p) : url(u), port(p) {}
471       
472        std::wstring url;
473        int port;
474};
475
476typedef std::vector<dht_node_detail> dht_node_details_t;
477
478struct web_seed_detail
479{
480        web_seed_detail() {}
481        web_seed_detail(std::wstring u) : url(u) {}
482       
483        std::wstring url;
484};
485
486typedef std::vector<web_seed_detail> web_seed_details_t;
487
488struct create_torrent_params
489{
490        create_torrent_params() {}
491
492        std::wstring creator;
493        std::wstring comment;
494        int piece_size;
495        bool private_torrent;
496
497        file_size_pairs_t file_size_pairs;
498        fs::wpath root_path;
499
500        tracker_details_t trackers;
501        dht_node_details_t dht_nodes;
502        web_seed_details_t web_seeds;
503};
504
505class EventDetail;
506
507struct SessionDetail
508{
509        int port;
510       
511        std::pair<double, double> speed;
512       
513        bool dht_on;
514        size_t dht_nodes;
515        size_t dht_torrents;
516       
517        bool ip_filter_on;
518        size_t ip_ranges_filtered;
519};
520
521typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
522typedef boost::function<bool (size_t, std::wstring)> progress_callback;
523typedef boost::function<void (int)> report_num_active;
524typedef std::pair<wstring, wstring> wstring_pair;
525typedef std::pair<float, float> float_pair;
526typedef std::pair<int, int> int_pair;
527typedef std::pair<std::vector<int>, int> vec_int_pair;
528
529class bit_impl;
530class torrent_internal;
531
532class bit
533{
534public: 
535
536        class null_torrent : public std::exception
537        {
538        public:
539                null_torrent() {}               
540                virtual ~null_torrent() throw () {}
541        };
542
543        class torrent : public stlsoft::operator_bool_adaptor<torrent>
544        {
545                typedef torrent class_type;
546
547        public:
548                class exec_around_ptr
549                {
550                public:
551                        class proxy 
552                        {
553                        public:
554                                explicit proxy(torrent_internal* t);
555
556                                torrent_internal* operator->() 
557                                {
558                                        return t_;
559                                }
560
561                                ~proxy ();
562
563                        private:
564                                torrent_internal* t_;
565                                mutex_t::scoped_lock l_;
566                        };
567
568                        exec_around_ptr() {}
569                        exec_around_ptr(boost::shared_ptr<torrent_internal> p) : ptr(p) {}
570
571                        proxy operator->() const
572                        {
573                                if (!ptr)
574                                        throw null_torrent();
575
576                                return proxy(&(*ptr));
577                        }
578
579                        operator bool() const { return ptr; }
580
581                private:
582                        boost::shared_ptr<torrent_internal> ptr;
583                };
584
585                torrent();
586                torrent(boost::shared_ptr<torrent_internal> p);
587
588                const std::wstring get_name() const;
589
590                float get_ratio() const;
591                void set_ratio(float new_ratio);
592               
593                std::pair<int, int> get_connection_limits() const;
594                void set_connection_limits(const std::pair<int, int>&);
595                std::pair<float, float> get_rate_limits() const;
596                void set_rate_limits(const std::pair<float, float>&);
597
598                wpath get_save_directory() const;
599                void set_save_directory(const wpath&);
600                wpath get_move_to_directory() const;
601                void set_move_to_directory(const wpath&);
602
603                std::pair<wstring, wstring> get_tracker_login() const;
604                void set_tracker_login(const std::pair<wstring, wstring>&);
605
606                std::vector<tracker_detail> get_trackers() const;
607                void set_trackers(const std::vector<tracker_detail>&);
608
609                bool get_is_active() const;
610                bool get_in_session() const;
611
612                void set_file_priorities(const vec_int_pair&);
613
614        public:
615                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(const std::wstring, class_type, 
616                        get_name, name);
617
618                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type, 
619                        get_ratio, set_ratio, ratio);
620
621                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(int_pair, const int_pair&, class_type, 
622                        get_connection_limits, set_connection_limits, connection_limits);
623                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float_pair, const float_pair&, class_type, 
624                        get_rate_limits, set_rate_limits, rate_limits);
625               
626                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
627                        get_save_directory, set_save_directory, save_directory);
628                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
629                        get_move_to_directory, set_move_to_directory, move_to_directory);
630
631                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wstring_pair, const wstring_pair&, 
632                        class_type, get_tracker_login, set_tracker_login, tracker_login);
633
634                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
635                        get_is_active, is_active);
636                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
637                        get_in_session, in_session);
638
639                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(std::vector<tracker_detail>, const std::vector<tracker_detail>&, 
640                        class_type, get_trackers, set_trackers, trackers);
641
642                STLSOFT_METHOD_PROPERTY_SET_EXTERNAL(const vec_int_pair&, class_type, 
643                        set_file_priorities, file_priorities);
644
645                void reset_trackers();
646
647                bool is_open() const;
648
649
650        private:
651                exec_around_ptr ptr;
652        };
653
654        enum mappings
655        {
656                mappingNone = 0,
657                mappingUPnP,
658                mappingNatPMP
659        };
660
661        void shutDownSession();
662        void save_torrent_data();
663
664        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn);
665
666        template<typename T>
667        torrent get(T t)
668        {
669                return get_wstr(to_wstr_shim(t));
670        }
671       
672        template<>
673        torrent get(const hal::torrent_details_ptr t)
674        {
675                if (t) 
676                        return get_wstr(t->name());
677                else
678                        return torrent();
679        }       
680       
681        bool listen_on(std::pair<int, int> const& portRange);
682        int is_listening_on();
683        void stop_listening();
684       
685        bool ensure_dht_on();
686        void ensure_dht_off();
687       
688        void ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4);
689        void ensure_pe_off();
690       
691        bool ensure_ip_filter_on(progress_callback fn);
692        void ensure_ip_filter_off();
693
694        void set_mapping(int mapping);
695
696        void ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last);
697        void ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last);
698        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
699        size_t ip_filter_size();
700        void clear_ip_filter(); 
701       
702        void setSessionHalfOpenLimit(int halfConn);
703        void set_session_limits(int maxConn, int maxUpload);
704        void set_session_speed(float download, float upload);
705        void set_dht_settings(int max_peers_reply, int search_branching, int service_port, int max_fail_count);
706
707        queue_settings get_queue_settings();
708        void set_queue_settings(const queue_settings& s);
709       
710        timeouts get_timeouts();
711        void set_timeouts(const timeouts& t);
712       
713        const SessionDetail getSessionDetails();
714
715        void setTorrentDefaults(int maxConn, int maxUpload, float download, float upload);     
716        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
717                bool startPaused=false, bool compactStorage=false, 
718                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false);
719       
720        void getAllPeerDetails(const std::string& filename, PeerDetails& peerContainer);
721        void getAllPeerDetails(const std::wstring& filename, PeerDetails& peerContainer);
722        void getAllFileDetails(const std::string& filename, FileDetails& fileDetails);
723        void getAllFileDetails(const std::wstring& filename, FileDetails& fileDetails);
724       
725        void resume_all();
726        void close_all(boost::optional<report_num_active> fn);
727       
728        bool isTorrent(const std::string& filename);
729        bool isTorrent(const std::wstring& filename);   
730       
731        void pauseTorrent(const std::string& filename);
732        void pauseTorrent(const std::wstring& filename);
733        void resumeTorrent(const std::string& filename);
734        void resumeTorrent(const std::wstring& filename);
735        void stopTorrent(const std::string& filename);
736        void stopTorrent(const std::wstring& filename);
737        bool isTorrentActive(const std::string& filename);
738        bool isTorrentActive(const std::wstring& filename);
739        void reannounceTorrent(const std::string& filename);
740        void reannounceTorrent(const std::wstring& filename);
741        void recheckTorrent(const std::string& filename);
742        void recheckTorrent(const std::wstring& filename);
743       
744        void pauseAllTorrents();
745        void unpauseAllTorrents();
746
747        template<typename S>
748        void remove_torrent(S filename)
749        { 
750                remove_torrent_wstr(to_wstr_shim(filename)); 
751        }       
752
753        template<typename S>
754        void remove_torrent_wipe_files(S filename)
755        { 
756                remove_torrent_wipe_files_wstr(to_wstr_shim(filename)); 
757        }       
758
759        void startEventReceiver();
760        void stopEventReceiver();
761       
762        friend bit& bittorrent();
763       
764        int defTorrentMaxConn();
765        int defTorrentMaxUpload();
766        float defTorrentDownload();
767        float defTorrentUpload();       
768
769        const torrent_details_manager& torrentDetails();
770        const torrent_details_manager& updatetorrent_details_manager(const std::wstring& focused, const std::set<std::wstring>& selected);
771       
772private:
773        bit();
774        boost::scoped_ptr<bit_impl> pimpl;
775
776        torrent get_wstr(const std::wstring& filename);
777       
778        void remove_torrent_wstr(const std::wstring& filename);
779        void remove_torrent_wipe_files_wstr(const std::wstring&  filename);
780       
781        torrent_details_manager torrentDetails_;
782};
783
784bit& bittorrent();
785
786};
Note: See TracBrowser for help on using the repository browser.