Changeset 409


Ignore:
Timestamp:
03/23/08 15:38:09 (12 years ago)
Author:
Eoin
Message:

Added support for individual xml saves pre torrent but havn't set when to be saved yet.

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/7z Halite Source.bat

    r386 r409  
    1 "D:\Program Files\7-Zip\7zG.exe" a -r -t7z Halite.src.7z -mx=7 ../trunk/* -x!test -x!bin -x!.svn -x!tools -x!*.7z -x!*.suo -x!*.ncb -x!*x64 -x!debug -x!Debug -x!release -x!Release 
     1"C:\Program Files\7-Zip\7zG.exe" a -r -t7z Halite.src.7z -mx=7 ../trunk/* -x!test -x!bin -x!.svn -x!tools -x!*.7z -x!*.suo -x!*.ncb -x!*x64 -x!debug -x!Debug -x!release -x!"release logging" -x!Release 
  • trunk/sln/Halite/Halite.vcproj

    r408 r409  
    675675                                        RelativePath="..\..\src\global\tinyxml.cpp" 
    676676                                        > 
     677                                        <FileConfiguration 
     678                                                Name="Debug|Win32" 
     679                                                > 
     680                                                <Tool 
     681                                                        Name="VCCLCompilerTool" 
     682                                                        UsePrecompiledHeader="0" 
     683                                                /> 
     684                                        </FileConfiguration> 
     685                                        <FileConfiguration 
     686                                                Name="Debug|x64" 
     687                                                > 
     688                                                <Tool 
     689                                                        Name="VCCLCompilerTool" 
     690                                                        UsePrecompiledHeader="0" 
     691                                                /> 
     692                                        </FileConfiguration> 
     693                                        <FileConfiguration 
     694                                                Name="Release|Win32" 
     695                                                > 
     696                                                <Tool 
     697                                                        Name="VCCLCompilerTool" 
     698                                                        UsePrecompiledHeader="0" 
     699                                                /> 
     700                                        </FileConfiguration> 
     701                                        <FileConfiguration 
     702                                                Name="Release|x64" 
     703                                                > 
     704                                                <Tool 
     705                                                        Name="VCCLCompilerTool" 
     706                                                        UsePrecompiledHeader="0" 
     707                                                /> 
     708                                        </FileConfiguration> 
     709                                        <FileConfiguration 
     710                                                Name="Release Logging|Win32" 
     711                                                > 
     712                                                <Tool 
     713                                                        Name="VCCLCompilerTool" 
     714                                                        UsePrecompiledHeader="0" 
     715                                                /> 
     716                                        </FileConfiguration> 
     717                                        <FileConfiguration 
     718                                                Name="Release Logging|x64" 
     719                                                > 
     720                                                <Tool 
     721                                                        Name="VCCLCompilerTool" 
     722                                                        UsePrecompiledHeader="0" 
     723                                                /> 
     724                                        </FileConfiguration> 
    677725                                </File> 
    678726                                <File 
    679727                                        RelativePath="..\..\src\global\tinyxmlerror.cpp" 
    680728                                        > 
     729                                        <FileConfiguration 
     730                                                Name="Debug|Win32" 
     731                                                > 
     732                                                <Tool 
     733                                                        Name="VCCLCompilerTool" 
     734                                                        UsePrecompiledHeader="0" 
     735                                                /> 
     736                                        </FileConfiguration> 
     737                                        <FileConfiguration 
     738                                                Name="Debug|x64" 
     739                                                > 
     740                                                <Tool 
     741                                                        Name="VCCLCompilerTool" 
     742                                                        UsePrecompiledHeader="0" 
     743                                                /> 
     744                                        </FileConfiguration> 
     745                                        <FileConfiguration 
     746                                                Name="Release|Win32" 
     747                                                > 
     748                                                <Tool 
     749                                                        Name="VCCLCompilerTool" 
     750                                                        UsePrecompiledHeader="0" 
     751                                                /> 
     752                                        </FileConfiguration> 
     753                                        <FileConfiguration 
     754                                                Name="Release|x64" 
     755                                                > 
     756                                                <Tool 
     757                                                        Name="VCCLCompilerTool" 
     758                                                        UsePrecompiledHeader="0" 
     759                                                /> 
     760                                        </FileConfiguration> 
     761                                        <FileConfiguration 
     762                                                Name="Release Logging|Win32" 
     763                                                > 
     764                                                <Tool 
     765                                                        Name="VCCLCompilerTool" 
     766                                                        UsePrecompiledHeader="0" 
     767                                                /> 
     768                                        </FileConfiguration> 
     769                                        <FileConfiguration 
     770                                                Name="Release Logging|x64" 
     771                                                > 
     772                                                <Tool 
     773                                                        Name="VCCLCompilerTool" 
     774                                                        UsePrecompiledHeader="0" 
     775                                                /> 
     776                                        </FileConfiguration> 
    681777                                </File> 
    682778                                <File 
    683779                                        RelativePath="..\..\src\global\tinyxmlparser.cpp" 
    684780                                        > 
     781                                        <FileConfiguration 
     782                                                Name="Debug|Win32" 
     783                                                > 
     784                                                <Tool 
     785                                                        Name="VCCLCompilerTool" 
     786                                                        UsePrecompiledHeader="0" 
     787                                                /> 
     788                                        </FileConfiguration> 
     789                                        <FileConfiguration 
     790                                                Name="Debug|x64" 
     791                                                > 
     792                                                <Tool 
     793                                                        Name="VCCLCompilerTool" 
     794                                                        UsePrecompiledHeader="0" 
     795                                                /> 
     796                                        </FileConfiguration> 
     797                                        <FileConfiguration 
     798                                                Name="Release|Win32" 
     799                                                > 
     800                                                <Tool 
     801                                                        Name="VCCLCompilerTool" 
     802                                                        UsePrecompiledHeader="0" 
     803                                                /> 
     804                                        </FileConfiguration> 
     805                                        <FileConfiguration 
     806                                                Name="Release|x64" 
     807                                                > 
     808                                                <Tool 
     809                                                        Name="VCCLCompilerTool" 
     810                                                        UsePrecompiledHeader="0" 
     811                                                /> 
     812                                        </FileConfiguration> 
     813                                        <FileConfiguration 
     814                                                Name="Release Logging|Win32" 
     815                                                > 
     816                                                <Tool 
     817                                                        Name="VCCLCompilerTool" 
     818                                                        UsePrecompiledHeader="0" 
     819                                                /> 
     820                                        </FileConfiguration> 
     821                                        <FileConfiguration 
     822                                                Name="Release Logging|x64" 
     823                                                > 
     824                                                <Tool 
     825                                                        Name="VCCLCompilerTool" 
     826                                                        UsePrecompiledHeader="0" 
     827                                                /> 
     828                                        </FileConfiguration> 
    685829                                </File> 
    686830                                <File 
  • trunk/src/global/ini.cpp

    r392 r409  
    8686        bool save(boost::filesystem::path location, std::string data) 
    8787        { 
    88                 tinyxml::node* data_node = get_data_node(location); 
     88                xml::node* data_node = get_data_node(location); 
    8989                 
    9090                // Should have correct node              
     
    9393        } 
    9494 
    95         bool save(boost::filesystem::path location, tinyxml::node* data) 
     95        bool save(boost::filesystem::path location, xml::node* data) 
    9696        { 
    97                 tinyxml::node* data_node = get_data_node(location); 
     97                xml::node* data_node = get_data_node(location); 
    9898                 
    9999                data_node->clear(); 
     
    103103        } 
    104104         
    105         tinyxml::node* load(boost::filesystem::path location) 
     105        xml::node* load(boost::filesystem::path location) 
    106106        { 
    107                 tinyxml::node* data_node = get_data_node(location); 
     107                xml::node* data_node = get_data_node(location); 
    108108                 
    109                 tinyxml::node* data = data_node->first_child(); 
     109                xml::node* data = data_node->first_child(); 
    110110                 
    111111                if (data) 
     
    118118        void generate_default_file() 
    119119        { 
    120                 xml_.link_end_child(new tinyxml::declaration("1.0", "", "")); 
     120                xml_.link_end_child(new xml::declaration("1.0", "", "")); 
    121121                 
    122                 xml_.link_end_child(new tinyxml::element("ini")); 
     122                xml_.link_end_child(new xml::element("ini")); 
    123123        } 
    124124         
    125         tinyxml::node* get_data_node(boost::filesystem::path location) 
     125        xml::node* get_data_node(boost::filesystem::path location) 
    126126        { 
    127                 tinyxml::node* data_node = xml_.first_child("ini"); 
     127                xml::node* data_node = xml_.first_child("ini"); 
    128128                 
    129129                if (!data_node) 
    130130                { 
    131                         data_node = new tinyxml::element("ini"); 
     131                        data_node = new xml::element("ini"); 
    132132                        xml_.link_end_child(data_node); 
    133133                } 
     
    135135                foreach(std::string elem, location) 
    136136                { 
    137                         tinyxml::node* child_node = data_node->first_child(elem); 
     137                        xml::node* child_node = data_node->first_child(elem); 
    138138                         
    139139                        if (!child_node) 
    140140                        { 
    141                                 child_node = new tinyxml::element(elem); 
     141                                child_node = new xml::element(elem); 
    142142                                data_node->link_end_child(child_node); 
    143143                        } 
     
    151151        boost::filesystem::wpath main_file_; 
    152152        boost::filesystem::wpath working_file_; 
    153         tinyxml::document xml_; 
     153        xml::document xml_; 
    154154}; 
    155155 
     
    176176} 
    177177 
    178 bool ini_file::save(boost::filesystem::path location, tinyxml::node* data) 
     178bool ini_file::save(boost::filesystem::path location, xml::node* data) 
    179179{ 
    180180        return pimpl->save(location, data); 
    181181} 
    182182 
    183 tinyxml::node* ini_file::load(boost::filesystem::path location) 
     183xml::node* ini_file::load(boost::filesystem::path location) 
    184184{ 
    185185        return pimpl->load(location); 
  • trunk/src/global/ini.hpp

    r376 r409  
    1111#include <boost/filesystem/path.hpp> 
    1212 
    13 namespace tinyxml 
     13namespace xml 
    1414{ 
    1515class node; 
     
    3131         
    3232        bool save(boost::filesystem::path location, std::string data); 
    33         bool save(boost::filesystem::path location, tinyxml::node* data); 
     33        bool save(boost::filesystem::path location, xml::node* data); 
    3434         
    35         tinyxml::node* load(boost::filesystem::path location); 
     35        xml::node* load(boost::filesystem::path location); 
    3636         
    3737        friend ini_file& ini(); 
  • trunk/src/global/ini_adapter.cpp

    r392 r409  
    1919void ini_adapter::load_stream_data(std::ostream& data) 
    2020{ 
    21         tinyxml::node* data_node = ini_.load(location_); 
     21        xml::node* data_node = ini_.load(location_); 
    2222         
    2323        if (data_node) 
    2424        { 
    25         tinyxml::document doc; 
     25        xml::document doc; 
    2626        doc.parse("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><!DOCTYPE boost_serialization>"); 
    2727         
     
    3434void ini_adapter::save_stream_data(std::istream& data) 
    3535{        
    36         tinyxml::document doc;   
     36        xml::document doc;       
    3737        data >> doc; 
    3838         
    39         tinyxml::node* data_node = doc.root_element(); 
     39        xml::node* data_node = doc.root_element(); 
    4040         
    4141        ini_.save(location_, data_node->clone()); 
     
    4444void ini_adapter::load_stream_data(std::wostream& data) 
    4545{ 
    46         tinyxml::node* data_node = ini_.load(location_); 
     46        xml::node* data_node = ini_.load(location_); 
    4747         
    4848        if (data_node) 
    4949        { 
    50                 tinyxml::document doc; 
     50                xml::document doc; 
    5151                doc.parse("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\ 
    5252                        <!DOCTYPE boost_serialization>"); 
     
    7474        ); 
    7575         
    76         tinyxml::document doc;   
     76        xml::document doc;       
    7777        sstr >> doc; 
    7878         
    79         tinyxml::node* data_node = doc.root_element(); 
     79        xml::node* data_node = doc.root_element(); 
    8080         
    8181        ini_.save(location_, data_node->clone()); 
  • trunk/src/global/tinyxml.cpp

    r392 r409  
    2323*/ 
    2424 
    25 #include "stdAfx.hpp" 
    26  
    2725#include <ctype.h> 
    2826 
     
    3432#include "tinyxml.hpp" 
    3533 
    36 namespace tinyxml 
     34namespace xml 
    3735{ 
    3836 
  • trunk/src/global/tinyxml.hpp

    r329 r409  
    6060#endif 
    6161 
    62 namespace tinyxml 
     62namespace xml 
    6363{ 
    6464 
  • trunk/src/global/tinyxmlerror.cpp

    r392 r409  
    2323*/ 
    2424 
    25 #include "stdAfx.hpp" 
    26  
    2725#include "tinyxml.hpp" 
    2826 
    29 namespace tinyxml 
     27namespace xml 
    3028{ 
    3129 
  • trunk/src/global/tinyxmlparser.cpp

    r392 r409  
    2323*/ 
    2424 
    25 #include "stdAfx.hpp" 
    26  
    2725#include <ctype.h> 
    2826#include <stddef.h> 
     
    3028#include "tinyxml.hpp" 
    3129 
    32 namespace tinyxml 
     30namespace xml 
    3331{ 
    3432 
  • trunk/src/halIni.hpp

    r370 r409  
    2525        {} 
    2626         
     27        IniBase(std::string name, hal::ini_file& ini = hal::ini()) : 
     28                adapter_(boost::filesystem::path(""), ini), 
     29                name_(name) 
     30        {} 
     31         
    2732        void Save() 
    2833        { 
     
    3742         
    3843        void save() { Save(); } 
     44 
     45        template<typename P> 
     46        void save_standalone(const P& location) 
     47        { 
     48                fs::wofstream ofs(location); 
     49                 
     50                boost::archive::xml_woarchive oxml(ofs); 
     51                T* pT = static_cast<T*>(this);   
     52                oxml << boost::serialization::make_nvp(name_.c_str(), *pT); 
     53        } 
     54         
     55        template<typename P> 
     56        void load_standalone(const P& location) 
     57        { 
     58                try  
     59                {                
     60                fs::wifstream ifs(location); 
     61 
     62                boost::archive::xml_wiarchive ixml(ifs); 
     63 
     64                T* pT = static_cast<T*>(this);   
     65                ixml >> boost::serialization::make_nvp(name_.c_str(), *pT); 
     66                 
     67                } 
     68                catch (const std::exception& e) 
     69                {                        
     70                        hal::event().post(boost::shared_ptr<hal::EventDetail>( 
     71                                new hal::EventXmlException(hal::from_utf8(e.what()), L"load_standalone")));  
     72                } 
     73        } 
    3974         
    4075        void Load() 
  • trunk/src/halTorrent.cpp

    r407 r409  
    12671267        try  
    12681268        {        
    1269          
    12701269        TorrentInternal_ptr TIp; 
    1271          
    1272         if (useMoveTo) 
    1273                 TIp.reset(new TorrentInternal(file, saveDirectory, compactStorage, moveToDirectory));            
     1270 
     1271        std::pair<std::string, std::string> names = extract_names(file); 
     1272        wstring_t xml_name = from_utf8(names.first) + L".xml"; 
     1273 
     1274        if (fs::exists(file.branch_path()/xml_name)) 
     1275        { 
     1276                torrent_standalone tsa; 
     1277                tsa.load_standalone(file.branch_path()/xml_name); 
     1278 
     1279                TIp = tsa.torrent; 
     1280                TIp->prepare(file); 
     1281        } 
    12741282        else 
    1275                 TIp.reset(new TorrentInternal(file, saveDirectory, compactStorage)); 
     1283        { 
     1284                if (useMoveTo) 
     1285                        TIp.reset(new TorrentInternal(file, saveDirectory, compactStorage, moveToDirectory));            
     1286                else 
     1287                        TIp.reset(new TorrentInternal(file, saveDirectory, compactStorage)); 
     1288 
     1289                TIp->setTransferSpeed(bittorrent().defTorrentDownload(), bittorrent().defTorrentUpload()); 
     1290                TIp->setConnectionLimit(bittorrent().defTorrentMaxConn(), bittorrent().defTorrentMaxUpload()); 
     1291        } 
    12761292         
    12771293        std::pair<TorrentManager::torrentByName::iterator, bool> p = 
     
    12801296        if (p.second) 
    12811297        { 
    1282                 TorrentInternal_ptr me = pimpl->theTorrents.get(TIp->name()); 
    1283                  
    1284                 me->setTransferSpeed(bittorrent().defTorrentDownload(), bittorrent().defTorrentUpload()); 
    1285                 me->setConnectionLimit(bittorrent().defTorrentMaxConn(), bittorrent().defTorrentMaxUpload()); 
    1286                  
    1287                 if (!startStopped) me->addToSession(); 
     1298                TorrentInternal_ptr me = pimpl->theTorrents.get(TIp->name());            
     1299                 
     1300                if (!startStopped)  
     1301                        me->addToSession(); 
     1302                else 
     1303                        me->set_state_stopped(); 
    12881304        } 
    12891305         
     
    14061422                        { 
    14071423                                 
    1408                         (*i).torrent->prepare(file, (*i).torrent->saveDirectory());      
     1424                        (*i).torrent->prepare(file);     
    14091425 
    14101426                        switch ((*i).torrent->state()) 
  • trunk/src/halTorrentInternal.hpp

    r408 r409  
    6666 
    6767#include <boost/tuple/tuple.hpp> 
     68#include <boost/enable_shared_from_this.hpp> 
    6869#include <boost/multi_index_container.hpp> 
    6970#include <boost/multi_index/ordered_index.hpp> 
     
    126127        lbt::bencode(std::ostream_iterator<char>(ofs), e); 
    127128        return true; 
     129} 
     130 
     131std::pair<std::string, std::string> extract_names(const wpath_t &file) 
     132{ 
     133        if (fs::exists(file))  
     134        {        
     135                lbt::torrent_info info(haldecode(file)); 
     136 
     137                std::string name = info.name();  
     138                std::string filename = name; 
     139 
     140                if (!boost::find_last(filename, ".torrent"))  
     141                                filename += ".torrent"; 
     142                 
     143                event().post(shared_ptr<EventDetail>(new EventMsg( 
     144                        wformat_t(L"Loaded names: %1%, %2%") % from_utf8(name) % from_utf8(filename)))); 
     145 
     146                return std::make_pair(name, filename); 
     147        } 
     148        else 
     149                return std::make_pair("", ""); 
    128150} 
    129151 
     
    408430}; 
    409431 
    410 class TorrentInternal :  
    411         boost::noncopyable 
     432 
     433class TorrentInternal; 
     434typedef shared_ptr<TorrentInternal> TorrentInternal_ptr; 
     435 
     436struct torrent_standalone : 
     437        public hal::IniBase<torrent_standalone> 
     438{ 
     439        typedef torrent_standalone thisClass; 
     440        typedef hal::IniBase<thisClass> iniClass; 
     441 
     442        torrent_standalone() : 
     443                iniClass("torrent") 
     444        {} 
     445 
     446        torrent_standalone(TorrentInternal_ptr t) : 
     447                iniClass("torrent"), 
     448                torrent(t), 
     449                save_time(pt::second_clock::universal_time()) 
     450        {} 
     451 
     452        TorrentInternal_ptr torrent; 
     453        pt::ptime save_time; 
     454 
     455    friend class boost::serialization::access; 
     456    template<class Archive> 
     457    void serialize(Archive& ar, const unsigned int version) 
     458    { 
     459        ar & make_nvp("torrent", torrent); 
     460        ar & make_nvp("save_time", save_time); 
     461    } 
     462}; 
     463 
     464class TorrentInternal : 
     465        public boost::enable_shared_from_this<TorrentInternal>, 
     466        private boost::noncopyable 
    412467{ 
    413468        friend class BitTorrent_impl;    
     
    423478                totalBase_(0), \ 
    424479                progress_(0), \ 
    425                 startTime_(boost::posix_time::second_clock::universal_time()) 
     480                startTime_(boost::posix_time::second_clock::universal_time()), \ 
     481                in_session_(false) 
    426482                 
    427483        TorrentInternal() :      
    428484                TORRENT_INTERNALS_DEFAULTS, 
    429485                compactStorage_(true), 
    430                 state_(TorrentDetail::torrent_stopped),  
    431                 in_session_(false) 
     486                state_(TorrentDetail::torrent_stopped) 
    432487        {} 
    433488         
     
    437492                move_to_directory_(move_to_directory.string()), 
    438493                compactStorage_(compactStorage),         
    439                 state_(TorrentDetail::torrent_stopped),  
    440                 in_session_(false) 
    441         { 
    442                 assert(the_session_); 
    443                  
    444                 prepare(filename, save_directory_); 
     494                state_(TorrentDetail::torrent_stopped) 
     495        { 
     496                assert(the_session_);            
     497                prepare(filename); 
    445498        } 
    446499         
     
    450503                connections_(t.connections_), 
    451504                uploads_(t.uploads_), 
    452                 in_session_(false), 
    453505                ratio_(t.ratio_), 
    454506                resolve_countries_(t.resolve_countries_), 
     
    657709        } 
    658710 
     711        void set_state_stopped() 
     712        { 
     713                state_ = TorrentDetail::torrent_stopped; 
     714        } 
     715 
    659716        void forceRecheck() 
    660717        { 
     
    694751                assert(halencode_result); 
    695752                HAL_DEV_MSG(L"Written!"); 
     753 
     754                torrent_standalone tsa(shared_from_this()); 
     755                tsa.save_standalone(resumeDir/(name_+L".xml")); 
    696756        } 
    697757         
     
    921981        } 
    922982         
    923         void prepare(wpath_t filename, wpath_t saveDirectory) 
     983        void prepare(wpath_t filename) 
    924984        { 
    925985                mutex_t::scoped_lock l(mutex_); 
     
    9451005                        copy_file(filename.string(), torrentFile); 
    9461006 
    947                 if (!exists(saveDirectory)) 
    948                         create_directory(saveDirectory); 
     1007                if (!fs::exists(save_directory_)) 
     1008                        fs::create_directory(save_directory_); 
    9491009 
    9501010                if (state_ == TorrentDetail::torrent_stopping) 
     
    11921252typedef std::map<std::string, TorrentInternalOld> TorrentMap; 
    11931253typedef std::pair<std::string, TorrentInternalOld> TorrentPair; 
    1194 typedef shared_ptr<TorrentInternal> TorrentInternal_ptr; 
    11951254 
    11961255class TorrentManager :  
Note: See TracChangeset for help on using the changeset viewer.