source: trunk/src/halTorrent.hpp @ 760

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

Auto exit after a (currently hardcoded) time working.

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::map<std::wstring, torrent_details_ptr> torrent_details_map;
358
359class torrent_details_manager
360{
361public: 
362        void sort(size_t index, bool cmp_less = true) const;
363       
364        const torrent_details_vec torrents() const 
365        {
366                mutex_t::scoped_lock l(mutex_); 
367                return torrents_; 
368        }
369       
370        const torrent_details_vec selectedTorrents() const 
371        { 
372                mutex_t::scoped_lock l(mutex_); 
373                return selectedTorrents_; 
374        }
375       
376        const torrent_details_ptr focusedTorrent() const 
377        {
378                mutex_t::scoped_lock l(mutex_); 
379                return selectedTorrent_; 
380        }
381
382        const std::set<wstring>& selected_names() const { return selected_names_; }
383       
384        const torrent_details_ptr get(std::wstring filename) const
385        {
386                mutex_t::scoped_lock l(mutex_); 
387               
388                torrent_details_map::const_iterator i = torrentMap_.find(filename);
389               
390                if (i != torrentMap_.end())
391                        return i->second;
392                else
393                        return torrent_details_ptr();
394        }
395       
396        friend class bit;
397
398private:
399        void clearAll(const mutex_t::scoped_lock&)
400        {
401                // !! No mutex lock, it should only be called from functions which
402                // have the lock themselves, hence the unused function param
403               
404                torrents_.clear();
405                torrentMap_.clear();
406                selectedTorrents_.clear();
407                selectedTorrent_.reset();
408        }
409
410        mutable torrent_details_vec torrents_;
411       
412        torrent_details_map torrentMap_;
413        torrent_details_vec selectedTorrents_;
414        torrent_details_ptr selectedTorrent_;
415        std::set<wstring> selected_names_;
416       
417        mutable mutex_t mutex_;
418};
419
420struct tracker_detail
421{
422        tracker_detail() {}
423        tracker_detail(std::wstring u, int t) : url(u), tier(t) {}
424       
425        bool operator<(const tracker_detail& t) const
426        {
427                return (tier < t.tier);
428        }
429       
430        std::wstring url;
431        int tier;
432};
433
434typedef std::vector<tracker_detail> tracker_details_t;
435
436struct web_seed_or_dht_node_detail
437{
438        web_seed_or_dht_node_detail();
439        web_seed_or_dht_node_detail(std::wstring u);
440        web_seed_or_dht_node_detail(std::wstring u, int p);
441               
442        std::wstring url;
443        int port;
444        std::wstring type;
445};
446
447typedef std::vector<pair<fs::wpath, size_type> > file_size_pairs_t;
448
449struct dht_node_detail
450{
451        dht_node_detail() {}
452        dht_node_detail(std::wstring u, int p) : url(u), port(p) {}
453       
454        std::wstring url;
455        int port;
456};
457
458typedef std::vector<dht_node_detail> dht_node_details_t;
459
460struct web_seed_detail
461{
462        web_seed_detail() {}
463        web_seed_detail(std::wstring u) : url(u) {}
464       
465        std::wstring url;
466};
467
468typedef std::vector<web_seed_detail> web_seed_details_t;
469
470struct create_torrent_params
471{
472        create_torrent_params() {}
473
474        std::wstring creator;
475        std::wstring comment;
476        int piece_size;
477        bool private_torrent;
478
479        file_size_pairs_t file_size_pairs;
480        fs::wpath root_path;
481
482        tracker_details_t trackers;
483        dht_node_details_t dht_nodes;
484        web_seed_details_t web_seeds;
485};
486
487class EventDetail;
488
489struct SessionDetail
490{
491        int port;
492       
493        std::pair<double, double> speed;
494       
495        bool dht_on;
496        size_t dht_nodes;
497        size_t dht_torrents;
498       
499        bool ip_filter_on;
500        size_t ip_ranges_filtered;
501};
502
503typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
504typedef boost::function<bool (size_t, size_t, std::wstring)> progress_callback;
505typedef boost::function<void ()> action_callback_t;
506typedef boost::function<void (int)> report_num_active;
507typedef boost::function<void (wpath path, boost::shared_ptr<file_details_vec> files)> remove_files;
508typedef std::pair<wstring, wstring> wstring_pair;
509typedef std::pair<float, float> float_pair;
510typedef std::pair<int, int> int_pair;
511typedef std::pair<std::vector<int>, int> vec_int_pair;
512
513class bit_impl;
514class torrent_internal;
515
516class bit
517{
518public:         
519
520        enum mappings
521        {
522                mappingNone = 0,
523                mappingUPnP,
524                mappingNatPMP
525        };
526
527        enum allocations
528        {
529                sparse_allocation = 1,
530                compact_allocation,
531                full_allocation
532        };
533
534        enum queue_adjustments
535        {
536                move_up = 0,
537                move_down,
538                move_to_top,
539                move_to_bottom
540        };
541       
542        enum timeout_actions
543        {
544                action_pause = 0,
545                action_resume,
546                action_callback
547        };
548
549        class null_torrent : public std::exception
550        {
551        public:
552                null_torrent() {}               
553                virtual ~null_torrent() throw () {}
554        };
555
556        class torrent : public stlsoft::operator_bool_adaptor<torrent>
557        {
558                typedef torrent class_type;
559
560        public:
561                class exec_around_ptr
562                {
563                public:
564                        class proxy 
565                        {
566                        public:
567                                explicit proxy(torrent_internal* t);
568
569                                torrent_internal* operator->() 
570                                {
571                                        return t_;
572                                }
573
574                                ~proxy ();
575
576                        private:
577                                torrent_internal* t_;
578                                mutex_t::scoped_lock l_;
579                        };
580
581                        exec_around_ptr() {}
582                        exec_around_ptr(boost::shared_ptr<torrent_internal> p) : ptr(p) {}
583
584                        proxy operator->() const
585                        {
586                                if (!ptr)
587                                        throw null_torrent();
588
589                                return proxy(&(*ptr));
590                        }
591
592                        operator bool() const { return ptr; }
593
594                private:
595                        boost::shared_ptr<torrent_internal> ptr;
596                };
597
598                torrent();
599                torrent(boost::shared_ptr<torrent_internal> p);
600
601                const std::wstring get_name() const;
602
603                float get_ratio() const;
604                void set_ratio(float new_ratio);
605               
606                std::pair<int, int> get_connection_limits() const;
607                void set_connection_limits(const std::pair<int, int>&);
608                std::pair<float, float> get_rate_limits() const;
609                void set_rate_limits(const std::pair<float, float>&);
610
611                wpath get_save_directory() const;
612                void set_save_directory(const wpath&);
613                wpath get_move_to_directory() const;
614                void set_move_to_directory(const wpath&);
615
616                std::pair<wstring, wstring> get_tracker_login() const;
617                void set_tracker_login(const std::pair<wstring, wstring>&);
618
619                std::vector<tracker_detail> get_trackers() const;
620                void set_trackers(const std::vector<tracker_detail>&);
621
622                bool get_is_active() const;
623                bool get_in_session() const;
624
625                void set_file_priorities(const vec_int_pair&);
626
627                void set_managed(bool);
628                bool get_managed() const;
629
630        public:
631                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(const std::wstring, class_type, 
632                        get_name, name);
633
634                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type, 
635                        get_ratio, set_ratio, ratio);
636
637                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(int_pair, const int_pair&, class_type, 
638                        get_connection_limits, set_connection_limits, connection_limits);
639                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float_pair, const float_pair&, class_type, 
640                        get_rate_limits, set_rate_limits, rate_limits);
641               
642                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
643                        get_save_directory, set_save_directory, save_directory);
644                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
645                        get_move_to_directory, set_move_to_directory, move_to_directory);
646
647                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wstring_pair, const wstring_pair&, 
648                        class_type, get_tracker_login, set_tracker_login, tracker_login);
649
650                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
651                        get_is_active, is_active);
652                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
653                        get_in_session, in_session);
654
655                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(std::vector<tracker_detail>, const std::vector<tracker_detail>&, 
656                        class_type, get_trackers, set_trackers, trackers);
657
658                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(bool, bool, class_type, 
659                        get_managed, set_managed, managed);
660
661                STLSOFT_METHOD_PROPERTY_SET_EXTERNAL(const vec_int_pair&, class_type, 
662                        set_file_priorities, file_priorities);
663
664                void reset_trackers();
665                bool is_open() const;
666                void adjust_queue_position(bit::queue_adjustments adjust);
667
668        private:
669                exec_around_ptr ptr;
670        };
671
672        void shutdown_session();
673        void save_torrent_data();
674
675        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn);
676
677        template<typename T>
678        torrent get(T t)
679        {
680                return get_wstr(to_wstr_shim(t));
681        }
682       
683        template<>
684        torrent get(const hal::torrent_details_ptr t)
685        {
686                if (t) 
687                        return get_wstr(t->name());
688                else
689                        return torrent();
690        }       
691
692        torrent get_wstr(const std::wstring& filename);
693       
694        bool listen_on(std::pair<int, int> const& portRange);
695        int is_listening_on();
696        void stop_listening();
697       
698        bool ensure_dht_on(const dht_settings& dht);
699        void ensure_dht_off();
700       
701        void ensure_pe_on(const pe_settings& pe);
702        void ensure_pe_off();
703       
704        bool ensure_ip_filter_on(progress_callback fn);
705        void ensure_ip_filter_off();
706
707        void set_resolve_countries(bool);
708        void start_smart_ban_plugin();
709        void start_ut_pex_plugin();
710        void start_ut_metadata_plugin();
711        void start_metadata_plugin();
712
713        void set_mapping(bool upnp, bool nat_pmp);
714        std::wstring upnp_router_model();
715
716        void ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last);
717        void ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last);
718        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
719        size_t ip_filter_size();
720        void clear_ip_filter(); 
721       
722        void set_session_half_open_limit(int halfConn);
723        void set_session_limits(int maxConn, int maxUpload);
724        void set_session_speed(float download, float upload);
725
726        queue_settings get_queue_settings();
727        void set_queue_settings(const queue_settings& s);
728       
729        timeouts get_timeouts();
730        void set_timeouts(const timeouts& t);
731
732        const cache_details get_cache_details() const;
733
734        void set_cache_settings(const cache_settings& cache);
735        cache_settings get_cache_settings() const;
736       
737        const SessionDetail get_session_details();
738
739        void set_torrent_defaults(const connections& defaults); 
740        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
741                bool startPaused=false, bool managed=false, allocations alloc=hal::bit::sparse_allocation, 
742                boost::filesystem::wpath moveToDirectory=L"");
743       
744        void get_all_peer_details(const std::string& filename, peer_details_vec& peerContainer);
745        void get_all_peer_details(const std::wstring& filename, peer_details_vec& peerContainer);
746        void get_all_file_details(const std::string& filename, file_details_vec& file_details);
747        void get_all_file_details(const std::wstring& filename, file_details_vec& file_details);
748       
749        void resume_all();
750        void close_all(boost::optional<report_num_active> fn);
751       
752        bool is_torrent(const std::string& filename);
753        bool is_torrent(const std::wstring& filename); 
754       
755        void pause_torrent(const std::string& filename);
756        void pause_torrent(const std::wstring& filename);
757        void resume_torrent(const std::string& filename);
758        void resume_torrent(const std::wstring& filename);
759        void stop_torrent(const std::string& filename);
760        void stop_torrent(const std::wstring& filename);
761        bool is_torrent_active(const std::string& filename);
762        bool is_torrent_active(const std::wstring& filename);
763        void reannounce_torrent(const std::string& filename);
764        void reannounce_torrent(const std::wstring& filename);
765        void recheck_torrent(const std::string& filename);
766        void recheck_torrent(const std::wstring& filename);
767       
768        void pause_all_torrents();
769        void unpause_all_torrents();
770        bool is_any_torrent_active();
771
772        template<typename S>
773        void remove_torrent(S filename)
774        { 
775                remove_torrent_wstr(to_wstr_shim(filename)); 
776        }       
777
778        template<typename S>
779        void remove_torrent_wipe_files(S filename, remove_files fn)
780        { 
781                remove_torrent_wipe_files_wstr(to_wstr_shim(filename), fn); 
782        }       
783
784        void start_event_receiver();
785        void stop_event_receiver();
786
787        void schedual_action(boost::posix_time::ptime time, timeout_actions action);
788        void schedual_action(boost::posix_time::time_duration duration, timeout_actions action);
789
790        void schedual_callback(boost::posix_time::ptime time, action_callback_t);
791        void schedual_callback(boost::posix_time::time_duration duration, action_callback_t);
792       
793//      friend bit& bittorrent();
794       
795        int default_torrent_max_connections();
796        int default_torrent_max_uploads();
797        float default_torrent_download();
798        float default_torrent_upload(); 
799
800        const torrent_details_manager& torrentDetails();
801        const torrent_details_manager& updatetorrent_details_manager(const std::wstring& focused, const std::set<std::wstring>& selected);
802       
803        bit();
804        ~bit();
805
806private:
807        bit_impl* pimpl();
808        const bit_impl* pimpl() const;
809        boost::scoped_ptr<bit_impl> pimpl_;
810       
811        void remove_torrent_wstr(const std::wstring& filename);
812        void remove_torrent_wipe_files_wstr(const std::wstring&  filename, remove_files fn);
813       
814        torrent_details_manager torrentDetails_;
815};
816
817typedef Loki::SingletonHolder<bit, Loki::CreateUsingNew, Loki::PhoenixSingleton> bittorrent;
818
819};
Note: See TracBrowser for help on using the repository browser.