Changeset 741


Ignore:
Timestamp:
04/04/09 12:51:38 (11 years ago)
Author:
Eoin
Message:

Torrent manager given it's own header with cleanup refactoring.

Location:
trunk
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/sln/Halite/Halite.vcproj

    r732 r741  
    16301630                        </File> 
    16311631                        <File 
     1632                                RelativePath="..\..\src\halTorrentManager.hpp" 
     1633                                > 
     1634                        </File> 
     1635                        <File 
    16321636                                RelativePath="..\..\src\halTypes.hpp" 
    16331637                                > 
  • trunk/src/halPeers.cpp

    r723 r741  
    1818 
    1919#include "halTorrentInternal.hpp" 
     20#include "halTorrentManager.hpp" 
    2021#include "halSession.hpp" 
    2122 
  • trunk/src/halSession.cpp

    r740 r741  
    763763                 
    764764                } 
    765                 catch(libt::unhandled_alert&) 
     765                catch(const libt::unhandled_alert&) 
    766766                { 
    767767//                      handler(*p_alert); 
    768768                } 
    769                 catch(bit::null_torrent& e) 
     769                catch(const bit::null_torrent&) 
    770770                { 
    771771                        // These are logged as debug because they are rarely important to act on! 
     
    773773                                new EventMsg(L"null_torrent exception", event_logger::info))); 
    774774                } 
    775                 catch(std::exception& e) 
     775                catch(const std::exception& e) 
    776776                { 
    777777                        // These are logged as debug because they are rarely important to act on! 
  • trunk/src/halSession.hpp

    r739 r741  
    4141#include "halConfig.hpp" 
    4242#include "halTorrentInternal.hpp" 
     43#include "halTorrentManager.hpp" 
    4344#include "halSignaler.hpp" 
    4445 
     
    951952        } 
    952953 
    953         void remove_torrent(const wstring& filename) 
     954        void remove_torrent(const wstring& name) 
    954955        { 
    955956                try { 
     
    957958 
    958959                boost::shared_ptr<file_details_vec> files = boost::shared_ptr<file_details_vec>(new file_details_vec());                 
    959                 torrent_internal_ptr pTI = the_torrents_.get(filename); 
     960                torrent_internal_ptr pTI = the_torrents_.get(name); 
    960961 
    961962        //      pTI->get_file_details(*files);           
     
    963964 
    964965                libt::torrent_handle handle = pTI->handle(); 
    965                 the_torrents_.erase(filename); 
     966                the_torrents_.remove_torrent(name); 
    966967                 
    967968                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Removed, started thread."))); 
    968969                 
    969                 } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "remove_torrent") 
    970         } 
    971  
    972         void remove_torrent_wipe_files(const std::wstring& filename, remove_files fn) 
     970                } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(name, "remove_torrent") 
     971        } 
     972 
     973        void remove_torrent_wipe_files(const std::wstring& name, remove_files fn) 
    973974        { 
    974975                try { 
     
    976977 
    977978                boost::shared_ptr<file_details_vec> files = boost::shared_ptr<file_details_vec>(new file_details_vec());                 
    978                 torrent_internal_ptr pTI = the_torrents_.get(filename); 
     979                torrent_internal_ptr pTI = the_torrents_.get(name); 
    979980 
    980981                pTI->get_file_details(*files); 
     
    984985                pTI->delete_torrent_file(); 
    985986 
    986                 the_torrents_.erase(filename); 
     987                the_torrents_.remove_torrent(name); 
    987988                 
    988989                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Removed, started thread."))); 
    989990                 
    990                 } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "remove_torrent_wipe_files") 
     991                } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(name, "remove_torrent_wipe_files") 
    991992        } 
    992993 
  • trunk/src/halTorrent.cpp

    r739 r741  
    1818 
    1919#include "halTorrentInternal.hpp" 
     20#include "halTorrentManager.hpp" 
    2021#include "halSession.hpp" 
    2122#include "halConfig.hpp" 
  • trunk/src/halTorrentInternal.hpp

    r740 r741  
    3434#pragma warning (pop)  
    3535 
    36 #include <boost/tuple/tuple.hpp> 
    37 #include <boost/enable_shared_from_this.hpp> 
    38 #include <boost/multi_index_container.hpp> 
    39 #include <boost/multi_index/ordered_index.hpp> 
    40 #include <boost/multi_index/indexed_by.hpp> 
    41 #include <boost/multi_index/identity.hpp> 
    42 #include <boost/multi_index/member.hpp> 
    43 #include <boost/multi_index/tag.hpp> 
    44  
    4536#include <boost/statechart/event.hpp> 
    4637#include <boost/statechart/state_machine.hpp> 
     
    310301        friend struct resume_data_idling; 
    311302 
    312 public: 
     303private: 
    313304        #define TORRENT_INTERNALS_DEFAULTS \ 
    314305                original_filename_(L""), \ 
     
    333324        } 
    334325 
    335 private: 
    336326        torrent_internal(wpath filename, wpath saveDirectory, bit::allocations alloc, wpath move_to_directory=L"") : 
    337327                TORRENT_INTERNALS_DEFAULTS, 
     
    933923}; 
    934924 
    935  
    936 class torrent_manager :  
    937         public hal::IniBase<torrent_manager> 
    938 { 
    939         typedef torrent_manager thisClass; 
    940         typedef hal::IniBase<thisClass> iniClass; 
    941  
    942         struct torrent_holder 
    943         { 
    944                 mutable torrent_internal_ptr torrent; 
    945                  
    946                 wstring filename; 
    947                 wstring name;            
    948                  
    949                 torrent_holder() 
    950                 {} 
    951                  
    952                 explicit torrent_holder(torrent_internal_ptr t) : 
    953                         torrent(t), filename(torrent->filename()), name(torrent->name()) 
    954                 {}                               
    955  
    956                 friend class boost::serialization::access; 
    957                 template<class Archive> 
    958                 void load(Archive& ar, const unsigned int version) 
    959                 { 
    960                         using boost::serialization::make_nvp; 
    961  
    962                         ar & make_nvp("torrent", torrent); 
    963                         ar & make_nvp("filename", filename); 
    964                         ar & make_nvp("name", name); 
    965  
    966                         torrent->initialize_state_machine(torrent); 
    967                 } 
    968  
    969                 template<class Archive> 
    970                 void save(Archive& ar, const unsigned int version) const 
    971                 { 
    972                         using boost::serialization::make_nvp; 
    973  
    974                         ar & make_nvp("torrent", torrent); 
    975                         ar & make_nvp("filename", filename); 
    976                         ar & make_nvp("name", name); 
    977                 } 
    978  
    979                 BOOST_SERIALIZATION_SPLIT_MEMBER() 
    980         }; 
    981          
    982         struct by_filename{}; 
    983         struct by_name{}; 
    984          
    985         typedef boost::multi_index_container< 
    986                 torrent_holder, 
    987                 boost::multi_index::indexed_by< 
    988                         boost::multi_index::ordered_unique< 
    989                                 boost::multi_index::tag<by_filename>, 
    990                                 boost::multi_index::member< 
    991                                         torrent_holder, wstring, &torrent_holder::filename>  
    992                                 >, 
    993                         boost::multi_index::ordered_unique< 
    994                                 boost::multi_index::tag<by_name>, 
    995                                 boost::multi_index::member< 
    996                                         torrent_holder, wstring, &torrent_holder::name>  
    997                                 > 
    998                 > 
    999         > torrent_multi_index; 
    1000          
    1001 public: 
    1002         typedef torrent_multi_index::index<by_filename>::type torrent_by_filename; 
    1003         typedef torrent_multi_index::index<by_name>::type torrent_by_name; 
    1004          
    1005         torrent_manager(ini_file& ini) : 
    1006                 iniClass("bittorrent", "torrent_manager", ini) 
    1007         {} 
    1008  
    1009         ~torrent_manager() 
    1010         { 
    1011                 for (torrent_by_name::iterator i= torrents_.get<by_name>().begin(),  
    1012                         e = torrents_.get<by_name>().end(); i!=e; ++i) 
    1013                 { 
    1014                         (*i).torrent->stop(); 
    1015                 } 
    1016         } 
    1017          
    1018 /*      std::pair<torrent_by_name::iterator, bool> insert(torrent_internal_ptr t) 
    1019         { 
    1020                 return insert(torrent_holder(t)); 
    1021         } 
    1022 */ 
    1023  
    1024         torrent_internal_ptr create_torrent(wpath filename, wpath saveDirectory, bit::allocations alloc, wpath move_to_directory=L"") 
    1025         { 
    1026                 torrent_internal_ptr t = torrent_internal_ptr(new torrent_internal(filename, saveDirectory, alloc, move_to_directory)); 
    1027  
    1028                 std::pair<torrent_by_name::iterator, bool> p = torrents_.get<by_name>().insert(torrent_holder(t)); 
    1029  
    1030                 if (!p.second)  
    1031                         t.reset(); 
    1032                 else 
    1033                         t->initialize_state_machine(t); 
    1034  
    1035                 return t;                        
    1036         } 
    1037  
    1038         torrent_internal_ptr get_by_file(const wstring& filename) 
    1039         { 
    1040                 torrent_by_filename::iterator it = torrents_.get<by_filename>().find(filename); 
    1041                  
    1042                 if (it != torrents_.get<by_filename>().end() && (*it).torrent) 
    1043                 { 
    1044                         return (*it).torrent; 
    1045                 } 
    1046                  
    1047                 throw invalid_torrent(filename); 
    1048         } 
    1049          
    1050         torrent_internal_ptr get(const wstring& name) 
    1051         { 
    1052                 torrent_by_name::iterator it = torrents_.get<by_name>().find(name); 
    1053                  
    1054                 if (it != torrents_.get<by_name>().end() && (*it).torrent) 
    1055                 { 
    1056                         return (*it).torrent; 
    1057                 } 
    1058                  
    1059                 throw invalid_torrent(name); 
    1060         } 
    1061          
    1062         torrent_by_name::iterator erase(torrent_by_name::iterator where) 
    1063         { 
    1064                 return torrents_.get<by_name>().erase(where); 
    1065         } 
    1066          
    1067         size_t size() 
    1068         { 
    1069                 return torrents_.size(); 
    1070         } 
    1071          
    1072         size_t erase(const wstring& name) 
    1073         { 
    1074                 torrent_by_name::iterator it = torrents_.get<by_name>().find(name); 
    1075                  
    1076                 TORRENT_STATE_LOG(L"Torrent manager erasing"); 
    1077  
    1078         /*      if (it != torrents_.get<by_name>().end()) 
    1079                 { 
    1080                         TORRENT_STATE_LOG(L"Torrent manager requesting stop"); 
    1081                         (*it).torrent->stop(); 
    1082                 } 
    1083         */ 
    1084                 return torrents_.get<by_name>().erase(name); 
    1085         } 
    1086          
    1087         bool exists(const wstring& name) 
    1088         { 
    1089                 torrent_by_name::iterator it = torrents_.get<by_name>().find(name); 
    1090                  
    1091                 if (it != torrents_.get<by_name>().end()) 
    1092                         return true; 
    1093                 else 
    1094                         return false; 
    1095         } 
    1096          
    1097         torrent_by_name::iterator begin() { return torrents_.get<by_name>().begin(); } 
    1098         torrent_by_name::iterator end() { return torrents_.get<by_name>().end(); } 
    1099          
    1100         friend class boost::serialization::access; 
    1101         template<class Archive> 
    1102         void serialize(Archive& ar, const unsigned int version) 
    1103         { 
    1104                 ar & boost::serialization::make_nvp("torrents", torrents_); 
    1105         }        
    1106          
    1107 private: 
    1108         torrent_multi_index torrents_; 
    1109 }; 
    1110  
    1111925} // namespace hal 
    1112926 
    1113927#include "halTorrentIntStates.hpp" 
    1114928 
    1115 BOOST_CLASS_VERSION(hal::torrent_manager::torrent_holder, 1) 
Note: See TracChangeset for help on using the changeset viewer.