source: trunk/src/halTorrent.hpp @ 519

Revision 519, 21.1 KB checked in by Eoin, 11 years ago (diff)

Adding a 'queued view' mode to main listview.

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