Changeset 429


Ignore:
Timestamp:
04/28/08 18:51:31 (12 years ago)
Author:
Eoin
Message:

Files and trackers correctly passed to create_torrent.

Location:
trunk
Files:
1 added
15 edited

Legend:

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

    r427 r429  
    998998                        </File> 
    999999                        <File 
     1000                                RelativePath="..\..\src\halTypes.hpp" 
     1001                                > 
     1002                        </File> 
     1003                        <File 
    10001004                                RelativePath="..\..\src\NewTorrentDialog.hpp" 
    10011005                                > 
  • trunk/src/AddTorrentDialog.hpp

    r403 r429  
    9292                CtrlsArrange(); 
    9393                 
     94                BOOL retval =  DoDataExchange(false); 
     95 
    9496                OnMoveTo(0, 0, GetDlgItem(IDC_ADDT_MOVETO_CHECK)); 
    95                  
    96                 BOOL retval =  DoDataExchange(false); 
    9797                return retval; 
    9898        } 
  • trunk/src/Halite.hpp

    r392 r429  
    66 
    77#pragma once 
    8  
    98 
    109using std::string; 
     
    4342         
    4443        using boost::tuple; 
     44 
     45        typedef boost::int64_t size_type; 
    4546} 
    4647 
  • trunk/src/HaliteListView.cpp

    r423 r429  
    196196                i != e; ++i) 
    197197        {        
    198                 HAL_DEV_MSG(wformat(L"Unique Save dir: %1%.") % *i); 
    199  
    200                 sei.lpDirectory = (*i).string().c_str(); 
    201                 sei.lpFile = (*i).string().c_str(); 
     198                wstring p = (*i).file_string(); 
     199 
     200                HAL_DEV_MSG(wformat(L"Unique Save dir: %1%.") % p); 
     201 
     202                sei.lpDirectory = p.c_str(); 
     203                sei.lpFile = p.c_str(); 
    202204                sei.lpVerb = L"open"; 
    203205                sei.nShow = true; 
  • trunk/src/NewTorrentDialog.cpp

    r427 r429  
    5151        { 
    5252                SetDlgItemText(IDC_NEWT_FILE, dlgOpen.m_ofn.lpstrFile); 
     53                EnableSave_(true); 
    5354        } 
    5455} 
     
    6566    else 
    6667    { 
    67                 HAL_DEV_MSG(currentDir.string()); 
     68//              HAL_DEV_MSG(currentDir.string()); 
    6869                files.push_back(relDir);                 
    6970    } 
     
    101102        BOOL retval =  DoDataExchange(false); 
    102103        return 0; 
     104} 
     105         
     106wpath FileSheet::FileFullPath() const 
     107{ 
     108        return fileRoot_; 
     109} 
     110 
     111hal::file_size_pairs_t FileSheet::FileSizePairs() const 
     112{ 
     113        hal::file_size_pairs_t filePairs; 
     114 
     115        for (int i = 0, e = filesList_.GetItemCount(); i<e; ++i) 
     116        { 
     117                hal::win_c_str<std::wstring> name_buf(MAX_PATH);                 
     118                filesList_.GetItemText(i, 0, name_buf, name_buf.size()); 
     119 
     120                hal::win_c_str<std::wstring> path_buf(MAX_PATH);                 
     121                filesList_.GetItemText(i, 1, path_buf, path_buf.size()); 
     122 
     123//              HAL_DEV_MSG(wformat(L"File: %1%, size: %2%, both: %3%") % fileRoot_.string() % name_buf.str() % (fileRoot_ / path_buf / name_buf).string()); 
     124 
     125                filePairs.push_back(hal::make_pair( 
     126                        wpath(wpath(path_buf.str()) / name_buf).string(),  
     127                        hal::fs::file_size(fileRoot_ / path_buf / name_buf))); 
     128        } 
     129 
     130        return filePairs; 
     131} 
     132 
     133wpath FileSheet::OutputFile() 
     134{ 
     135        DoDataExchange(true); 
     136 
     137        return outFile_; 
     138} 
     139 
     140hal::tracker_details_t TrackerSheet::Trackers() const 
     141{ 
     142        hal::tracker_details_t trackers; 
     143 
     144        for (int i = 0, e = trackerList_.GetItemCount(); i<e; ++i) 
     145        { 
     146                hal::win_c_str<std::wstring> str_buf(MAX_PATH);          
     147                trackerList_.GetItemText(i, 0, str_buf, str_buf.size()); 
     148 
     149                hal::win_c_str<std::wstring> tier_buf(MAX_PATH);                 
     150                trackerList_.GetItemText(i, 1, tier_buf, tier_buf.size()); 
     151 
     152                trackers.push_back(hal::tracker_detail( 
     153                        str_buf, lexical_cast<unsigned>(tier_buf.str()))); 
     154        } 
     155 
     156        return trackers; 
    103157} 
    104158 
     
    219273} 
    220274 
    221 LRESULT NewTorrentDialog::OnOk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    222 { 
     275LRESULT NewTorrentDialog::OnSave(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
     276{ 
     277        try 
     278        { 
     279 
    223280        hal::event().post(shared_ptr<hal::EventDetail>( 
    224                 new hal::EventMsg(L"NewTorrentDialog::OnOk()"))); 
     281                new hal::EventMsg(L"NewTorrentDialog::OnSave()"))); 
     282 
     283        hal::create_torrent_params params; 
     284 
     285        params.file_size_pairs = fileSheet_.FileSizePairs(); 
     286        params.root_path = fileSheet_.FileFullPath(); 
     287 
     288        params.trackers = trackerSheet_.Trackers(); 
     289 
     290        hal::bittorrent().create_torrent(params, fileSheet_.OutputFile()); 
     291 
     292        } 
     293        catch(const std::exception& e) 
     294        { 
     295                hal::event().post(boost::shared_ptr<hal::EventDetail>( 
     296                        new hal::EventStdException(hal::Event::critical, e,  
     297                                L"NewTorrentDialog::OnSave"))); 
     298        } 
    225299 
    226300        return 0; 
  • trunk/src/NewTorrentDialog.hpp

    r427 r429  
    4242#include "NewTorrentPeersLV.hpp" 
    4343 
     44typedef boost::function<void (bool)> enable_save; 
    4445 
    4546class FilesListViewCtrl : 
     
    125126 
    126127public: 
    127         FileSheet() 
     128        FileSheet(enable_save enableSave) : 
     129          EnableSave_(enableSave) 
    128130        {} 
    129131 
     
    149151                DDX_EX_STDWSTRING(IDC_NEWTORRENT_CREATOR, creator_); 
    150152                DDX_EX_STDWSTRING(IDC_NEWTORRENT_COMMENT, comment_); 
     153                DDX_EX_STDWSTRING(IDC_NEWT_FILE, outFile_); 
    151154        DDX_CHECK(IDC_NEWTORRENT_PRIVATE, private_) 
    152155    END_DDX_MAP() 
     
    165168        LRESULT onInitDialog(HWND, LPARAM); 
    166169        void OnDestroy() {}; 
     170 
     171        wpath FileFullPath() const; 
     172        hal::file_size_pairs_t FileSizePairs() const; 
     173 
     174        wpath OutputFile(); 
    167175         
    168176private: 
    169177        FilesListViewCtrl filesList_; 
     178        enable_save EnableSave_; 
    170179         
    171180        wpath fileRoot_; 
     
    174183        wstring creator_; 
    175184        wstring comment_; 
     185        wstring outFile_; 
    176186        bool private_; 
    177  
    178187}; 
    179188 
     
    217226 
    218227        void OnDestroy() {} 
     228 
     229        hal::tracker_details_t Trackers() const; 
    219230         
    220231private: 
     
    278289                iniClass("NewTorrentDialog", "Dialog"), 
    279290                inited_(false), 
    280                 rect_(0,0,0,0) 
     291                rect_(0,0,0,0), 
     292                fileSheet_(bind(&NewTorrentDialog::EnableSave, this, _1)) 
    281293    { 
    282294                Load(); 
    283295 
    284                 AddPage(fileSheet); 
    285                 AddPage(trackerSheet); 
    286                 AddPage(detailsSheet);           
     296                AddPage(fileSheet_); 
     297                AddPage(trackerSheet_); 
     298                AddPage(detailsSheet_);          
    287299        } 
    288300 
     
    293305                MSG_WM_DESTROY(OnDestroy) 
    294306                 
    295                 COMMAND_ID_HANDLER(0x1, OnOk) 
     307                COMMAND_ID_HANDLER(0x1, OnSave) 
    296308 
    297309                CHAIN_MSG_MAP(resizeClass) 
     
    326338                Save(); 
    327339        } 
    328          
    329         LRESULT OnOk(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); 
     340 
     341        void EnableSave(bool enable) 
     342        { 
     343                ::EnableWindow(GetDlgItem(0x1), enable); 
     344        } 
     345         
     346        LRESULT OnSave(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); 
    330347 
    331348        friend class boost::serialization::access; 
     
    354371        } 
    355372 
    356         FileSheet fileSheet; 
    357         TrackerSheet trackerSheet; 
    358         PeersSheet detailsSheet; 
     373        FileSheet fileSheet_; 
     374        TrackerSheet trackerSheet_; 
     375        PeersSheet detailsSheet_; 
    359376}; 
    360377 
  • trunk/src/NewTorrentTrackerAD.hpp

    r425 r429  
    2727         
    2828public: 
    29         NewTorrent_TrackerAddDialog(wstring title, hal::TrackerDetail& tracker) : 
     29        NewTorrent_TrackerAddDialog(wstring title, hal::tracker_detail& tracker) : 
    3030                genericBaseClass(title, "genericAddDlgs/NewTorrentAddTracker", "NewTorrentAddTracker"), 
    3131                tracker_(tracker) 
     
    5353private: 
    5454        wstring title_; 
    55         hal::TrackerDetail& tracker_; 
     55        hal::tracker_detail& tracker_; 
    5656}; 
  • trunk/src/NewTorrentTrackerLV.cpp

    r423 r429  
    4040                if (lock)  
    4141                {                        
    42                         std::vector<hal::TrackerDetail> trackers = 
     42                        std::vector<hal::tracker_detail> trackers = 
    4343                                hal::bittorrent().getTorrentTrackers(pT->name()); 
    4444                        clearAll(); 
    4545                         
    46                         foreach (const hal::TrackerDetail& tracker, trackers) 
     46                        foreach (const hal::tracker_detail& tracker, trackers) 
    4747                        { 
    4848                                int itemPos = AddItem(0, 0, tracker.url.c_str(), 0); 
     
    5959void NewTorrent_TrackerListViewCtrl::newItem() 
    6060{ 
    61         hal::TrackerDetail tracker(L"", 0);      
     61        hal::tracker_detail tracker(L"", 0);     
    6262        NewTorrent_TrackerAddDialog trackDlg(L"Add New Tracker", tracker); 
    6363         
     
    7474 
    7575        GetItemText(index, 0, buffer.elems, buffer.size()); 
    76         hal::TrackerDetail tracker(wstring(buffer.elems), 0); 
     76        hal::tracker_detail tracker(wstring(buffer.elems), 0); 
    7777         
    7878        GetItemText(index, 1, buffer.elems, buffer.size()); 
  • trunk/src/advtabs/Tracker.cpp

    r408 r429  
    191191        hal::bittorrent().resetTorrentTrackers(torrent_name); 
    192192         
    193         std::vector<hal::TrackerDetail> trackers = 
     193        std::vector<hal::tracker_detail> trackers = 
    194194                hal::bittorrent().getTorrentTrackers(torrent_name); 
    195195        m_list.clearAll(); 
    196196         
    197         foreach (const hal::TrackerDetail& tracker, trackers) 
     197        foreach (const hal::tracker_detail& tracker, trackers) 
    198198        { 
    199199                int itemPos = m_list.AddItem(0, 0, tracker.url.c_str(), 0); 
     
    207207{ 
    208208        int total = m_list.GetItemCount(); 
    209         std::vector<hal::TrackerDetail> trackers; 
     209        std::vector<hal::tracker_detail> trackers; 
    210210         
    211211        for (int i=0; i<total; ++i) 
     
    214214                 
    215215                m_list.GetItemText(i, 0, buffer.elems, buffer.size()); 
    216                 trackers.push_back(hal::TrackerDetail(wstring(buffer.elems), 0)); 
     216                trackers.push_back(hal::tracker_detail(wstring(buffer.elems), 0)); 
    217217                 
    218218                m_list.GetItemText(i, 1, buffer.elems, buffer.size()); 
  • trunk/src/advtabs/TrackerAddDialog.hpp

    r425 r429  
    2929         
    3030public: 
    31         TrackerAddDialog(wstring title, hal::TrackerDetail& tracker) : 
     31        TrackerAddDialog(wstring title, hal::tracker_detail& tracker) : 
    3232                genericBaseClass(title, "genericAddDlgs/AddTracker", "AddTracker"), 
    3333                tracker_(tracker) 
     
    5555private: 
    5656        wstring title_; 
    57         hal::TrackerDetail& tracker_; 
     57        hal::tracker_detail& tracker_; 
    5858}; 
    5959 
  • trunk/src/advtabs/TrackerListView.cpp

    r423 r429  
    4040                if (lock)  
    4141                {                        
    42                         std::vector<hal::TrackerDetail> trackers = 
     42                        std::vector<hal::tracker_detail> trackers = 
    4343                                hal::bittorrent().getTorrentTrackers(pT->name()); 
    4444                        clearAll(); 
    4545                         
    46                         foreach (const hal::TrackerDetail& tracker, trackers) 
     46                        foreach (const hal::tracker_detail& tracker, trackers) 
    4747                        { 
    4848                                int itemPos = AddItem(0, 0, tracker.url.c_str(), 0); 
     
    5959void TrackerListViewCtrl::newItem() 
    6060{ 
    61         hal::TrackerDetail tracker(L"", 0);      
     61        hal::tracker_detail tracker(L"", 0);     
    6262        TrackerAddDialog trackDlg(L"Add New Tracker", tracker); 
    6363         
     
    7676 
    7777        GetItemText(index, 0, buffer.elems, buffer.size()); 
    78         hal::TrackerDetail tracker(wstring(buffer.elems), 0); 
     78        hal::tracker_detail tracker(wstring(buffer.elems), 0); 
    7979         
    8080        GetItemText(index, 1, buffer.elems, buffer.size()); 
  • trunk/src/global/string_conv.hpp

    r423 r429  
    8080        typedef typename S::value_type char_t; 
    8181 
     82        size_t size() { return (N >= 0) ? N : 0; } 
     83        string_t str() { return string_t(&vector_[0]); }  
     84         
    8285        operator char_t* () { return buffer_.elems; } 
    8386        operator const string_t() { return string_t(buffer_.elems); } 
    84         size_t size() { return (N >= 0) ? N : 0; } 
    8587 
    8688private: 
     
    99101        typedef typename S::value_type char_t; 
    100102 
     103        size_t size() { return vector_.size(); } 
     104        string_t str() { return string_t(&vector_[0]); }  
     105 
    101106        operator char_t* () { return &vector_[0]; } 
    102107        operator const string_t() { return string_t(&vector_[0]); } 
    103         size_t size() { return vector_.size(); } 
    104108 
    105109private: 
  • trunk/src/halTorrent.cpp

    r427 r429  
    8080 
    8181template<class Archive> 
    82 void serialize(Archive& ar, hal::TrackerDetail& tracker, const unsigned int version) 
     82void serialize(Archive& ar, hal::tracker_detail& tracker, const unsigned int version) 
    8383{        
    8484        ar & BOOST_SERIALIZATION_NVP(tracker.url); 
     
    723723{ 
    724724        pimpl->saveTorrentData(); 
     725} 
     726 
     727void BitTorrent::create_torrent(const create_torrent_params& params, fs::wpath out_file) 
     728{ 
     729 
     730        HAL_DEV_MSG(wformat_t(L"create_torrent creator: %1%, comment: %2%") % params.creator % params.comment); 
     731 
     732        HAL_DEV_MSG(L"Files"); 
     733        for (file_size_pairs_t::const_iterator i = params.file_size_pairs.begin(), e = params.file_size_pairs.end(); 
     734                        i != e; ++i) 
     735        { 
     736                HAL_DEV_MSG(wformat_t(L"file path: %1%, size: %2%") % (*i).first % (*i).second); 
     737        } 
     738 
     739        HAL_DEV_MSG(L"Trackers"); 
     740        for (tracker_details_t::const_iterator i = params.trackers.begin(), e = params.trackers.end(); 
     741                        i != e; ++i) 
     742        { 
     743                HAL_DEV_MSG(wformat_t(L"URL: %1%, Tier: %2%") % (*i).url % (*i).tier); 
     744        } 
    725745} 
    726746 
     
    19761996 
    19771997void BitTorrent::setTorrentTrackers(const std::string& filename,  
    1978         const std::vector<TrackerDetail>& trackers) 
     1998        const std::vector<tracker_detail>& trackers) 
    19791999{ 
    19802000        setTorrentTrackers(from_utf8_safe(filename), trackers); 
     
    19822002 
    19832003void BitTorrent::setTorrentTrackers(const std::wstring& filename,  
    1984         const std::vector<TrackerDetail>& trackers) 
     2004        const std::vector<tracker_detail>& trackers) 
    19852005{ 
    19862006        try { 
     
    20052025} 
    20062026 
    2007 std::vector<TrackerDetail> BitTorrent::getTorrentTrackers(const std::string& filename) 
     2027std::vector<tracker_detail> BitTorrent::getTorrentTrackers(const std::string& filename) 
    20082028{ 
    20092029        return getTorrentTrackers(from_utf8_safe(filename)); 
    20102030} 
    20112031 
    2012 std::vector<TrackerDetail> BitTorrent::getTorrentTrackers(const std::wstring& filename) 
     2032std::vector<tracker_detail> BitTorrent::getTorrentTrackers(const std::wstring& filename) 
    20132033{ 
    20142034        try { 
     
    20182038        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getTorrentTrackers") 
    20192039         
    2020         return std::vector<TrackerDetail>();     
     2040        return std::vector<tracker_detail>();    
    20212041} 
    20222042 
  • trunk/src/halTorrent.hpp

    r427 r429  
    1717#include <boost/bind.hpp> 
    1818 
    19 #include <boost/thread/thread.hpp> 
    20 #include <boost/thread/recursive_mutex.hpp> 
    2119#include <boost/smart_ptr.hpp> 
    2220 
    2321#include <boost/noncopyable.hpp> 
    2422 
    25 #include <boost/tuple/tuple.hpp> 
    2623#include <boost/signal.hpp> 
    2724#include <boost/optional.hpp> 
    2825#include <boost/function.hpp> 
    2926 
    30 #include <boost/date_time/posix_time/posix_time.hpp> 
    3127#include <boost/smart_ptr.hpp> 
    3228#include <boost/algorithm/string.hpp> 
     
    4137#include <asio/ip/udp.hpp> 
    4238 
     39#include "halTypes.hpp" 
     40 
    4341namespace libtorrent { struct peer_info; } 
    4442 
    4543namespace hal  
    4644{ 
    47  
    48 typedef boost::recursive_mutex mutex_t; 
    49 typedef boost::thread thread_t; 
    5045         
    5146struct torrentBriefDetail  
     
    144139public: 
    145140        TorrentDetail(std::wstring n, std::wstring f, std::wstring sd, std::wstring s, std::wstring cT, std::pair<float,float> sp=std::pair<float,float>(0,0), 
    146                         float c=0, float d=0, boost::int64_t tWD=0, boost::int64_t tW=0, boost::int64_t tU=0, boost::int64_t tpU=0, boost::int64_t tD=0, boost::int64_t tpD=0, boost::tuple<size_t, size_t, size_t, size_t> connections = boost::tuple<size_t, size_t, size_t, size_t>(0,0,0,0), float r=0,  
     141                        float c=0, float d=0, size_type tWD=0, size_type tW=0, size_type tU=0, size_type tpU=0, size_type tD=0, size_type tpD=0, boost::tuple<size_type, size_type, size_type, size_type> connections = boost::tuple<size_type, size_type, size_type, size_type>(0,0,0,0), float r=0,  
    147142                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0), boost::posix_time::time_duration uIn=boost::posix_time::seconds(0), 
    148143                        boost::posix_time::time_duration actve=boost::posix_time::seconds(0), boost::posix_time::time_duration seding=boost::posix_time::seconds(0), boost::posix_time::ptime srt=boost::posix_time::second_clock::universal_time(), boost::posix_time::ptime fin=boost::posix_time::second_clock::universal_time()) : 
     
    200195        const float& distributedCopies() const { return distributed_copies_; } 
    201196         
    202         const boost::int64_t& totalUploaded() const { return totalUploaded_; } 
    203         const boost::int64_t& totalPayloadUploaded() const { return totalPayloadUploaded_; } 
    204         const boost::int64_t& totalDownloaded() const { return totalDownloaded_; } 
    205         const boost::int64_t& totalPayloadDownloaded() const { return totalPayloadDownloaded_; } 
    206         const boost::int64_t& totalWantedDone() const { return totalWantedDone_; } 
    207         const boost::int64_t& totalWanted() const { return totalWanted_; } 
    208          
    209         int peers() const { return peers_; } 
    210         int peersConnected() const { return connectedPeers_; } 
    211         int seeds() const { return seeds_; } 
    212         int seedsConnected() const { return connectedSeeds_; } 
     197        size_type totalUploaded() const { return totalUploaded_; } 
     198        size_type totalPayloadUploaded() const { return totalPayloadUploaded_; } 
     199        size_type totalDownloaded() const { return totalDownloaded_; } 
     200        size_type totalPayloadDownloaded() const { return totalPayloadDownloaded_; } 
     201        size_type totalWantedDone() const { return totalWantedDone_; } 
     202        size_type totalWanted() const { return totalWanted_; } 
     203         
     204        size_type peers() const { return peers_; } 
     205        size_type peersConnected() const { return connectedPeers_; } 
     206        size_type seeds() const { return seeds_; } 
     207        size_type seedsConnected() const { return connectedSeeds_; } 
    213208         
    214209        float ratio() { return ratio_; } 
     
    236231        float distributed_copies_; 
    237232         
    238         boost::int64_t totalWantedDone_; 
    239         boost::int64_t totalWanted_; 
    240         boost::int64_t totalUploaded_; 
    241         boost::int64_t totalPayloadUploaded_; 
    242         boost::int64_t totalDownloaded_; 
    243         boost::int64_t totalPayloadDownloaded_; 
    244          
    245         int peers_; 
    246         int connectedPeers_; 
    247         int seeds_; 
    248         int connectedSeeds_; 
     233        size_type totalWantedDone_; 
     234        size_type totalWanted_; 
     235        size_type totalUploaded_; 
     236        size_type totalPayloadUploaded_; 
     237        size_type totalDownloaded_; 
     238        size_type totalPayloadDownloaded_; 
     239         
     240        size_type peers_; 
     241        size_type connectedPeers_; 
     242        size_type seeds_; 
     243        size_type connectedSeeds_; 
    249244         
    250245        float ratio_; 
     
    330325}; 
    331326 
    332 struct TrackerDetail 
    333 { 
    334         TrackerDetail() {} 
    335         TrackerDetail(std::wstring u, int t) : url(u), tier(t) {} 
    336          
    337         bool operator<(const TrackerDetail& t) const 
     327struct tracker_detail 
     328{ 
     329        tracker_detail() {} 
     330        tracker_detail(std::wstring u, int t) : url(u), tier(t) {} 
     331         
     332        bool operator<(const tracker_detail& t) const 
    338333        { 
    339334                return (tier < t.tier); 
     
    343338        int tier; 
    344339}; 
     340 
     341typedef std::vector<tracker_detail> tracker_details_t; 
    345342 
    346343struct UrlDhtPeerDetail 
     
    364361}; 
    365362 
     363typedef std::vector<pair<fs::wpath, size_type> > file_size_pairs_t; 
     364 
     365struct create_torrent_params 
     366{ 
     367        create_torrent_params() {} 
     368 
     369        std::wstring creator; 
     370        std::wstring comment; 
     371 
     372        file_size_pairs_t file_size_pairs; 
     373        fs::wpath root_path; 
     374 
     375        tracker_details_t trackers; 
     376}; 
    366377 
    367378class EventDetail; 
     
    415426        void shutDownSession(); 
    416427        void saveTorrentData(); 
     428 
     429        void create_torrent(const create_torrent_params& params, fs::wpath out_file); 
    417430         
    418431        bool listenOn(std::pair<int, int> const& portRange); 
     
    435448        void ip_filter_import_dat(boost::filesystem::path file, progressCallback fn, bool octalFix); 
    436449        size_t ip_filter_size(); 
    437         void clearIpFilter(); 
    438          
     450        void clearIpFilter();    
    439451         
    440452        void setSessionHalfOpenLimit(int halfConn); 
     
    504516        std::pair<float, float> getTorrentSpeed(const std::wstring& filename); 
    505517         
    506         void setTorrentTrackers(const std::string& filename, const std::vector<TrackerDetail>& trackers); 
    507         void setTorrentTrackers(const std::wstring& filename, const std::vector<TrackerDetail>& trackers); 
     518        void setTorrentTrackers(const std::string& filename, const std::vector<tracker_detail>& trackers); 
     519        void setTorrentTrackers(const std::wstring& filename, const std::vector<tracker_detail>& trackers); 
    508520        void resetTorrentTrackers(const std::string& filename); 
    509521        void resetTorrentTrackers(const std::wstring& filename); 
    510         std::vector<TrackerDetail> getTorrentTrackers(const std::string& filename); 
    511         std::vector<TrackerDetail> getTorrentTrackers(const std::wstring& filename); 
     522        std::vector<tracker_detail> getTorrentTrackers(const std::string& filename); 
     523        std::vector<tracker_detail> getTorrentTrackers(const std::wstring& filename); 
    512524         
    513525        void setTorrentFilePriorities(const std::string& filename, std::vector<int> fileIndices, int priority); 
  • trunk/src/halTorrentInternal.hpp

    r427 r429  
    409409        DurationTracker seedingDuration_; 
    410410         
    411         std::vector<TrackerDetail> trackers_; 
     411        std::vector<tracker_detail> trackers_; 
    412412        std::vector<lbt::announce_entry> torrent_trackers_; 
    413413        std::vector<lbt::peer_info> peers_;      
     
    816816        } 
    817817         
    818         void setTrackers(const std::vector<TrackerDetail>& trackerDetails) 
     818        void setTrackers(const std::vector<tracker_detail>& tracker_details) 
    819819        { 
    820820                trackers_.clear(); 
    821                 trackers_.assign(trackerDetails.begin(), trackerDetails.end()); 
     821                trackers_.assign(tracker_details.begin(), tracker_details.end()); 
    822822                 
    823823                applyTrackers(); 
    824824        } 
    825825         
    826         const std::vector<TrackerDetail>& getTrackers() 
     826        const std::vector<tracker_detail>& getTrackers() 
    827827        { 
    828828                if (trackers_.empty()) 
     
    833833                        { 
    834834                                trackers_.push_back( 
    835                                         TrackerDetail(hal::from_utf8(entry.url), entry.tier)); 
     835                                        tracker_detail(hal::from_utf8(entry.url), entry.tier)); 
    836836                        } 
    837837                }                
     
    11471147                                std::vector<lbt::announce_entry> trackers; 
    11481148                                 
    1149                                 foreach (const TrackerDetail& tracker, trackers_) 
     1149                                foreach (const tracker_detail& tracker, trackers_) 
    11501150                                { 
    11511151                                        trackers.push_back( 
     
    12791279        DurationTracker seedingDuration_; 
    12801280         
    1281         std::vector<TrackerDetail> trackers_; 
     1281        std::vector<tracker_detail> trackers_; 
    12821282        std::vector<lbt::announce_entry> torrent_trackers_; 
    12831283        std::vector<lbt::peer_info> peers_;      
Note: See TracChangeset for help on using the changeset viewer.