source: trunk/src/halTorrent.hpp @ 778

Revision 778, 21.2 KB checked in by Eoin, 10 years ago (diff)

Made get torrent details non-blocking. Need to do same for get session details.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2009.
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#include <boost/noncopyable.hpp>
21
22#include <boost/signal.hpp>
23#include <boost/optional.hpp>
24#include <boost/function.hpp>
25
26#include <boost/smart_ptr.hpp>
27
28#include <boost/filesystem/path.hpp>
29#include <boost/filesystem/operations.hpp>
30#include <boost/filesystem/fstream.hpp>
31*/
32
33#include <boost/algorithm/string.hpp>
34
35#include <stlsoft/properties/method_properties.hpp>
36#include <stlsoft/util/operator_bool_adaptor.hpp>
37
38#include <loki/Singleton.h>
39
40#include <boost/asio/ip/tcp.hpp>
41#include <boost/asio/ip/udp.hpp>
42
43#include <boost/asio/deadline_timer.hpp>
44#include <boost/date_time/posix_time/posix_time.hpp>
45
46#include "halTypes.hpp"
47#include "halPeers.hpp"
48
49namespace hal
50{
51
52template<typename T>
53bool hal_details_ptr_compare(T l, T r, size_t index = 0, bool cmp_less = true)
54{
55        if (cmp_less)
56                return l->less(*r, index);
57        else
58                return r->less(*l, index);
59}
60
61template<typename T>
62bool hal_details_compare(T l, T r, size_t index = 0, bool cmp_less = true)
63{
64        if (cmp_less)
65                return l.less(r, index);
66        else
67                return r.less(l, index);
68}
69
70inline boost::wformat wform(const std::wstring & f_string) 
71{
72    using namespace boost::io;
73
74        boost::wformat fmter(f_string);
75    fmter.exceptions( no_error_bits  );
76    return fmter;
77}
78
79struct torrentBriefDetail
80{
81        std::wstring filename;
82        std::wstring status;
83        std::pair<float,float> speed;
84        float completion;
85        int peers;
86        int seeds;
87};
88
89struct queue_settings;
90struct timeouts;
91struct dht_settings;
92struct cache_settings;
93struct pe_settings;
94struct connections;
95struct cache_details;
96
97
98struct file_details
99{
100        enum details
101        {
102                filename_e = 0,
103                branch_e,
104                size_e,
105                progress_e,
106                priority_e,
107                type_e
108        };
109
110        file_details(boost::filesystem::wpath p, 
111                        boost::int64_t s=0, 
112                        boost::int64_t pg=0, 
113                        int pr=1, 
114                        size_t o=0, 
115                        unsigned t=file_details::file) :
116                branch(p.parent_path()),
117                filename(p.filename()),
118                type(t),
119                size(s),
120                progress(pg),
121                priority(pr),
122                order_(o)
123        {}
124       
125        bool operator==(const file_details& file) const
126        {
127                return (branch == file.branch);
128        }
129       
130        bool operator<(const file_details& file) const
131        {
132                return (branch < file.branch);
133        }
134       
135        bool less(const file_details& r, size_t index = 0) const;
136        std::wstring to_wstring(size_t index = 0);
137       
138        enum file_type
139        {
140                folder,
141                file
142        };
143       
144        size_t order() const { return order_; }
145       
146        boost::filesystem::wpath branch;
147        std::wstring filename;
148        unsigned type;
149        boost::int64_t size;
150        boost::int64_t progress;
151        int priority;
152       
153private:
154        size_t order_;
155};
156
157inline bool file_details_names_equal(const file_details& l, const file_details& r)
158{
159        return l.filename == r.filename;
160}
161
162inline bool file_details_names_less(const file_details& l, const file_details& r)
163{
164        return l.filename < r.filename;
165}
166
167typedef std::vector<file_details> file_details_vec;
168
169void file_details_sort(file_details_vec& f, size_t index, bool cmp_less = true);
170
171class torrent_details 
172{
173public:
174        torrent_details(std::wstring n, std::wstring f, 
175                        std::wstring sd, 
176                        std::wstring s, 
177                        std::wstring cT, 
178                        std::pair<float,float> sp=std::pair<float,float>(0,0),
179                        float c=0, float d=0, 
180                        size_type tWD=0, size_type tW=0, 
181                        size_type tU=0, size_type tpU=0, 
182                        size_type tD=0, size_type tpD=0, 
183                        boost::tuple<size_type, size_type, size_type, size_type> connections = 
184                                boost::tuple<size_type, size_type, size_type, size_type>(0,0,0,0), 
185                        float r=0, 
186                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0), 
187                        boost::posix_time::time_duration uIn=boost::posix_time::seconds(0),
188                        boost::posix_time::time_duration actve=boost::posix_time::seconds(0), 
189                        boost::posix_time::time_duration seding=boost::posix_time::seconds(0), 
190                        boost::posix_time::ptime srt=boost::posix_time::second_clock::universal_time(), 
191                        boost::posix_time::ptime fin=boost::posix_time::second_clock::universal_time(), 
192                        int q_p=-1, 
193                        bool man=false) :
194                filename_(f),
195                name_(n),
196                saveDir_(sd),
197                state_(s),
198                currentTracker_(cT),
199                speed_(sp),
200                completion_(c),
201                distributed_copies_(d),
202                total_wanted_done_(tWD),
203                total_wanted_(tW),
204                total_uploaded_(tU),
205                total_payload_uploaded_(tpU),
206                total_downloaded_(tD),
207                total_payload_downloaded_(tpD),
208                peers_(connections.get<0>()),
209                connected_peers_(connections.get<1>()),
210                seeds_(connections.get<2>()),
211                connected_seeds_(connections.get<3>()),
212                ratio_(r),
213                estimated_time_left_(eta),
214                update_tracker_in_(uIn),
215                peer_details_filled_(false),
216                file_details_filled_(false),
217                active_(actve),
218                seeding_(seding),
219                start_time_(srt),
220                finish_time_(fin),
221                queue_position_(q_p),
222                managed_(man)
223        {}
224
225        torrent_details() :     
226                peer_details_filled_(false),
227                file_details_filled_(false)
228        {};
229       
230        enum state
231        {
232                torrent_active = 0,
233                torrent_paused,
234                torrent_stopped,
235                torrent_pausing,
236                torrent_stopping,
237                torrent_in_error,
238                torrent_not_started
239        };
240
241        enum details
242        {
243                name_e = 0,
244                state_e,
245                progress_e,
246                speed_down_e,
247                speed_up_e,
248                peers_e,
249                seeds_e,
250                eta_e,
251                distributed_copies_e,
252                tracker,
253                update_tracker_in_e,
254                ratio_e,
255                total_wanted_e,
256                completed_e,
257                remaining_e,
258                downloaded_e,
259                uploaded_e,
260                active_time_e,
261                seeding_time_e,
262                start_time_e,
263                finish_time_e,
264                managed_e,
265                queue_position_e
266        };
267       
268//      const std::wstring& filename() const { return filename_; }
269        const std::wstring& name() const { return name_; }
270        const std::wstring& save_directory() const { return saveDir_; }
271        const std::wstring& state() const { return state_; }
272        const std::wstring& current_tracker() const { return currentTracker_; }
273       
274        std::pair<float,float> speed() const { return speed_; }
275        const float& completion() const { return completion_; }
276        const float& distributed_copies() const { return distributed_copies_; }
277       
278        size_type total_uploaded() const { return total_uploaded_; }
279        size_type total_payload_uploaded() const { return total_payload_uploaded_; }
280        size_type total_downloaded() const { return total_downloaded_; }
281        size_type total_payload_downloaded() const { return total_payload_downloaded_; }
282        size_type total_wanted_done() const { return total_wanted_done_; }
283        size_type total_wanted() const { return total_wanted_; }
284       
285        size_type peers() const { return peers_; }
286        size_type peers_connected() const { return connected_peers_; }
287        size_type seeds() const { return seeds_; }
288        size_type seeds_connected() const { return connected_seeds_; }
289       
290        float ratio() { return ratio_; }
291       
292        const boost::posix_time::time_duration& estimated_time_left() { return estimated_time_left_; }
293        const boost::posix_time::time_duration& update_tracker_in() { return update_tracker_in_; }
294       
295        const peer_details_vec& get_peer_details() const;
296        const file_details_vec& get_file_details() const;
297       
298        const boost::posix_time::time_duration& active() { return active_; }
299        const boost::posix_time::time_duration& seeding() { return seeding_; }
300        const boost::posix_time::ptime& start_time() { return start_time_; }
301        const boost::posix_time::ptime& finish_time() { return finish_time_; }
302
303        int queue_position() const { return queue_position_; }
304        bool managed() const { return managed_; }
305
306        bool less(const torrent_details& r, size_t index = 0) const;
307        std::wstring to_wstring(size_t index = 0);
308       
309public:
310        std::wstring filename_;
311        std::wstring name_;
312        std::wstring saveDir_;
313        std::wstring state_;
314        std::wstring currentTracker_;
315
316        std::pair<float,float> speed_;         
317        float completion_;     
318        float distributed_copies_;
319       
320        size_type total_wanted_done_;
321        size_type total_wanted_;
322        size_type total_uploaded_;
323        size_type total_payload_uploaded_;
324        size_type total_downloaded_;
325        size_type total_payload_downloaded_;
326       
327        size_type peers_;
328        size_type connected_peers_;
329        size_type seeds_;
330        size_type connected_seeds_;
331       
332        float ratio_;
333       
334        boost::posix_time::time_duration estimated_time_left_;
335        boost::posix_time::time_duration update_tracker_in_;
336       
337        boost::posix_time::time_duration active_;
338        boost::posix_time::time_duration seeding_;
339        boost::posix_time::ptime start_time_;
340        boost::posix_time::ptime finish_time_;
341
342        int queue_position_;
343        bool managed_;
344       
345private:
346        mutable bool peer_details_filled_;
347        mutable peer_details_vec peer_details_;
348       
349        mutable bool file_details_filled_;
350        mutable file_details_vec file_details_;
351};
352
353typedef boost::shared_ptr<torrent_details> torrent_details_ptr;
354typedef boost::scoped_ptr<torrent_details> torrent_details_sptr;
355typedef boost::weak_ptr<torrent_details> torrent_details_wptr;
356typedef std::vector<torrent_details_ptr> torrent_details_vec;
357typedef std::set<torrent_details_ptr> torrent_details_set;
358typedef std::map<std::wstring, torrent_details_ptr> torrent_details_map;
359
360class torrent_details_manager
361{
362public: 
363        void sort(size_t index, bool cmp_less = true) const;
364       
365        const torrent_details_set torrents() const 
366        {
367                mutex_t::scoped_lock l(mutex_); 
368
369                torrent_details_set torrents;
370
371                for (torrent_details_map::const_iterator i = torrent_map_.begin(), e = torrent_map_.end();
372                                i != e; ++i)
373                        torrents.insert(i->second);
374
375                return torrents; 
376        }
377
378        const torrent_details_ptr focused_torrent() const 
379        {
380                return get(focused_); 
381        }
382
383        const std::set<wstring>& selected_names() const { return selected_names_; }
384       
385        const torrent_details_ptr get(std::wstring filename) const
386        {
387                mutex_t::scoped_lock l(mutex_); 
388               
389                torrent_details_map::const_iterator i = torrent_map_.find(filename);
390               
391                if (i != torrent_map_.end())
392                        return i->second;
393                else
394                        return torrent_details_ptr();
395        }
396       
397        friend class bit;
398
399private:
400        void clear_all(const mutex_t::scoped_lock&)
401        {
402                // !! No mutex lock, it should only be called from functions which
403                // have the lock themselves, hence the unused function param
404               
405                torrent_map_.clear();
406        }
407
408        std::set<wstring> selected_names_;
409        torrent_details_map torrent_map_;
410
411        wstring focused_;
412       
413        mutable mutex_t mutex_;
414};
415
416struct tracker_detail
417{
418        tracker_detail() {}
419        tracker_detail(std::wstring u, int t) : url(u), tier(t) {}
420       
421        bool operator<(const tracker_detail& t) const
422        {
423                return (tier < t.tier);
424        }
425       
426        std::wstring url;
427        int tier;
428};
429
430typedef std::vector<tracker_detail> tracker_details_t;
431
432struct web_seed_or_dht_node_detail
433{
434        web_seed_or_dht_node_detail();
435        web_seed_or_dht_node_detail(std::wstring u);
436        web_seed_or_dht_node_detail(std::wstring u, int p);
437               
438        std::wstring url;
439        int port;
440        std::wstring type;
441};
442
443typedef std::vector<pair<fs::wpath, size_type> > file_size_pairs_t;
444
445struct dht_node_detail
446{
447        dht_node_detail() {}
448        dht_node_detail(std::wstring u, int p) : url(u), port(p) {}
449       
450        std::wstring url;
451        int port;
452};
453
454typedef std::vector<dht_node_detail> dht_node_details_t;
455
456struct web_seed_detail
457{
458        web_seed_detail() {}
459        web_seed_detail(std::wstring u) : url(u) {}
460       
461        std::wstring url;
462};
463
464typedef std::vector<web_seed_detail> web_seed_details_t;
465
466struct create_torrent_params
467{
468        create_torrent_params() {}
469
470        std::wstring creator;
471        std::wstring comment;
472        int piece_size;
473        bool private_torrent;
474
475        file_size_pairs_t file_size_pairs;
476        fs::wpath root_path;
477
478        tracker_details_t trackers;
479        dht_node_details_t dht_nodes;
480        web_seed_details_t web_seeds;
481};
482
483class EventDetail;
484
485struct SessionDetail
486{
487        int port;
488       
489        std::pair<double, double> speed;
490       
491        bool dht_on;
492        size_t dht_nodes;
493        size_t dht_torrents;
494       
495        bool ip_filter_on;
496        size_t ip_ranges_filtered;
497};
498
499typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
500typedef boost::function<bool (size_t, size_t, std::wstring)> progress_callback;
501typedef boost::function<void ()> action_callback_t;
502typedef boost::function<void (int)> report_num_active;
503typedef boost::function<void (wpath path, boost::shared_ptr<file_details_vec> files)> remove_files;
504typedef std::pair<wstring, wstring> wstring_pair;
505typedef std::pair<float, float> float_pair;
506typedef std::pair<int, int> int_pair;
507typedef std::pair<std::vector<int>, int> vec_int_pair;
508
509class bit_impl;
510class torrent_internal;
511
512class bit
513{
514public:         
515
516        enum mappings
517        {
518                mappingNone = 0,
519                mappingUPnP,
520                mappingNatPMP
521        };
522
523        enum allocations
524        {
525                sparse_allocation = 1,
526                compact_allocation,
527                full_allocation
528        };
529
530        enum queue_adjustments
531        {
532                move_up = 0,
533                move_down,
534                move_to_top,
535                move_to_bottom
536        };
537       
538        enum timeout_actions
539        {
540                action_pause = 0,
541                action_resume,
542                action_callback
543        };
544
545        class null_torrent : public std::exception
546        {
547        public:
548                null_torrent() {}               
549                virtual ~null_torrent() throw () {}
550        };
551
552        class torrent : public stlsoft::operator_bool_adaptor<torrent>
553        {
554                typedef torrent class_type;
555
556        public:
557                class exec_around_ptr
558                {
559                public:
560                        class proxy 
561                        {
562                        public:
563                                explicit proxy(torrent_internal* t);
564
565                                torrent_internal* operator->() 
566                                {
567                                        return t_;
568                                }
569
570                                ~proxy ();
571
572                        private:
573                                torrent_internal* t_;
574                                mutex_t::scoped_lock l_;
575                        };
576
577                        exec_around_ptr() {}
578                        exec_around_ptr(boost::shared_ptr<torrent_internal> p) : ptr(p) {}
579
580                        proxy operator->() const
581                        {
582                                if (!ptr)
583                                        throw null_torrent();
584
585                                return proxy(&(*ptr));
586                        }
587
588                        operator bool() const { return ptr; }
589
590                private:
591                        boost::shared_ptr<torrent_internal> ptr;
592                };
593
594                torrent();
595                torrent(boost::shared_ptr<torrent_internal> p);
596
597                const std::wstring get_name() const;
598
599                float get_ratio() const;
600                void set_ratio(float new_ratio);
601               
602                std::pair<int, int> get_connection_limits() const;
603                void set_connection_limits(const std::pair<int, int>&);
604                std::pair<float, float> get_rate_limits() const;
605                void set_rate_limits(const std::pair<float, float>&);
606
607                wpath get_save_directory() const;
608                void set_save_directory(const wpath&);
609                wpath get_move_to_directory() const;
610                void set_move_to_directory(const wpath&);
611
612                std::pair<wstring, wstring> get_tracker_login() const;
613                void set_tracker_login(const std::pair<wstring, wstring>&);
614
615                std::vector<tracker_detail> get_trackers() const;
616                void set_trackers(const std::vector<tracker_detail>&);
617
618                bool get_is_active() const;
619                bool get_in_session() const;
620
621                void set_file_priorities(const vec_int_pair&);
622
623                void set_managed(bool);
624                bool get_managed() const;
625
626        public:
627                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(const std::wstring, class_type, 
628                        get_name, name);
629
630                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type, 
631                        get_ratio, set_ratio, ratio);
632
633                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(int_pair, const int_pair&, class_type, 
634                        get_connection_limits, set_connection_limits, connection_limits);
635                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float_pair, const float_pair&, class_type, 
636                        get_rate_limits, set_rate_limits, rate_limits);
637               
638                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
639                        get_save_directory, set_save_directory, save_directory);
640                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
641                        get_move_to_directory, set_move_to_directory, move_to_directory);
642
643                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wstring_pair, const wstring_pair&, 
644                        class_type, get_tracker_login, set_tracker_login, tracker_login);
645
646                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
647                        get_is_active, is_active);
648                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
649                        get_in_session, in_session);
650
651                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(std::vector<tracker_detail>, const std::vector<tracker_detail>&, 
652                        class_type, get_trackers, set_trackers, trackers);
653
654                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(bool, bool, class_type, 
655                        get_managed, set_managed, managed);
656
657                STLSOFT_METHOD_PROPERTY_SET_EXTERNAL(const vec_int_pair&, class_type, 
658                        set_file_priorities, file_priorities);
659
660                void reset_trackers();
661                bool is_open() const;
662                void adjust_queue_position(bit::queue_adjustments adjust);
663
664        private:
665                exec_around_ptr ptr;
666        };
667
668        void shutdown_session();
669        void save_torrent_data();
670
671        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn);
672
673        template<typename T>
674        torrent get(T t)
675        {
676                return get_wstr(to_wstr_shim(t));
677        }
678       
679        template<>
680        torrent get(const hal::torrent_details_ptr t)
681        {
682                if (t) 
683                        return get_wstr(t->name());
684                else
685                        return torrent();
686        }       
687
688        torrent get_wstr(const std::wstring& filename);
689       
690        bool listen_on(std::pair<int, int> const& portRange);
691        int is_listening_on();
692        void stop_listening();
693       
694        bool ensure_dht_on(const dht_settings& dht);
695        void ensure_dht_off();
696       
697        void ensure_pe_on(const pe_settings& pe);
698        void ensure_pe_off();
699       
700        bool ensure_ip_filter_on(progress_callback fn);
701        void ensure_ip_filter_off();
702
703        void set_resolve_countries(bool);
704        void start_smart_ban_plugin();
705        void start_ut_pex_plugin();
706        void start_ut_metadata_plugin();
707        void start_metadata_plugin();
708
709        void set_mapping(bool upnp, bool nat_pmp);
710        std::wstring upnp_router_model();
711
712        void ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last);
713        void ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last);
714        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
715        size_t ip_filter_size();
716        void clear_ip_filter(); 
717       
718        void set_session_half_open_limit(int halfConn);
719        void set_session_limits(int maxConn, int maxUpload);
720        void set_session_speed(float download, float upload);
721
722        queue_settings get_queue_settings();
723        void set_queue_settings(const queue_settings& s);
724       
725        timeouts get_timeouts();
726        void set_timeouts(const timeouts& t);
727
728        const cache_details get_cache_details() const;
729
730        void set_cache_settings(const cache_settings& cache);
731        cache_settings get_cache_settings() const;
732       
733        const SessionDetail get_session_details();
734
735        void set_torrent_defaults(const connections& defaults); 
736        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
737                bool startPaused=false, bool managed=false, allocations alloc=hal::bit::sparse_allocation, 
738                boost::filesystem::wpath moveToDirectory=L"");
739       
740        void get_all_peer_details(const std::string& filename, peer_details_vec& peerContainer);
741        void get_all_peer_details(const std::wstring& filename, peer_details_vec& peerContainer);
742        void get_all_file_details(const std::string& filename, file_details_vec& file_details);
743        void get_all_file_details(const std::wstring& filename, file_details_vec& file_details);
744       
745        void resume_all();
746        void close_all(boost::optional<report_num_active> fn);
747       
748        bool is_torrent(const std::string& filename);
749        bool is_torrent(const std::wstring& filename); 
750       
751        void pause_torrent(const std::string& filename);
752        void pause_torrent(const std::wstring& filename);
753        void resume_torrent(const std::string& filename);
754        void resume_torrent(const std::wstring& filename);
755        void stop_torrent(const std::string& filename);
756        void stop_torrent(const std::wstring& filename);
757        bool is_torrent_active(const std::string& filename);
758        bool is_torrent_active(const std::wstring& filename);
759        void reannounce_torrent(const std::string& filename);
760        void reannounce_torrent(const std::wstring& filename);
761        void recheck_torrent(const std::string& filename);
762        void recheck_torrent(const std::wstring& filename);
763       
764        void pause_all_torrents();
765        void unpause_all_torrents();
766        bool is_any_torrent_active();
767
768        template<typename S>
769        void remove_torrent(S filename)
770        { 
771                remove_torrent_wstr(to_wstr_shim(filename)); 
772        }       
773
774        template<typename S>
775        void remove_torrent_wipe_files(S filename, remove_files fn)
776        { 
777                remove_torrent_wipe_files_wstr(to_wstr_shim(filename), fn); 
778        }       
779
780        void start_event_receiver();
781        void stop_event_receiver();
782
783        void schedual_action(boost::posix_time::ptime time, timeout_actions action);
784        void schedual_action(boost::posix_time::time_duration duration, timeout_actions action);
785
786        void schedual_callback(boost::posix_time::ptime time, action_callback_t);
787        void schedual_callback(boost::posix_time::time_duration duration, action_callback_t);
788
789        void schedual_cancel();
790       
791//      friend bit& bittorrent();
792       
793        int default_torrent_max_connections();
794        int default_torrent_max_uploads();
795        float default_torrent_download();
796        float default_torrent_upload(); 
797
798        const torrent_details_manager& torrentDetails();
799        const torrent_details_manager& update_torrent_details_manager(
800                const std::wstring& focused, const std::set<std::wstring>& selected);
801       
802        bit();
803        ~bit();
804
805private:
806        bit_impl* pimpl();
807        const bit_impl* pimpl() const;
808        boost::scoped_ptr<bit_impl> pimpl_;
809       
810        void remove_torrent_wstr(const std::wstring& filename);
811        void remove_torrent_wipe_files_wstr(const std::wstring&  filename, remove_files fn);
812
813        void update_torrent_details_manager_thread(
814                const wstring& focused, const std::set<wstring>& selected);
815       
816        torrent_details_manager torrentDetails_;
817};
818
819typedef Loki::SingletonHolder<bit, Loki::CreateUsingNew, Loki::PhoenixSingleton> bittorrent;
820
821};
Note: See TracBrowser for help on using the repository browser.