Changeset 447 for trunk


Ignore:
Timestamp:
05/17/08 11:03:03 (12 years ago)
Author:
Eoin
Message:

Cleaned up the SortListView? class.

Location:
trunk/src
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/HaliteDialog.hpp

    r445 r447  
    9191         
    9292                DialogListView() : 
    93                         iniClass("listviews/dialog", "DialogPeersList"), 
    94                         listClass(true,false,false) 
     93                        iniClass("listviews/dialog", "DialogPeersList") 
    9594                {                                        
    9695                        std::vector<wstring> names;      
  • trunk/src/HaliteListView.cpp

    r441 r447  
    66 
    77#include "stdAfx.hpp" 
     8 
     9#include <boost/iterator/filter_iterator.hpp> 
     10#include <winstl/controls/listview_sequence.hpp> 
     11 
    812#include "Halite.hpp" 
    913 
     
    1620HaliteListViewCtrl::HaliteListViewCtrl(HaliteWindow& HalWindow) : 
    1721        halWindow_(HalWindow), 
    18         iniClass("listviews/halite", "HaliteListView"), 
    19         listClass(true, false, false) 
     22        iniClass("listviews/halite", "HaliteListView") 
    2023{                
    2124        HalWindow.connectUiUpdate(bind(&HaliteListViewCtrl::uiUpdate, this, _1)); 
     
    2427        wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
    2528         
    26         // "Name;Status;Progress;Download;Upload;Peers;Seeds;ETA;Copies;Tracker;Reannounce;Ratio;Total;Completed;Remaining;Downloaded;Uploaded;Active;Seeding;Start Time;Finish Time" 
    2729        boost::split(names, column_names, boost::is_any_of(L";")); 
    2830         
    29         array<int, 21> widths = {100,110,60,60,60,42,45,61,45,45,45,45,45,45,45,45,45,45,45,45,45}; 
    30         array<int, 21> order = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}; 
    31         array<bool, 21> visible = {true,true,true,true,true,true,true,true,true,true,true,\ 
     31        array<int, NumberOfColumns_s> widths = {100,110,60,60,60,42,45,61,45,45,45,45,45,45,45,45,45,45,45,45,45}; 
     32        array<int, NumberOfColumns_s> order = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}; 
     33        array<bool, NumberOfColumns_s> visible = {true,true,true,true,true,true,true,true,true,true,true,\ 
    3234                true,true,true,true,true,true,true,true,true,true}; 
    3335         
     
    9395                        itemPos = AddItem(0, 0, td->name().c_str(), 0); 
    9496 
    95                 for (size_t i=1; i<HaliteListViewCtrl::NumberOfColumns_s; ++i) 
     97                for (size_t i=1; i<NumberOfColumns_s; ++i) 
    9698                { 
    9799                        SetItemText(itemPos, i, getColumnAdapter(i)->print(td).c_str()); 
     
    117119LRESULT HaliteListViewCtrl::OnResume(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    118120{ 
    119         std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    120                 bind((void (hal::bit::*)(const std::wstring&))&hal::bit::resumeTorrent,  
    121                         &hal::bittorrent(), _1)); 
     121        typedef winstl::listview_sequence::sequence_value_type lv_val; 
     122        winstl::listview_sequence lv_seq(*this); 
     123 
     124        std::for_each(make_filter_iterator(&is_selected, lv_seq.begin(), lv_seq.end()), 
     125                                  make_filter_iterator(&is_selected, lv_seq.end(), lv_seq.end()), 
     126                                  bind((void (hal::bit::*)(const std::wstring&))&hal::bit::resumeTorrent,  
     127                                      &hal::bittorrent(),  
     128                                          bind(&hal::to_wstr_shim<const lv_val>, _1))); 
    122129         
    123130        return 0; 
     
    126133LRESULT HaliteListViewCtrl::OnPause(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    127134{        
    128         std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    129                 bind((void (hal::bit::*)(const std::wstring&))&hal::bit::pauseTorrent, 
    130                         &hal::bittorrent(), _1)); 
     135        typedef winstl::listview_sequence::sequence_value_type lv_val; 
     136        winstl::listview_sequence lv_seq(*this); 
     137 
     138        std::for_each(make_filter_iterator(&is_selected, lv_seq.begin(), lv_seq.end()), 
     139                                  make_filter_iterator(&is_selected, lv_seq.end(), lv_seq.end()), 
     140                                  bind((void (hal::bit::*)(const std::wstring&))&hal::bit::pauseTorrent,  
     141                                      &hal::bittorrent(),  
     142                                          bind(&hal::to_wstr_shim<const lv_val>, _1))); 
    131143         
    132144        return 0; 
     
    135147LRESULT HaliteListViewCtrl::OnStop(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    136148{ 
    137         std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    138                 bind((void (hal::bit::*)(const std::wstring&))&hal::bit::stopTorrent,  
    139                         &hal::bittorrent(), _1)); 
    140          
     149        typedef winstl::listview_sequence::sequence_value_type lv_val; 
     150        winstl::listview_sequence lv_seq(*this); 
     151 
     152        std::for_each(make_filter_iterator(&is_selected, lv_seq.begin(), lv_seq.end()), 
     153                                  make_filter_iterator(&is_selected, lv_seq.end(), lv_seq.end()), 
     154                                  bind((void (hal::bit::*)(const std::wstring&))&hal::bit::stopTorrent,  
     155                                      &hal::bittorrent(),  
     156                                          bind(&hal::to_wstr_shim<const lv_val>, _1))); 
     157 
    141158        return 0; 
    142159} 
     
    188205                i != e; ++i) 
    189206        { 
    190                 wstring saveDir = hal::bittorrent().torrentDetails().get(*i)->saveDirectory();           
     207                wpath saveDir = hal::bittorrent().get(*i).save_directory;                
    191208                HAL_DEV_MSG(wformat(L"Name %1%, Save dir: %2%.") % *i % saveDir); 
    192209 
  • trunk/src/HaliteListView.hpp

    r437 r447  
    373373    { 
    374374                if (version > 2) 
    375                         ar & boost::serialization::make_nvp("listview", boost::serialization::base_object<listClass>(*this)); 
     375                        ar & boost::serialization::make_nvp("listview",  
     376                                boost::serialization::base_object<listClass>(*this)); 
    376377    } 
    377378         
  • trunk/src/HaliteSortListViewCtrl.hpp

    r423 r447  
    1010 
    1111#include <functional> 
     12 
    1213#include <boost/array.hpp> 
    1314#include <boost/signals.hpp> 
     
    1617#include <boost/serialization/split_free.hpp> 
    1718#include <boost/ptr_container/ptr_map.hpp> 
     19 
     20#include <winstl/controls/listview_sequence.hpp> 
    1821 
    1922#include "Halite.hpp" 
     
    4548} 
    4649 
    47 template <class TBase, typename adapterType=void*, size_t N=-1> 
     50template <class TBase, typename adapterType=void*> 
    4851class CHaliteSortListViewCtrl :  
    49         public WTL::CSortListViewCtrlImpl<CHaliteSortListViewCtrl<TBase, adapterType, N> > 
     52        public WTL::CSortListViewCtrlImpl<CHaliteSortListViewCtrl<TBase, adapterType> > 
    5053{ 
    5154public: 
    52         typedef CHaliteSortListViewCtrl<TBase, adapterType, N> thisClass; 
     55        typedef CHaliteSortListViewCtrl<TBase, adapterType> thisClass; 
    5356        typedef CSortListViewCtrlImpl<thisClass> parentClass; 
    5457         
    55 #if 0 
    56         class selection_manager :  
    57                 private boost::noncopyable 
    58         {        
    59         public: 
    60                 selection_manager(thisClass& m_list) : 
    61                         m_list_(m_list) 
    62                 {} 
    63                  
    64                 typedef std::wstring string_t;  
    65                 typedef const string_t& param_type; 
    66                  
    67                 void sync_list(bool list_to_manager, bool signal_change=true) 
    68                 { 
    69                         if (list_to_manager) 
    70                         {        
    71                                 if (listToManager() && signal_change) signal(); 
    72                         } 
    73                         else 
    74                         { 
    75                                 if (managerToList() && signal_change) signal(); 
    76                         } 
    77                 } 
    78                  
    79                 bool listToManager() 
    80                 { 
    81                         boost::array<wchar_t, MAX_PATH> pathBuffer; 
    82                         std::set<string_t> all_selected; 
    83                         string_t selected = L""; 
    84                          
    85                         bool do_signal = false; 
    86                          
    87                         int total = m_list_.GetItemCount(); 
    88                          
    89                         for (int i=0; i<total; ++i) 
    90                         { 
    91                                 UINT flags = m_list_.GetItemState(i, LVIS_SELECTED); 
    92                                  
    93                                 if (flags && LVIS_SELECTED) 
    94                                 { 
    95                                         m_list_.GetItemText(i, 0, pathBuffer.c_array(), pathBuffer.size());      
    96                                         all_selected.insert(pathBuffer.data()); 
    97                                 } 
    98                                 if (flags && LVIS_FOCUSED) 
    99                                 { 
    100                                         selected = pathBuffer.data(); 
    101                                 } 
    102                         } 
    103  
    104                         if (all_selected != all_selected_) 
    105                         { 
    106                                 std::swap(all_selected_, all_selected); 
    107                                 do_signal = true; 
    108                         } 
    109                                          
    110                         if (selected_ != selected) 
    111                         { 
    112                                 std::swap(selected_, selected); 
    113                                 do_signal = true; 
    114                         } 
    115                          
    116                         return do_signal; 
    117                 } 
    118                  
    119                 bool managerToList() 
    120                 { 
    121                         // Prevent changing states from signaling another sync 
    122                         UpdateLock<thisClass> lock(m_list_); 
    123                          
    124                         boost::array<wchar_t, MAX_PATH> pathBuffer; 
    125                         LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };  
    126                         findInfo.flags = LVFI_STRING; 
    127                          
    128                         bool do_signal = true; // Always signal for now! 
    129                          
    130                         int total = m_list_.GetItemCount(); 
    131                          
    132                         for (int i=0; i<total; ++i) 
    133                         { 
    134                                 m_list_.GetItemText(i, 0, pathBuffer.c_array(), pathBuffer.size()); 
    135                                 string_t temp_name = pathBuffer.data(); 
    136                                  
    137                                 LVITEM lvi = { LVIF_STATE }; 
    138                                 lvi.state = 0; 
    139                                 lvi.stateMask = LVIS_SELECTED|LVIS_FOCUSED; 
    140                                  
    141                                 if (temp_name == selected_) 
    142                                 { 
    143                                         lvi.state |= LVIS_FOCUSED; 
    144                                 } 
    145                                 if (all_selected_.find(temp_name) != all_selected_.end()) 
    146                                 { 
    147                                         lvi.state |= LVIS_SELECTED; 
    148                                 } 
    149                                  
    150                                 m_list_.SetItemState(i, &lvi); 
    151                         }                        
    152                          
    153                         return do_signal; 
    154                 } 
    155                  
    156                 int selectMatch(const string_t& name) 
    157                 { 
    158                         LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };  
    159                         findInfo.flags = LVFI_STRING; 
    160                                          
    161                         findInfo.psz = name.c_str(); 
    162                          
    163                         int itemPos = m_list_.FindItem(&findInfo, -1);   
    164                                                  
    165                         if (itemPos == -1) 
    166                                 return itemPos; 
    167                                  
    168                         UINT flags = m_list_.GetItemState(itemPos, LVIS_SELECTED); 
    169                          
    170                         //if (!flags && LVIS_SELECTED) 
    171                         { 
    172                                 LVITEM lvi = { LVIF_STATE }; 
    173                                 lvi.state = LVIS_SELECTED; 
    174                                 lvi.stateMask = LVIS_SELECTED; 
    175                                 m_list_.SetItemState(itemPos, &lvi); 
    176                         } 
    177                  
    178                         return itemPos; 
    179                 } 
    180                  
    181                 param_type selected() const { return selected_; } 
    182                  
    183                 int selectedIndex() const 
    184                 { 
    185                         LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };          
    186                         findInfo.psz = selected_.c_str(); 
    187                          
    188                         return m_list_.FindItem(&findInfo, -1);          
    189                 } 
    190                  
    191                 const std::set<string_t>& allSelected() const { return all_selected_; } 
    192                  
    193                 void setSelected(const string_t& sel)  
    194                 { 
    195                         selected_ = sel; 
    196                 } 
    197                  
    198                 void setSelected(int itemPos) 
    199                 {                
    200                         hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"Set Selected %1%") % itemPos).str().c_str()))); 
    201  
    202                         LVITEM lvi = { LVIF_STATE }; 
    203                         lvi.state = LVIS_SELECTED|LVIS_FOCUSED; 
    204                         lvi.stateMask = LVIS_SELECTED|LVIS_FOCUSED; 
    205                         m_list_.SetItemState(itemPos, &lvi); 
    206                          
    207                         m_list_.SetSelectionMark(itemPos); 
    208                          
    209                         sync_list(true); 
    210                 } 
    211                  
    212                 void clear() 
    213                 { 
    214                         // Prevent changing states from signaling another sync 
    215                         UpdateLock<thisClass> lock(m_list_); 
    216                          
    217                         m_list_.DeleteItem(selectedIndex()); 
    218                          
    219                         sync_list(true);         
    220                 } 
    221                  
    222                 void clear_all_selected() 
    223                 { 
    224                         // Prevent changing states from signaling another sync 
    225                         UpdateLock<thisClass> lock(m_list_); 
    226                          
    227                         int total = m_list_.GetItemCount(); 
    228                          
    229                         for (int i=total-1; i>=0; --i) 
    230                         { 
    231                                 UINT flags = m_list_.GetItemState(i, LVIS_SELECTED); 
    232                                  
    233                                 if (flags && LVIS_SELECTED) 
    234                                         m_list_.DeleteItem(i); 
    235                         } 
    236                         all_selected_.clear(); 
    237                          
    238                         sync_list(true);         
    239                 } 
    240                  
    241                 void clear_all() 
    242                 { 
    243                         // Prevent changing states from signaling another sync 
    244                         UpdateLock<thisClass> lock(m_list_); 
    245                          
    246                         m_list_.DeleteAllItems(); 
    247                         all_selected_.clear(); 
    248                          
    249                         sync_list(true);                 
    250                 } 
    251                  
    252                 void attach(boost::function<void (param_type)> fn) const { selection_.connect(fn); } 
    253                  
    254                 void signal()  
    255                 {  
    256                         selection_(selected_);  
    257                 } 
    258                  
    259         private: 
    260                 string_t selected_; 
    261                 std::set<string_t> all_selected_; 
    262                  
    263                 mutable boost::signal<void (param_type)> selection_; 
    264                 thisClass& m_list_; 
    265         }; 
    266 #endif   
    26758        class CHaliteHeaderCtrl : public CWindowImpl<CHaliteHeaderCtrl, WTL::CHeaderCtrl> 
    26859        { 
     
    332123        typedef SelectionManager selection_manage_class; 
    333124         
    334         thisClass(bool resMenu=true, bool resNames=true, bool resWidthsAndOrder=true) : 
     125        thisClass() : 
    335126                manager_(*this), 
    336127                header_(*this), 
     
    340131                sortCol_(-1) 
    341132        {                
    342                 if (resMenu && TBase::LISTVIEW_ID_MENU) 
     133                if (TBase::LISTVIEW_ID_MENU) 
    343134                { 
    344135                        CMenuHandle menu; 
     
    348139                        menu_.Attach(menu.GetSubMenu(0)); 
    349140                } 
    350  
    351                 if (resNames) 
    352                 { 
    353                         wstring column_names = hal::app().res_wstr(TBase::LISTVIEW_ID_COLUMNNAMES); 
    354                         boost::split(listNames_, column_names, boost::is_any_of(L";")); 
    355                 } 
    356                  
    357                 if (resWidthsAndOrder) 
    358                 { 
    359                         wstring column_widths = hal::app().res_wstr(TBase::LISTVIEW_ID_COLUMNWIDTHS); 
    360                         std::vector<wstring> widths; 
    361                         boost::split(widths, column_widths, boost::is_any_of(L";")); 
    362                          
    363                         listWidths_.reserve(listNames_.size());  
    364                         listOrder_.reserve(listNames_.size()); 
    365                          
    366                         for (size_t i=0; i<listNames_.size(); ++i) 
    367                         { 
    368                                 listWidths_.push_back(lexical_cast<int>(widths[i])); 
    369                                 listOrder_.push_back(i); 
    370                         } 
    371                 } 
    372141        } 
    373142 
     
    415184        }                
    416185         
    417         void SetListViewDetails() 
    418         { 
    419                 vectorSizePreConditions(); 
    420                  
    421                 header_.Attach(this->GetHeader()); 
    422                 header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG); 
    423                          
    424                 foreach (wstring name, listNames_) 
    425                 { 
    426                         int i = header_.GetItemCount(); 
    427                          
    428                         AddColumn(name.c_str(), i); 
    429                 }                
    430  
    431                 for (unsigned i=0; i<listNames_.size(); ++i) 
    432                         SetColumnWidth(i, listOrder_[i]); 
    433                  
    434                 SetColumnOrderArray(listOrder_.size(), &listOrder_[0]);  
    435         } 
    436          
    437186        template<typename N, typename W, typename O, typename P> 
    438187        void SetDefaults(N nameList, W widthList, O orderList, P visibleList, bool autoSort=false) 
     
    444193                 
    445194                autoSort_ = autoSort; 
    446         } 
    447          
    448         template<std::size_t Size> 
    449         void SetDefaults(array<int, Size> a) 
    450         { 
    451                 assert (Size == listNames_.size()); 
    452                 vectorSizePreConditions(); 
    453                  
    454                 for (size_t i=0; i<listNames_.size(); ++i) 
    455                 { 
    456                         listWidths_[i] = a[i]; 
    457                         listOrder_[i] = i; 
    458                 }                
    459195        } 
    460196         
     
    594330        {                
    595331                hal::try_update_lock<thisClass> lock(*this); 
    596                 if (lock)  
    597                         manager_.sync_list(true, true); 
    598                         //syncTimer_.reset(50, 0, bind(&thisClass::syncTimeout, this)); 
     332                 
     333                if (lock) manager_.sync_list(true, true); 
    599334                 
    600335                return 0; 
     
    638373    void serialize(Archive & ar, const unsigned int version) 
    639374    { 
     375                using boost::serialization::make_nvp; 
    640376                if (version >= 1) 
    641377                { 
    642                         ar & boost::serialization::make_nvp("width", listWidths_); 
    643                         ar & boost::serialization::make_nvp("order", listOrder_); 
    644                         ar & boost::serialization::make_nvp("visible", listVisible_); 
    645                         ar & boost::serialization::make_nvp("autoSort", autoSort_); 
     378                        ar & make_nvp("width", listWidths_); 
     379                        ar & make_nvp("order", listOrder_); 
     380                        ar & make_nvp("visible", listVisible_); 
     381                        ar & make_nvp("autoSort", autoSort_); 
    646382                } 
    647383                if (version >= 2) 
    648384                { 
    649                         ar & boost::serialization::make_nvp("descending", descending_); 
    650                         ar & boost::serialization::make_nvp("sortCol", sortCol_); 
     385                        ar & make_nvp("descending", descending_); 
     386                        ar & make_nvp("sortCol", sortCol_); 
    651387                } 
    652388    } 
     
    698434                return NULL; 
    699435        } 
    700          
     436 
     437        static bool is_selected (const winstl::listview_sequence::sequence_value_type& v)  
     438        {  
     439                return (v.state() & LVIS_SELECTED) != 0;  
     440        } 
     441 
    701442protected:       
    702443        inline void* CustomItemConversion(LVCompareParam* param, int iSortCol) 
     
    727468        void vectorSizePreConditions() 
    728469        { 
    729 /*              if (listColumnWidth_.size() != names_.size()) 
    730                 { 
    731                         listColumnWidth_.clear(); 
    732                         listColumnWidth_.insert(listColumnWidth_.end(), names_.size(), 50);      
    733                 } 
    734                  
    735                 if (listColumnOrder_.size() != names_.size()) 
    736                 {                
    737                         listColumnOrder_.clear(); 
    738                         listColumnOrder_.insert(listColumnOrder_.end(), names_.size(), 0); 
    739                 } 
    740 */ 
    741         } 
    742          
    743         void syncTimeout() 
    744         { 
    745         //      hal::event().post(shared_ptr<hal::EventDetail> 
    746         //              (new hal::EventDebug(hal::Event::info, (wformat(L"Signaled")).str().c_str()))); 
    747                  
    748                 manager_.sync_list(true, true); 
    749470        } 
    750471         
     
    771492}; 
    772493 
     494template<> 
     495inline const std::wstring hal::to_wstr_shim<const winstl::listview_sequence::sequence_value_type> 
     496        (const winstl::listview_sequence::sequence_value_type& v) 
     497{ 
     498        return std::wstring(winstl::c_str_ptr(v)); 
     499} 
     500 
     501 
    773502namespace boost { 
    774503namespace serialization { 
    775 template <class TBase, typename adapterType, size_t N> 
    776 struct version< CHaliteSortListViewCtrl<TBase, adapterType, N> > 
     504template <class TBase, typename adapterType> 
     505struct version< CHaliteSortListViewCtrl<TBase, adapterType> > 
    777506{ 
    778507    typedef mpl::int_<2> type; 
  • trunk/src/NewTorrentDialog.hpp

    r438 r447  
    6262         
    6363        FilesListViewCtrl() : 
    64                 listClass(true,false,false), 
    6564                iniClass("listviews/new_files", "NewFilesListView") 
    6665        { 
  • trunk/src/NewTorrentPeersLV.hpp

    r431 r447  
    4646         
    4747        NewTorrent_PeersListViewCtrl() : 
    48                 listClass(true,false,false), 
    4948                iniClass("listviews/NewTorrentPeers", "NewPeersListView") 
    5049        { 
  • trunk/src/NewTorrentTrackerLV.hpp

    r431 r447  
    4545         
    4646        NewTorrent_TrackerListViewCtrl() : 
    47                 listClass(true,false,false), 
    4847                iniClass("listviews/NewTorrent", "NewTorrentListView") 
    4948        { 
  • trunk/src/advtabs/Debug.hpp

    r407 r447  
    9090 
    9191        LogListViewCtrl() : 
    92                 listClass(false, false, false), 
    9392                iniClass("listviews/eventLog", "LogListView") 
    9493        { 
  • trunk/src/advtabs/Files.cpp

    r423 r447  
    1717 
    1818FileListView::FileListView() : 
    19         iniClass("listviews/advFiles", "FileListView"), 
    20         listClass(true,false,false) 
     19        iniClass("listviews/advFiles", "FileListView") 
    2120{                                        
    2221        std::vector<wstring> names;      
  • trunk/src/advtabs/Peers.hpp

    r395 r447  
    7070 
    7171        thisClass() : 
    72                 iniClass("listviews/advPeers", "PeerListView"), 
    73                 listClass(true,false,false) 
     72                iniClass("listviews/advPeers", "PeerListView") 
    7473        {                                        
    7574                std::vector<wstring> names;      
  • trunk/src/advtabs/TrackerListView.hpp

    r425 r447  
    4343         
    4444        TrackerListViewCtrl(boost::filesystem::path location, std::string name) : 
    45                 listClass(true,false,false), 
    4645                iniClass(location, name) 
    4746        { 
  • trunk/src/halTorrent.cpp

    r441 r447  
    155155} 
    156156 
    157 bool operator!=(const lbt::dht_settings& lhs, const lbt::dht_settings& rhs) 
     157bool operator!=(const libt::dht_settings& lhs, const libt::dht_settings& rhs) 
    158158{ 
    159159        return lhs.max_peers_reply != rhs.max_peers_reply || 
     
    164164 
    165165template<typename Addr> 
    166 void write_range(fs::ofstream& ofs, const lbt::ip_range<Addr>& range) 
     166void write_range(fs::ofstream& ofs, const libt::ip_range<Addr>& range) 
    167167{  
    168168        const typename Addr::bytes_type first = range.first.to_bytes(); 
     
    173173 
    174174template<typename Addr> 
    175 void write_vec_range(fs::ofstream& ofs, const std::vector<lbt::ip_range<Addr> >& vec) 
     175void write_vec_range(fs::ofstream& ofs, const std::vector<libt::ip_range<Addr> >& vec) 
    176176{  
    177177        ofs << vec.size(); 
    178178         
    179         for (typename std::vector<lbt::ip_range<Addr> >::const_iterator i=vec.begin();  
     179        for (typename std::vector<libt::ip_range<Addr> >::const_iterator i=vec.begin();  
    180180                i != vec.end(); ++i) 
    181181        { 
     
    185185 
    186186template<typename Addr> 
    187 void read_range_to_filter(fs::ifstream& ifs, lbt::ip_filter& ip_filter) 
     187void read_range_to_filter(fs::ifstream& ifs, libt::ip_filter& ip_filter) 
    188188{  
    189189        typename Addr::bytes_type first; 
     
    193193         
    194194        ip_filter.add_rule(Addr(first), Addr(last), 
    195                 lbt::ip_filter::blocked); 
    196 } 
    197  
    198 static Event::eventLevel lbtAlertToHalEvent(lbt::alert::severity_t severity) 
     195                libt::ip_filter::blocked); 
     196} 
     197 
     198static Event::eventLevel lbtAlertToHalEvent(libt::alert::severity_t severity) 
    199199{ 
    200200        switch (severity) 
    201201        { 
    202         case lbt::alert::debug: 
     202        case libt::alert::debug: 
    203203                return Event::debug; 
    204204         
    205         case lbt::alert::info: 
     205        case libt::alert::info: 
    206206                return Event::info; 
    207207         
    208         case lbt::alert::warning: 
     208        case libt::alert::warning: 
    209209                return Event::warning; 
    210210         
    211         case lbt::alert::critical: 
    212         case lbt::alert::fatal: 
     211        case libt::alert::critical: 
     212        case libt::alert::fatal: 
    213213                return Event::critical; 
    214214         
     
    290290//                      boost::archive::binary_oarchive oba(ofs); 
    291291                         
    292                         lbt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();     
    293                          
    294                         std::vector<lbt::ip_range<asio::ip::address_v4> > v4(vectors.get<0>()); 
    295                         std::vector<lbt::ip_range<asio::ip::address_v6> > v6(vectors.get<1>()); 
     292                        libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();    
     293                         
     294                        std::vector<libt::ip_range<asio::ip::address_v4> > v4(vectors.get<0>()); 
     295                        std::vector<libt::ip_range<asio::ip::address_v6> > v6(vectors.get<1>()); 
    296296                         
    297297                        v4.erase(std::remove(v4.begin(), v4.end(), 0), v4.end()); 
     
    321321                { 
    322322                 
    323                 std::auto_ptr<lbt::alert> p_alert = theSession.pop_alert(); 
     323                std::auto_ptr<libt::alert> p_alert = theSession.pop_alert(); 
    324324                 
    325325                class AlertHandler 
     
    330330                {} 
    331331                 
    332                 void operator()(lbt::torrent_finished_alert const& a) const 
     332                void operator()(libt::torrent_finished_alert const& a) const 
    333333                { 
    334334                        event().post(shared_ptr<EventDetail>( 
     
    340340                } 
    341341                 
    342                 void operator()(lbt::torrent_paused_alert const& a) const 
     342                void operator()(libt::torrent_paused_alert const& a) const 
    343343                { 
    344344                        event().post(shared_ptr<EventDetail>( 
     
    350350                } 
    351351                 
    352                 void operator()(lbt::peer_error_alert const& a) const 
     352                void operator()(libt::peer_error_alert const& a) const 
    353353                { 
    354354                        event().post(shared_ptr<EventDetail>( 
     
    360360                } 
    361361                         
    362                 void operator()(lbt::peer_ban_alert const& a) const 
     362                void operator()(libt::peer_ban_alert const& a) const 
    363363                { 
    364364                        event().post(shared_ptr<EventDetail>( 
     
    370370                } 
    371371                         
    372                 void operator()(lbt::hash_failed_alert const& a) const 
     372                void operator()(libt::hash_failed_alert const& a) const 
    373373                { 
    374374                        event().post(shared_ptr<EventDetail>( 
     
    380380                } 
    381381                         
    382                 void operator()(lbt::url_seed_alert const& a) const 
     382                void operator()(libt::url_seed_alert const& a) const 
    383383                { 
    384384                        event().post(shared_ptr<EventDetail>( 
     
    391391                } 
    392392                 
    393                 void operator()(lbt::tracker_warning_alert const& a) const 
     393                void operator()(libt::tracker_warning_alert const& a) const 
    394394                { 
    395395                        event().post(shared_ptr<EventDetail>( 
     
    401401                } 
    402402                 
    403                 void operator()(lbt::tracker_announce_alert const& a) const 
     403                void operator()(libt::tracker_announce_alert const& a) const 
    404404                { 
    405405                        event().post(shared_ptr<EventDetail>( 
     
    409409                } 
    410410                 
    411                 void operator()(lbt::tracker_alert const& a) const 
     411                void operator()(libt::tracker_alert const& a) const 
    412412                { 
    413413                        event().post(shared_ptr<EventDetail>( 
     
    421421                } 
    422422                 
    423                 void operator()(lbt::tracker_reply_alert const& a) const 
     423                void operator()(libt::tracker_reply_alert const& a) const 
    424424                { 
    425425                        event().post(shared_ptr<EventDetail>( 
     
    432432                } 
    433433                 
    434                 void operator()(lbt::fastresume_rejected_alert const& a) const 
     434                void operator()(libt::fastresume_rejected_alert const& a) const 
    435435                { 
    436436                        event().post(shared_ptr<EventDetail>( 
     
    442442                } 
    443443                 
    444                 void operator()(lbt::piece_finished_alert const& a) const 
     444                void operator()(libt::piece_finished_alert const& a) const 
    445445                { 
    446446                        event().post(shared_ptr<EventDetail>( 
     
    452452                } 
    453453                 
    454                 void operator()(lbt::block_finished_alert const& a) const 
     454                void operator()(libt::block_finished_alert const& a) const 
    455455                { 
    456456                        event().post(shared_ptr<EventDetail>( 
     
    463463                } 
    464464                 
    465                 void operator()(lbt::block_downloading_alert const& a) const 
     465                void operator()(libt::block_downloading_alert const& a) const 
    466466                { 
    467467                        event().post(shared_ptr<EventDetail>( 
     
    474474                } 
    475475                 
    476                 void operator()(lbt::listen_failed_alert const& a) const 
     476                void operator()(libt::listen_failed_alert const& a) const 
    477477                { 
    478478                        if (a.endpoint.address().is_v6()) 
     
    493493                } 
    494494                 
    495                 void operator()(lbt::listen_succeeded_alert const& a) const 
     495                void operator()(libt::listen_succeeded_alert const& a) const 
    496496                { 
    497497                        event().post(shared_ptr<EventDetail>( 
     
    504504                } 
    505505                 
    506                 void operator()(lbt::peer_blocked_alert const& a) const 
     506                void operator()(libt::peer_blocked_alert const& a) const 
    507507                { 
    508508                        event().post(shared_ptr<EventDetail>( 
     
    514514                } 
    515515                 
    516                 void operator()(lbt::alert const& a) const 
     516                void operator()(libt::alert const& a) const 
    517517                { 
    518518                        event().post(shared_ptr<EventDetail>( 
     
    524524                        bit_impl& bit_impl_; 
    525525                         
    526                         torrent_internal_ptr get(lbt::torrent_handle h) const  
     526                        torrent_internal_ptr get(libt::torrent_handle h) const  
    527527                        {  
    528528                                return bit_impl_.theTorrents.get(from_utf8_safe(h.get_torrent_info().name()));  
     
    536536                        { 
    537537                         
    538                         lbt::handle_alert< 
    539                                 lbt::torrent_finished_alert, 
    540                                 lbt::torrent_paused_alert, 
    541                                 lbt::peer_error_alert, 
    542                                 lbt::peer_ban_alert, 
    543                                 lbt::hash_failed_alert, 
    544                                 lbt::url_seed_alert, 
    545                                 lbt::tracker_alert, 
    546                                 lbt::tracker_warning_alert, 
    547                                 lbt::tracker_announce_alert, 
    548                                 lbt::tracker_reply_alert, 
    549                                 lbt::fastresume_rejected_alert, 
    550                                 lbt::piece_finished_alert, 
    551                                 lbt::block_finished_alert, 
    552                                 lbt::block_downloading_alert, 
    553                                 lbt::listen_failed_alert, 
    554                                 lbt::listen_succeeded_alert, 
    555                                 lbt::peer_blocked_alert, 
    556                                 lbt::alert 
     538                        libt::handle_alert< 
     539                                libt::torrent_finished_alert, 
     540                                libt::torrent_paused_alert, 
     541                                libt::peer_error_alert, 
     542                                libt::peer_ban_alert, 
     543                                libt::hash_failed_alert, 
     544                                libt::url_seed_alert, 
     545                                libt::tracker_alert, 
     546                                libt::tracker_warning_alert, 
     547                                libt::tracker_announce_alert, 
     548                                libt::tracker_reply_alert, 
     549                                libt::fastresume_rejected_alert, 
     550                                libt::piece_finished_alert, 
     551                                libt::block_finished_alert, 
     552                                libt::block_downloading_alert, 
     553                                libt::listen_failed_alert, 
     554                                libt::listen_succeeded_alert, 
     555                                libt::peer_blocked_alert, 
     556                                libt::alert 
    557557                        >::handle_alert(p_alert, handler);                       
    558558                         
    559559                        } 
    560                         catch(lbt::unhandled_alert&) 
     560                        catch(libt::unhandled_alert&) 
    561561                        { 
    562562                                handler(*p_alert); 
     
    606606private: 
    607607        bit_impl() : 
    608                 theSession(lbt::fingerprint(HALITE_FINGERPRINT)), 
     608                theSession(libt::fingerprint(HALITE_FINGERPRINT)), 
    609609                timer_(io_), 
    610610                keepChecking_(false), 
     
    624624                torrent_internal::workingDir_ = workingDir(); 
    625625                 
    626                 theSession.set_severity_level(lbt::alert::debug);                
    627                 theSession.add_extension(&lbt::create_metadata_plugin); 
    628                 theSession.add_extension(&lbt::create_ut_pex_plugin); 
     626                theSession.set_severity_level(libt::alert::debug);               
     627                theSession.add_extension(&libt::create_metadata_plugin); 
     628                theSession.add_extension(&libt::create_ut_pex_plugin); 
    629629                theSession.set_max_half_open_connections(10); 
    630630                 
     
    649649                        TorrentMap torrents; 
    650650                        boost::archive::xml_wiarchive ia(ifs);   
    651                         ia >> slz::make_nvp("torrents", torrents); 
     651                        ia >> boost::serialization::make_nvp("torrents", torrents); 
    652652                         
    653653                        theTorrents = torrents; 
     
    679679                } 
    680680                 
    681                 {       lbt::session_settings settings = theSession.settings(); 
     681                {       libt::session_settings settings = theSession.settings(); 
    682682                        settings.user_agent = string("Halite ") + HALITE_VERSION_STRING; 
    683683                        theSession.set_settings(settings); 
     
    692692        try 
    693693        { 
    694                 boost::intrusive_ptr<lbt::torrent_info> t_info(new lbt::torrent_info); 
     694                boost::intrusive_ptr<libt::torrent_info> t_info(new libt::torrent_info); 
    695695 
    696696                int piece_size = 256 * 1024; 
     
    705705                } 
    706706 
    707                 lbt::file_pool f_pool; 
    708                  
    709                 scoped_ptr<lbt::storage_interface> store( 
    710                         lbt::default_storage_constructor(t_info, to_utf8(params.root_path.string()), 
     707                libt::file_pool f_pool; 
     708                 
     709                scoped_ptr<libt::storage_interface> store( 
     710                        libt::default_storage_constructor(t_info, to_utf8(params.root_path.string()), 
    711711                                f_pool)); 
    712712 
     
    743743                        store->read(&piece_buf[0], i, 0, t_info->piece_size(i)); 
    744744 
    745                         lbt::hasher h(&piece_buf[0], t_info->piece_size(i)); 
     745                        libt::hasher h(&piece_buf[0], t_info->piece_size(i)); 
    746746                        t_info->set_hash(i, h.final()); 
    747747 
     
    763763 
    764764                // create the torrent and print it to out 
    765                 lbt::entry e = t_info->create_torrent(); 
     765                libt::entry e = t_info->create_torrent(); 
    766766                halencode(out_file, e); 
    767767                } 
     
    775775        } 
    776776         
    777         std::pair<lbt::entry, lbt::entry> prepTorrent(wpath filename, wpath saveDirectory); 
     777        std::pair<libt::entry, libt::entry> prepTorrent(wpath filename, wpath saveDirectory); 
    778778        void removalThread(torrent_internal_ptr pIT, bool wipeFiles); 
    779779         
    780         lbt::session theSession; 
     780        libt::session theSession; 
    781781        asio::io_service io_; 
    782782        asio::deadline_timer timer_; 
     
    795795        bool ip_filter_loaded_; 
    796796        bool ip_filter_changed_; 
    797         lbt::ip_filter ip_filter_; 
     797        libt::ip_filter ip_filter_; 
    798798        size_t ip_filter_count_; 
    799799         
    800800        void ip_filter_count(); 
    801801        void ip_filter_load(progress_callback fn); 
    802         void ip_filter_import(std::vector<lbt::ip_range<asio::ip::address_v4> >& v4, 
    803                 std::vector<lbt::ip_range<asio::ip::address_v6> >& v6); 
     802        void ip_filter_import(std::vector<libt::ip_range<asio::ip::address_v4> >& v4, 
     803                std::vector<libt::ip_range<asio::ip::address_v6> >& v6); 
    804804         
    805805        bool dht_on_; 
    806         lbt::dht_settings dht_settings_; 
    807         lbt::entry dht_state_; 
     806        libt::dht_settings dht_settings_; 
     807        libt::entry dht_state_; 
    808808         
    809809}; 
     
    816816 
    817817#define HAL_GENERIC_TORRENT_EXCEPTION_CATCH(TORRENT, FUNCTION) \ 
    818 catch (const lbt::invalid_handle&) \ 
     818catch (const libt::invalid_handle&) \ 
    819819{\ 
    820820        event().post(shared_ptr<EventDetail>( \ 
     
    930930        int service_port, int max_fail_count) 
    931931{ 
    932         lbt::dht_settings settings; 
     932        libt::dht_settings settings; 
    933933        settings.max_peers_reply = max_peers_reply; 
    934934        settings.search_branching = search_branching; 
     
    953953                        pimpl->theSession.stop_natpmp(); 
    954954 
    955                         pimpl->signals.successful_listen.connect_once(bind(&lbt::session::start_upnp, &pimpl->theSession)); 
     955                        pimpl->signals.successful_listen.connect_once(bind(&libt::session::start_upnp, &pimpl->theSession)); 
    956956                } 
    957957                else 
     
    961961                        pimpl->theSession.stop_natpmp(); 
    962962 
    963                         pimpl->signals.successful_listen.connect_once(bind(&lbt::session::start_natpmp, &pimpl->theSession)); 
     963                        pimpl->signals.successful_listen.connect_once(bind(&libt::session::start_natpmp, &pimpl->theSession)); 
    964964                } 
    965965        } 
     
    974974void bit::setTimeouts(int peers, int tracker) 
    975975{ 
    976         lbt::session_settings settings = pimpl->theSession.settings(); 
     976        libt::session_settings settings = pimpl->theSession.settings(); 
    977977        settings.peer_connect_timeout = peers; 
    978978        settings.tracker_completion_timeout = tracker; 
     
    10081008void bit_impl::ip_filter_count() 
    10091009{ 
    1010         lbt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter(); 
     1010        libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter(); 
    10111011         
    10121012        vectors.get<0>().erase(std::remove(vectors.get<0>().begin(), vectors.get<0>().end(), 0), 
     
    10421042} 
    10431043 
    1044 void  bit_impl::ip_filter_import(std::vector<lbt::ip_range<asio::ip::address_v4> >& v4, 
    1045         std::vector<lbt::ip_range<asio::ip::address_v6> >& v6) 
    1046 { 
    1047         for(std::vector<lbt::ip_range<asio::ip::address_v4> >::iterator i=v4.begin(); 
     1044void  bit_impl::ip_filter_import(std::vector<libt::ip_range<asio::ip::address_v4> >& v4, 
     1045        std::vector<libt::ip_range<asio::ip::address_v6> >& v6) 
     1046{ 
     1047        for(std::vector<libt::ip_range<asio::ip::address_v4> >::iterator i=v4.begin(); 
    10481048                i != v4.end(); ++i) 
    10491049        { 
    1050                 ip_filter_.add_rule(i->first, i->last, lbt::ip_filter::blocked); 
    1051         } 
    1052 /*      for(std::vector<lbt::ip_range<asio::ip::address_v6> >::iterator i=v6.begin(); 
     1050                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked); 
     1051        } 
     1052/*      for(std::vector<libt::ip_range<asio::ip::address_v6> >::iterator i=v6.begin(); 
    10531053                i != v6.end(); ++i) 
    10541054        { 
    1055                 ip_filter_.add_rule(i->first, i->last, lbt::ip_filter::blocked); 
     1055                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked); 
    10561056        } 
    10571057*/       
     
    10931093void bit::ensureIpFilterOff() 
    10941094{ 
    1095         pimpl->theSession.set_ip_filter(lbt::ip_filter()); 
     1095        pimpl->theSession.set_ip_filter(libt::ip_filter()); 
    10961096        pimpl->ip_filter_on_ = false; 
    10971097         
     
    11021102void bit::ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4) 
    11031103{ 
    1104         lbt::pe_settings pe; 
     1104        libt::pe_settings pe; 
    11051105         
    11061106        switch (enc_level) 
    11071107        { 
    11081108                case 0: 
    1109                         pe.allowed_enc_level = lbt::pe_settings::plaintext; 
     1109                        pe.allowed_enc_level = libt::pe_settings::plaintext; 
    11101110                        break; 
    11111111                case 1: 
    1112                         pe.allowed_enc_level = lbt::pe_settings::rc4; 
     1112                        pe.allowed_enc_level = libt::pe_settings::rc4; 
    11131113                        break; 
    11141114                case 2: 
    1115                         pe.allowed_enc_level = lbt::pe_settings::both; 
     1115                        pe.allowed_enc_level = libt::pe_settings::both; 
    11161116                        break; 
    11171117                default: 
    1118                         pe.allowed_enc_level = lbt::pe_settings::both; 
     1118                        pe.allowed_enc_level = libt::pe_settings::both; 
    11191119                         
    11201120                        hal::event().post(shared_ptr<hal::EventDetail>( 
     
    11261126        { 
    11271127                case 0: 
    1128                         pe.in_enc_policy = lbt::pe_settings::forced; 
     1128                        pe.in_enc_policy = libt::pe_settings::forced; 
    11291129                        break; 
    11301130                case 1: 
    1131                         pe.in_enc_policy = lbt::pe_settings::enabled; 
     1131                        pe.in_enc_policy = libt::pe_settings::enabled; 
    11321132                        break; 
    11331133                case 2: 
    1134                         pe.in_enc_policy = lbt::pe_settings::disabled; 
     1134                        pe.in_enc_policy = libt::pe_settings::disabled; 
    11351135                        break; 
    11361136                default: 
    1137                         pe.in_enc_policy = lbt::pe_settings::enabled; 
     1137                        pe.in_enc_policy = libt::pe_settings::enabled; 
    11381138                         
    11391139                        hal::event().post(shared_ptr<hal::EventDetail>( 
     
    11451145        { 
    11461146                case 0: 
    1147                         pe.out_enc_policy = lbt::pe_settings::forced; 
     1147                        pe.out_enc_policy = libt::pe_settings::forced; 
    11481148                        break; 
    11491149                case 1: 
    1150                         pe.out_enc_policy = lbt::pe_settings::enabled; 
     1150                        pe.out_enc_policy = libt::pe_settings::enabled; 
    11511151                        break; 
    11521152                case 2: 
    1153                         pe.out_enc_policy = lbt::pe_settings::disabled; 
     1153                        pe.out_enc_policy = libt::pe_settings::disabled; 
    11541154                        break; 
    11551155                default: 
    1156                         pe.out_enc_policy = lbt::pe_settings::enabled; 
     1156                        pe.out_enc_policy = libt::pe_settings::enabled; 
    11571157                         
    11581158                        hal::event().post(shared_ptr<hal::EventDetail>( 
     
    11821182void bit::ensurePeOff() 
    11831183{ 
    1184         lbt::pe_settings pe; 
    1185         pe.out_enc_policy = lbt::pe_settings::disabled; 
    1186         pe.in_enc_policy = lbt::pe_settings::disabled; 
    1187          
    1188         pe.allowed_enc_level = lbt::pe_settings::both; 
     1184        libt::pe_settings pe; 
     1185        pe.out_enc_policy = libt::pe_settings::disabled; 
     1186        pe.in_enc_policy = libt::pe_settings::disabled; 
     1187         
     1188        pe.allowed_enc_level = libt::pe_settings::both; 
    11891189        pe.prefer_rc4 = true; 
    11901190         
     
    11971197void bit::ip_v4_filter_block(asio::ip::address_v4 first, asio::ip::address_v4 last) 
    11981198{ 
    1199         pimpl->ip_filter_.add_rule(first, last, lbt::ip_filter::blocked); 
     1199        pimpl->ip_filter_.add_rule(first, last, libt::ip_filter::blocked); 
    12001200        pimpl->ip_filter_count(); 
    12011201        pimpl->ip_filter_changed_ = true; 
     
    12041204void bit::ip_v6_filter_block(asio::ip::address_v6 first, asio::ip::address_v6 last) 
    12051205{ 
    1206         pimpl->ip_filter_.add_rule(first, last, lbt::ip_filter::blocked); 
     1206        pimpl->ip_filter_.add_rule(first, last, libt::ip_filter::blocked); 
    12071207        pimpl->ip_filter_count(); 
    12081208        pimpl->ip_filter_changed_ = true; 
     
    12161216void bit::clearIpFilter() 
    12171217{ 
    1218         pimpl->ip_filter_ = lbt::ip_filter(); 
    1219         pimpl->theSession.set_ip_filter(lbt::ip_filter());       
     1218        pimpl->ip_filter_ = libt::ip_filter(); 
     1219        pimpl->theSession.set_ip_filter(libt::ip_filter());      
    12201220        pimpl->ip_filter_changed_ = true; 
    12211221        pimpl->ip_filter_count(); 
     
    12781278                                {                        
    12791279                                pimpl->ip_filter_.add_rule(asio::ip::address_v4::from_string(first), 
    1280                                         asio::ip::address_v4::from_string(last), lbt::ip_filter::blocked);       
     1280                                        asio::ip::address_v4::from_string(last), libt::ip_filter::blocked);      
    12811281                                } 
    12821282                                catch(...) 
     
    13091309        details.port = pimpl->theSession.is_listening() ? pimpl->theSession.listen_port() : -1; 
    13101310         
    1311         lbt::session_status status = pimpl->theSession.status(); 
     1311        libt::session_status status = pimpl->theSession.status(); 
    13121312         
    13131313        details.speed = std::pair<double, double>(status.download_rate, status.upload_rate); 
     
    13461346} 
    13471347 
    1348 std::pair<lbt::entry, lbt::entry> bit_impl::prepTorrent(wpath filename, wpath saveDirectory) 
    1349 { 
    1350         lbt::entry metadata = haldecode(filename); 
    1351         lbt::torrent_info info(metadata); 
     1348std::pair<libt::entry, libt::entry> bit_impl::prepTorrent(wpath filename, wpath saveDirectory) 
     1349{ 
     1350        libt::entry metadata = haldecode(filename); 
     1351        libt::torrent_info info(metadata); 
    13521352         
    13531353        wstring torrentName = hal::from_utf8_safe(info.name()); 
     
    13651365        //  ^^^ Handle old naming style!         
    13661366         
    1367         lbt::entry resumeData;   
     1367        libt::entry resumeData;  
    13681368         
    13691369        if (fs::exists(resumeFile))  
     
    14391439                 
    14401440                if (!startStopped)  
    1441                         me->addToSession(); 
     1441                        me->add_to_session(); 
    14421442                else 
    14431443                        me->set_state_stopped(); 
     
    14471447} 
    14481448 
    1449 void add_files(lbt::torrent_info& t, fs::path const& p, fs::path const& l) 
     1449void add_files(libt::torrent_info& t, fs::path const& p, fs::path const& l) 
    14501450{ 
    14511451/*      fs::path f(p / l); 
     
    14581458        { 
    14591459        //      std::cerr << "adding \"" << l.string() << "\"\n"; 
    1460                 lbt::file fi(f, lbt::file::in); 
    1461                 fi.seek(0, lbt::file::end); 
     1460                libt::file fi(f, libt::file::in); 
     1461                fi.seek(0, libt::file::end); 
    14621462                libtorrent::size_type size = fi.tell(); 
    14631463                t.add_file(l, size); 
     
    14821482        t.set_piece_size(piece_size); 
    14831483 
    1484         lbt::storage st(t, full_path.branch_path()); 
     1484        libt::storage st(t, full_path.branch_path()); 
    14851485        t.add_tracker("http://www.nitcom.com.au/announce.php"); 
    14861486        t.set_priv(false); 
     
    15011501 
    15021502        // create the torrent and print it to out 
    1503         lbt::entry e = t.create_torrent(); 
    1504         lbt::bencode(std::ostream_iterator<char>(out), e); 
     1503        libt::entry e = t.create_torrent(); 
     1504        libt::bencode(std::ostream_iterator<char>(out), e); 
    15051505        } 
    15061506        catch (std::exception& e) 
     
    15691569                                        break; 
    15701570                                case TorrentDetail::torrent_paused: 
    1571                                         (*i).torrent->addToSession(true); 
     1571                                        (*i).torrent->add_to_session(true); 
    15721572                                        break; 
    15731573                                case TorrentDetail::torrent_active: 
    1574                                         (*i).torrent->addToSession(false); 
     1574                                        (*i).torrent->add_to_session(false); 
    15751575                                        break; 
    15761576                                default: 
     
    15811581                         
    15821582                        } 
    1583                         catch(const lbt::duplicate_torrent&) 
     1583                        catch(const libt::duplicate_torrent&) 
    15841584                        { 
    15851585                                hal::event().post(shared_ptr<hal::EventDetail>( 
     
    16451645                if ((*i).torrent->in_session()) 
    16461646                { 
    1647                         (*i).torrent->removeFromSession(); 
    1648                         (*i).torrent->writeResumeData(); 
     1647                        (*i).torrent->remove_from_session(); 
     1648                        (*i).torrent->write_resume_data(); 
    16491649                } 
    16501650        } 
     
    16551655} 
    16561656 
    1657 PeerDetail::PeerDetail(lbt::peer_info& peerInfo) : 
     1657PeerDetail::PeerDetail(libt::peer_info& peerInfo) : 
    16581658        ipAddress(hal::from_utf8_safe(peerInfo.ip.address().to_string())), 
    16591659        country(L""), 
     
    16681668#endif   
    16691669 
    1670         if (peerInfo.flags & lbt::peer_info::handshake) 
     1670        if (peerInfo.flags & libt::peer_info::handshake) 
    16711671        { 
    16721672                status_vec.push_back(app().res_wstr(HAL_PEER_HANDSHAKE)); 
    16731673        }                
    1674         else if (peerInfo.flags & lbt::peer_info::connecting) 
     1674        else if (peerInfo.flags & libt::peer_info::connecting) 
    16751675        { 
    16761676                status_vec.push_back(app().res_wstr(HAL_PEER_CONNECTING)); 
     
    16791679        { 
    16801680        #ifndef TORRENT_DISABLE_ENCRYPTION               
    1681                 if (peerInfo.flags & lbt::peer_info::rc4_encrypted) 
     1681                if (peerInfo.flags & libt::peer_info::rc4_encrypted) 
    16821682                        status_vec.push_back(app().res_wstr(HAL_PEER_RC4_ENCRYPTED));            
    1683                 if (peerInfo.flags & lbt::peer_info::plaintext_encrypted) 
     1683                if (peerInfo.flags & libt::peer_info::plaintext_encrypted) 
    16841684                        status_vec.push_back(app().res_wstr(HAL_PEER_PLAINTEXT_ENCRYPTED)); 
    16851685        #endif 
    16861686                 
    1687                 if (peerInfo.flags & lbt::peer_info::interesting) 
     1687                if (peerInfo.flags & libt::peer_info::interesting) 
    16881688                        status_vec.push_back(app().res_wstr(HAL_PEER_INTERESTING));      
    1689                 if (peerInfo.flags & lbt::peer_info::choked) 
     1689                if (peerInfo.flags & libt::peer_info::choked) 
    16901690                        status_vec.push_back(app().res_wstr(HAL_PEER_CHOKED));   
    1691                 if (peerInfo.flags & lbt::peer_info::remote_interested) 
     1691                if (peerInfo.flags & libt::peer_info::remote_interested) 
    16921692                        status_vec.push_back(app().res_wstr(HAL_PEER_REMOTE_INTERESTING));       
    1693                 if (peerInfo.flags & lbt::peer_info::remote_choked) 
     1693                if (peerInfo.flags & libt::peer_info::remote_choked) 
    16941694                        status_vec.push_back(app().res_wstr(HAL_PEER_REMOTE_CHOKED));    
    1695                 if (peerInfo.flags & lbt::peer_info::supports_extensions) 
     1695                if (peerInfo.flags & libt::peer_info::supports_extensions) 
    16961696                        status_vec.push_back(app().res_wstr(HAL_PEER_SUPPORT_EXTENSIONS));       
    1697         //      if (peerInfo.flags & lbt::peer_info::local_connection)                                          // Not sure whats up here? 
     1697        //      if (peerInfo.flags & libt::peer_info::local_connection)                                         // Not sure whats up here? 
    16981698        //              status_vec.push_back(app().res_wstr(HAL_PEER_LOCAL_CONNECTION));                         
    1699                 if (peerInfo.flags & lbt::peer_info::queued) 
     1699                if (peerInfo.flags & libt::peer_info::queued) 
    17001700                        status_vec.push_back(app().res_wstr(HAL_PEER_QUEUED)); 
    17011701        } 
    17021702         
    1703         seed = (peerInfo.flags & lbt::peer_info::seed) ? true : false; 
     1703        seed = (peerInfo.flags & libt::peer_info::seed) ? true : false; 
    17041704         
    17051705        if (!status_vec.empty()) status = status_vec[0]; 
     
    18731873                if (pIT->in_session()) 
    18741874                { 
    1875                         theSession.remove_torrent(pIT->handle(), lbt::session::delete_files); 
     1875                        theSession.remove_torrent(pIT->handle(), libt::session::delete_files); 
    18761876                } 
    18771877                else 
    18781878                { 
    1879                         lbt::torrent_info m_info = pIT->infoMemory(); 
     1879                        libt::torrent_info m_info = pIT->infoMemory(); 
    18801880                         
    18811881                        // delete the files from disk 
     
    18831883                        std::set<std::string> directories; 
    18841884                         
    1885                         for (lbt::torrent_info::file_iterator i = m_info.begin_files(true) 
     1885                        for (libt::torrent_info::file_iterator i = m_info.begin_files(true) 
    18861886                                , end(m_info.end_files(true)); i != end; ++i) 
    18871887                        { 
     
    19251925         
    19261926        torrent_internal_ptr pTI = pimpl->theTorrents.get(filename); 
    1927         lbt::torrent_handle handle = pTI->handle(); 
     1927        libt::torrent_handle handle = pTI->handle(); 
    19281928        pimpl->theTorrents.erase(filename); 
    19291929         
     
    19421942        try { 
    19431943         
    1944         pimpl->theTorrents.get(filename)->forceRecheck(); 
     1944        pimpl->theTorrents.get(filename)->force_recheck(); 
    19451945         
    19461946        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheckTorrent") 
     
    19571957         
    19581958        torrent_internal_ptr pTI = pimpl->theTorrents.get(filename); 
    1959         lbt::torrent_handle handle = pTI->handle(); 
     1959        libt::torrent_handle handle = pTI->handle(); 
    19601960        pimpl->theTorrents.erase(filename); 
    19611961         
  • trunk/src/halTorrentInternal.hpp

    r445 r447  
    9999{ 
    100100 
    101 namespace lbt = libtorrent; 
    102  
    103 lbt::entry haldecode(const wpath &file)  
     101namespace libt = libtorrent; 
     102 
     103libt::entry haldecode(const wpath &file)  
    104104{ 
    105105        fs::ifstream ifs(file, fs::ifstream::binary); 
     
    107107        { 
    108108                ifs.unsetf(fs::ifstream::skipws); 
    109                 return lbt::bdecode(std::istream_iterator<char>(ifs), std::istream_iterator<char>()); 
    110         } 
    111         else return lbt::entry(); 
     109                return libt::bdecode(std::istream_iterator<char>(ifs), std::istream_iterator<char>()); 
     110        } 
     111        else return libt::entry(); 
    112112} 
    113113 
    114 bool halencode(const wpath &file, const lbt::entry &e)  
     114bool halencode(const wpath &file, const libt::entry &e)  
    115115{ 
    116116        fs::ofstream ofs(file, fs::ofstream::binary); 
     
    119119                return false; 
    120120         
    121         lbt::bencode(std::ostream_iterator<char>(ofs), e); 
     121        libt::bencode(std::ostream_iterator<char>(ofs), e); 
    122122        return true; 
    123123} 
     
    137137        if (fs::exists(file))  
    138138        {        
    139                 lbt::torrent_info info(haldecode(file)); 
     139                libt::torrent_info info(haldecode(file)); 
    140140 
    141141                std::string name = info.name();  
     
    173173         
    174174template<typename T> 
    175 class TransferTracker 
     175class transfer_tracker 
    176176{ 
    177177public: 
    178         TransferTracker() : 
     178        transfer_tracker() : 
    179179                total_(0), 
    180180                total_offset_(0) 
    181181        {} 
    182182         
    183         TransferTracker(T total) : 
     183        transfer_tracker(T total) : 
    184184                total_(total), 
    185185                total_offset_(0) 
    186186        {} 
    187187         
    188         TransferTracker(T total, T offset) : 
     188        transfer_tracker(T total, T offset) : 
    189189                total_(total), 
    190190                total_offset_(offset) 
     
    216216        void serialize(Archive& ar, const unsigned int version) 
    217217        { 
    218                 ar & slz::make_nvp("total", total_); 
     218                ar & boost::serialization::make_nvp("total", total_); 
    219219        } 
    220220         
     
    224224}; 
    225225 
    226 class DurationTracker 
     226class duration_tracker 
    227227{ 
    228228public: 
    229         DurationTracker() : 
     229        duration_tracker() : 
    230230                total_(boost::posix_time::time_duration(0,0,0,0),  
    231231                        boost::posix_time::time_duration(0,0,0,0)) 
     
    253253        void serialize(Archive& ar, const unsigned int version) 
    254254        { 
    255                 ar & slz::make_nvp("total", total_); 
     255                ar & boost::serialization::make_nvp("total", total_); 
    256256        } 
    257257         
     
    259259         
    260260private: 
    261         TransferTracker<boost::posix_time::time_duration> total_;        
     261        transfer_tracker<boost::posix_time::time_duration> total_;       
    262262        mutable boost::posix_time::ptime start_;                 
    263263}; 
     
    270270    void serialize(Archive& ar, const unsigned int version) 
    271271    { 
    272         ar & slz::make_nvp("transferLimit", transferLimit_); 
    273         ar & slz::make_nvp("connections", connections_); 
    274         ar & slz::make_nvp("uploads", uploads_);         
     272                using boost::serialization::make_nvp; 
     273 
     274        ar & make_nvp("transferLimit", transferLimit_); 
     275        ar & make_nvp("connections", connections_); 
     276        ar & make_nvp("uploads", uploads_);      
    275277                 
    276278                if (version > 6) { 
    277                         ar & slz::make_nvp("filename", filename_); 
     279                        ar & make_nvp("filename", filename_); 
    278280                } 
    279281                else  
    280282                { 
    281283                        wstring originalFilename; 
    282                         ar & slz::make_nvp("filename", originalFilename); 
     284                        ar & make_nvp("filename", originalFilename); 
    283285                         
    284286                        updatePreVersion7Files(originalFilename); 
    285287                } 
    286288                 
    287         ar & slz::make_nvp("saveDirectory", save_directory_); 
     289        ar & make_nvp("saveDirectory", save_directory_); 
    288290                 
    289291                if (version > 7) { 
    290                         ar & slz::make_nvp("payloadUploaded_", payloadUploaded_); 
    291                         ar & slz::make_nvp("payloadDownloaded_", payloadDownloaded_); 
    292                         ar & slz::make_nvp("uploaded_", uploaded_); 
    293                         ar & slz::make_nvp("downloaded_", downloaded_);  
    294                         ar & slz::make_nvp("ratio", ratio_);     
     292                        ar & make_nvp("payloadUploaded_", payloadUploaded_); 
     293                        ar & make_nvp("payloadDownloaded_", payloadDownloaded_); 
     294                        ar & make_nvp("uploaded_", uploaded_); 
     295                        ar & make_nvp("downloaded_", downloaded_);       
     296                        ar & make_nvp("ratio", ratio_);  
    295297                }  
    296298                else if (version > 3) { 
    297                         ar & slz::make_nvp("payloadUploaded_", payloadUploaded_); 
    298                         ar & slz::make_nvp("payloadDownloaded_", payloadDownloaded_); 
    299                         ar & slz::make_nvp("uploaded_", uploaded_); 
    300                         ar & slz::make_nvp("downloaded_", downloaded_);          
     299                        ar & make_nvp("payloadUploaded_", payloadUploaded_); 
     300                        ar & make_nvp("payloadDownloaded_", payloadDownloaded_); 
     301                        ar & make_nvp("uploaded_", uploaded_); 
     302                        ar & make_nvp("downloaded_", downloaded_);               
    301303                }  
    302304                else if (version > 1) 
    303305                { 
    304                         ar & slz::make_nvp("totalUploaded", totalUploaded_); 
    305                         ar & slz::make_nvp("ratio", ratio_); 
     306                        ar & make_nvp("totalUploaded", totalUploaded_); 
     307                        ar & make_nvp("ratio", ratio_); 
    306308                         
    307309                        payloadUploaded_.reset(totalUploaded_); 
     
    309311                 
    310312                if (version > 0) { 
    311                         ar & slz::make_nvp("trackerUsername", trackerUsername_); 
    312                         ar & slz::make_nvp("trackerPassword", trackerPassword_); 
     313                        ar & make_nvp("trackerUsername", trackerUsername_); 
     314                        ar & make_nvp("trackerPassword", trackerPassword_); 
    313315                } 
    314316                if (version > 1) { 
    315                         ar & slz::make_nvp("state", state_); 
    316                         ar & slz::make_nvp("trackers", trackers_); 
     317                        ar & make_nvp("state", state_); 
     318                        ar & make_nvp("trackers", trackers_); 
    317319                } 
    318320         
    319321                if (version > 2) { 
    320                         ar & slz::make_nvp("resolve_countries", resolve_countries_); 
     322                        ar & make_nvp("resolve_countries", resolve_countries_); 
    321323                } 
    322324                if (version > 4) { 
    323                         ar & slz::make_nvp("file_priorities", filePriorities_); 
     325                        ar & make_nvp("file_priorities", filePriorities_); 
    324326                } 
    325327                if (version > 5) { 
    326                         ar & slz::make_nvp("startTime", startTime_); 
    327                         ar & slz::make_nvp("activeDuration", activeDuration_); 
    328                         ar & slz::make_nvp("seedingDuration", seedingDuration_); 
     328                        ar & make_nvp("startTime", startTime_); 
     329                        ar & make_nvp("activeDuration", activeDuration_); 
     330                        ar & make_nvp("seedingDuration", seedingDuration_); 
    329331                } 
    330332                if (version > 6) { 
    331                         ar & slz::make_nvp("name", name_); 
    332                         ar & slz::make_nvp("compactStorage", compactStorage_); 
    333                         ar & slz::make_nvp("finishTime", finishTime_); 
     333                        ar & make_nvp("name", name_); 
     334                        ar & make_nvp("compactStorage", compactStorage_); 
     335                        ar & make_nvp("finishTime", finishTime_); 
    334336                } 
    335337                if (version > 8) { 
    336                         ar & slz::make_nvp("progress", progress_); 
     338                        ar & make_nvp("progress", progress_); 
    337339                } 
    338340    } 
    339341         
    340         void extractNames(lbt::entry& metadata) 
     342        void extractNames(libt::entry& metadata) 
    341343        {                
    342                 lbt::torrent_info info(metadata);                                
     344                libt::torrent_info info(metadata);                               
    343345                name_ = hal::from_utf8_safe(info.name()); 
    344346                 
     
    392394        wstring save_directory_; 
    393395        wstring originalFilename_; 
    394         lbt::torrent_handle handle_;     
    395          
    396         lbt::entry metadata_; 
    397         lbt::entry resumedata_; 
     396        libt::torrent_handle handle_;    
     397         
     398        libt::entry metadata_; 
     399        libt::entry resumedata_; 
    398400         
    399401        wstring trackerUsername_;        
     
    403405        boost::int64_t totalBase_; 
    404406         
    405         TransferTracker<boost::int64_t> payloadUploaded_; 
    406         TransferTracker<boost::int64_t> payloadDownloaded_; 
    407         TransferTracker<boost::int64_t> uploaded_; 
    408         TransferTracker<boost::int64_t> downloaded_; 
     407        transfer_tracker<boost::int64_t> payloadUploaded_; 
     408        transfer_tracker<boost::int64_t> payloadDownloaded_; 
     409        transfer_tracker<boost::int64_t> uploaded_; 
     410        transfer_tracker<boost::int64_t> downloaded_; 
    409411         
    410412        boost::posix_time::ptime startTime_; 
    411413        boost::posix_time::ptime finishTime_; 
    412         DurationTracker activeDuration_; 
    413         DurationTracker seedingDuration_; 
     414        duration_tracker activeDuration_; 
     415        duration_tracker seedingDuration_; 
    414416         
    415417        std::vector<tracker_detail> trackers_; 
    416         std::vector<lbt::announce_entry> torrent_trackers_; 
    417         std::vector<lbt::peer_info> peers_;      
     418        std::vector<libt::announce_entry> torrent_trackers_; 
     419        std::vector<libt::peer_info> peers_;     
    418420        std::vector<int> filePriorities_; 
    419421         
    420422        float progress_; 
    421423         
    422         lbt::torrent_info infoMemory_; 
    423         lbt::torrent_status statusMemory_; 
     424        libt::torrent_info infoMemory_; 
     425        libt::torrent_status statusMemory_; 
    424426        FileDetails fileDetailsMemory_; 
    425427         
     
    461463    void serialize(Archive& ar, const unsigned int version) 
    462464    { 
    463                 ar & slz::make_nvp("torrent", torrent); 
    464                 ar & slz::make_nvp("save_time", save_time); 
     465                ar & boost::serialization::make_nvp("torrent", torrent); 
     466                ar & boost::serialization::make_nvp("save_time", save_time); 
    465467    } 
    466468}; 
     
    564566        } 
    565567         
    566         void addToSession(bool paused = false) 
     568        void add_to_session(bool paused = false) 
    567569        { 
    568570                try 
     
    572574                assert(the_session_ != 0); 
    573575 
    574                 HAL_DEV_MSG(wformat(L"addToSession() paused=%1%") % paused); 
     576                HAL_DEV_MSG(wformat(L"add_to_session() paused=%1%") % paused); 
    575577                 
    576578                if (!in_session())  
     
    578580                        path dir = path_to_utf8(save_directory_); 
    579581                         
    580                         lbt::storage_mode_t storage = lbt::storage_mode_sparse; 
     582                        libt::storage_mode_t storage = libt::storage_mode_sparse; 
    581583                         
    582584                        if (compactStorage_) 
    583                                 storage = lbt::storage_mode_compact; 
     585                                storage = libt::storage_mode_compact; 
    584586                         
    585587                        handle_ = the_session_->add_torrent(metadata_, dir, resumedata_, storage, paused);                       
    586588                        assert(handle_.is_valid()); 
    587589                         
    588                         clearResumeData(); 
     590                        clear_resume_data(); 
    589591                         
    590592                        in_session_ = true; 
     
    609611        } 
    610612         
    611         void removeFromSession(bool writeData=true) 
     613        void remove_from_session(bool writeData=true) 
    612614        { 
    613615                try 
     
    617619                assert(in_session()); 
    618620 
    619                 HAL_DEV_MSG(wformat(L"removeFromSession() writeData=%1%") % writeData); 
     621                HAL_DEV_MSG(wformat(L"remove_from_session() writeData=%1%") % writeData); 
    620622                 
    621623                if (writeData) 
     
    624626                        resumedata_ = handle_.write_resume_data(); // Update the fast-resume data 
    625627                        HAL_DEV_MSG(L"writing resume data"); 
    626                         writeResumeData(); 
     628                        write_resume_data(); 
    627629 
    628630                        torrent_standalone tsa(shared_from_this()); 
     
    658660                if (state_ == TorrentDetail::torrent_stopped) 
    659661                {        
    660                         addToSession(false); 
     662                        add_to_session(false); 
    661663                        assert(in_session());                    
    662664                } 
     
    677679                if (state_ == TorrentDetail::torrent_stopped) 
    678680                {        
    679                         addToSession(true); 
     681                        add_to_session(true); 
    680682 
    681683                        assert(in_session()); 
     
    712714                        else if (state_ == TorrentDetail::torrent_paused) 
    713715                        {                        
    714                                 removeFromSession(); 
     716                                remove_from_session(); 
    715717                                state_ = TorrentDetail::torrent_stopped;                                 
    716718                        } 
     
    723725        } 
    724726 
    725         void forceRecheck() 
     727        void force_recheck() 
    726728        { 
    727729                mutex_t::scoped_lock l(mutex_);          
    728                 HAL_DEV_MSG(L"forceRecheck()"); 
     730                HAL_DEV_MSG(L"force_recheck()"); 
    729731 
    730732                switch (state_) 
    731733                { 
    732734                case TorrentDetail::torrent_stopped: 
    733                         clearResumeData(); 
     735                        clear_resume_data(); 
    734736                        resume(); 
    735737                        break; 
     
    751753        } 
    752754         
    753         void writeResumeData() 
     755        void write_resume_data() 
    754756        {                                        
    755                 HAL_DEV_MSG(L"writeResumeData()"); 
     757                HAL_DEV_MSG(L"write_resume_data()"); 
    756758                wpath resumeDir = workingDir_/L"resume"; 
    757759                 
     
    764766        } 
    765767         
    766         void clearResumeData() 
     768        void clear_resume_data() 
    767769        { 
    768770                wpath resumeFile = workingDir_/L"resume"/filename_; 
     
    771773                        remove(resumeFile); 
    772774 
    773                 resumedata_ = lbt::entry(); 
     775                resumedata_ = libt::entry(); 
    774776        } 
    775777 
     
    818820                if (in_session()) 
    819821                { 
    820                         lbt::torrent_status::state_t s = handle_.status().state; 
    821  
    822                         return (s == lbt::torrent_status::seeding || 
    823                                                 s == lbt::torrent_status::finished); 
     822                        libt::torrent_status::state_t s = handle_.status().state; 
     823 
     824                        return (s == libt::torrent_status::seeding || 
     825                                                s == libt::torrent_status::finished); 
    824826                } 
    825827                else return false; 
     
    863865        const wstring& originalFilename() const { return originalFilename_; } 
    864866         
    865         const lbt::torrent_handle& handle() const { return handle_; } 
     867        const libt::torrent_handle& handle() const { return handle_; } 
    866868 
    867869        void resetTrackers() 
     
    886888                if (trackers_.empty()) 
    887889                { 
    888                         std::vector<lbt::announce_entry> trackers = infoMemory_.trackers(); 
    889                          
    890                         foreach (const lbt::announce_entry& entry, trackers) 
     890                        std::vector<libt::announce_entry> trackers = infoMemory_.trackers(); 
     891                         
     892                        foreach (const libt::announce_entry& entry, trackers) 
    891893                        { 
    892894                                trackers_.push_back( 
     
    914916    void serialize(Archive& ar, const unsigned int version) 
    915917    { 
     918                using boost::serialization::make_nvp; 
     919 
    916920                if (version > 1) { 
    917                         ar & slz::make_nvp("transfer_limits", transferLimit_); 
    918                         ar & slz::make_nvp("connection_limits", connections_); 
    919                         ar & slz::make_nvp("upload_limits", uploads_);   
    920  
    921                         ar & slz::make_nvp("name", name_); 
    922                         ar & slz::make_nvp("filename", filename_);       
    923  
    924                         ar & slz::make_nvp("ratio", ratio_);     
    925                         ar & slz::make_nvp("progress", progress_); 
    926                         ar & slz::make_nvp("state", state_); 
    927                         ar & slz::make_nvp("compact_storage", compactStorage_);  
    928                         ar & slz::make_nvp("resolve_countries", resolve_countries_);     
    929  
    930                         ar & slz::make_nvp("tracker_username", trackerUsername_); 
    931                         ar & slz::make_nvp("tracker_password", trackerPassword_); 
    932                         ar & slz::make_nvp("trackers", trackers_); 
    933  
    934                         ar & slz::make_nvp("save_directory", save_directory_); 
    935                         ar & slz::make_nvp("move_to_directory", move_to_directory_); 
    936                          
    937                         ar & slz::make_nvp("payload_uploaded", payloadUploaded_); 
    938                         ar & slz::make_nvp("payload_downloaded", payloadDownloaded_); 
    939                         ar & slz::make_nvp("uploaded", uploaded_); 
    940                         ar & slz::make_nvp("downloaded", downloaded_);                   
     921                        ar & make_nvp("transfer_limits", transferLimit_); 
     922                        ar & make_nvp("connection_limits", connections_); 
     923                        ar & make_nvp("upload_limits", uploads_);        
     924 
     925                        ar & make_nvp("name", name_); 
     926                        ar & make_nvp("filename", filename_);    
     927 
     928                        ar & make_nvp("ratio", ratio_);  
     929                        ar & make_nvp("progress", progress_); 
     930                        ar & make_nvp("state", state_); 
     931                        ar & make_nvp("compact_storage", compactStorage_);       
     932                        ar & make_nvp("resolve_countries", resolve_countries_);  
     933 
     934                        ar & make_nvp("tracker_username", trackerUsername_); 
     935                        ar & make_nvp("tracker_password", trackerPassword_); 
     936                        ar & make_nvp("trackers", trackers_); 
     937 
     938                        ar & make_nvp("save_directory", save_directory_); 
     939                        ar & make_nvp("move_to_directory", move_to_directory_); 
     940                         
     941                        ar & make_nvp("payload_uploaded", payloadUploaded_); 
     942                        ar & make_nvp("payload_downloaded", payloadDownloaded_); 
     943                        ar & make_nvp("uploaded", uploaded_); 
     944                        ar & make_nvp("downloaded", downloaded_);                        
    941945                                         
    942                         ar & slz::make_nvp("file_priorities", filePriorities_); 
    943                          
    944                         ar & slz::make_nvp("start_time", startTime_); 
    945                         ar & slz::make_nvp("finish_time", finishTime_); 
    946                         ar & slz::make_nvp("active_duration", activeDuration_); 
    947                         ar & slz::make_nvp("seeding_duration", seedingDuration_); 
     946                        ar & make_nvp("file_priorities", filePriorities_); 
     947                         
     948                        ar & make_nvp("start_time", startTime_); 
     949                        ar & make_nvp("finish_time", finishTime_); 
     950                        ar & make_nvp("active_duration", activeDuration_); 
     951                        ar & make_nvp("seeding_duration", seedingDuration_); 
    948952                                         
    949953                }  
    950954                else  
    951955                { 
    952                     ar & slz::make_nvp("transferLimit", transferLimit_); 
    953                         ar & slz::make_nvp("connections", connections_); 
    954                         ar & slz::make_nvp("uploads", uploads_);                         
    955                         ar & slz::make_nvp("filename", filename_);       
     956                    ar & make_nvp("transferLimit", transferLimit_); 
     957                        ar & make_nvp("connections", connections_); 
     958                        ar & make_nvp("uploads", uploads_);                      
     959                        ar & make_nvp("filename", filename_);    
    956960 
    957961                        wstring s; 
    958                         ar & slz::make_nvp("saveDirectory", s); 
     962                        ar & make_nvp("saveDirectory", s); 
    959963                        save_directory_ = s; 
    960964 
    961965                        if (version == 2) { 
    962966                                wstring m; 
    963                                 ar & slz::make_nvp("moveToDirectory", m); 
     967                                ar & make_nvp("moveToDirectory", m); 
    964968                                move_to_directory_ = m; 
    965969                        } else { 
     
    967971                        } 
    968972                         
    969                         ar & slz::make_nvp("payloadUploaded_", payloadUploaded_); 
    970                         ar & slz::make_nvp("payloadDownloaded_", payloadDownloaded_); 
    971                         ar & slz::make_nvp("uploaded_", uploaded_); 
    972                         ar & slz::make_nvp("downloaded_", downloaded_);  
    973                         ar & slz::make_nvp("ratio", ratio_);     
    974                         ar & slz::make_nvp("trackerUsername", trackerUsername_); 
    975                         ar & slz::make_nvp("trackerPassword", trackerPassword_); 
    976                          
    977                         ar & slz::make_nvp("state", state_); 
    978                         ar & slz::make_nvp("trackers", trackers_); 
    979                          
    980                         ar & slz::make_nvp("resolve_countries", resolve_countries_); 
    981                          
    982                         ar & slz::make_nvp("file_priorities", filePriorities_); 
    983                          
    984                         ar & slz::make_nvp("startTime", startTime_); 
    985                         ar & slz::make_nvp("activeDuration", activeDuration_); 
    986                         ar & slz::make_nvp("seedingDuration", seedingDuration_); 
    987                          
    988                         ar & slz::make_nvp("name", name_); 
    989                         ar & slz::make_nvp("compactStorage", compactStorage_); 
    990                         ar & slz::make_nvp("finishTime", finishTime_); 
    991                          
    992                         ar & slz::make_nvp("progress", progress_); 
     973                        ar & make_nvp("payloadUploaded_", payloadUploaded_); 
     974                        ar & make_nvp("payloadDownloaded_", payloadDownloaded_); 
     975                        ar & make_nvp("uploaded_", uploaded_); 
     976                        ar & make_nvp("downloaded_", downloaded_);       
     977                        ar & make_nvp("ratio", ratio_);  
     978                        ar & make_nvp("trackerUsername", trackerUsername_); 
     979                        ar & make_nvp("trackerPassword", trackerPassword_); 
     980                         
     981                        ar & make_nvp("state", state_); 
     982                        ar & make_nvp("trackers", trackers_); 
     983                         
     984                        ar & make_nvp("resolve_countries", resolve_countries_); 
     985                         
     986                        ar & make_nvp("file_priorities", filePriorities_); 
     987                         
     988                        ar & make_nvp("startTime", startTime_); 
     989                        ar & make_nvp("activeDuration", activeDuration_); 
     990                        ar & make_nvp("seedingDuration", seedingDuration_); 
     991                         
     992                        ar & make_nvp("name", name_); 
     993                        ar & make_nvp("compactStorage", compactStorage_); 
     994                        ar & make_nvp("finishTime", finishTime_); 
     995                         
     996                        ar & make_nvp("progress", progress_); 
    993997        } 
    994998    } 
     
    10001004        } 
    10011005 
    1002         std::vector<lbt::peer_info>& peers() { return peers_; } 
     1006        std::vector<libt::peer_info>& peers() { return peers_; } 
    10031007         
    10041008        boost::tuple<size_t, size_t, size_t, size_t> updatePeers() 
     
    10121016                size_t seedsConnected = 0; 
    10131017                 
    1014                 foreach (lbt::peer_info& peer, peers_)  
     1018                foreach (libt::peer_info& peer, peers_)  
    10151019                { 
    10161020                        float speedSum = peer.down_speed + peer.up_speed; 
    10171021                         
    1018                         if (!(peer.flags & lbt::peer_info::seed)) 
     1022                        if (!(peer.flags & libt::peer_info::seed)) 
    10191023                        { 
    10201024                                ++totalPeers; 
     
    10391043                if (in_session()) 
    10401044                { 
    1041                         foreach (lbt::peer_info peer, peers_)  
     1045                        foreach (libt::peer_info peer, peers_)  
    10421046                        { 
    10431047                                peerDetails.push_back(peer); 
     
    10501054                if (fileDetailsMemory_.empty()) 
    10511055                { 
    1052                         lbt::torrent_info& info = infoMemory(); 
    1053                         std::vector<lbt::file_entry> files; 
     1056                        libt::torrent_info& info = infoMemory(); 
     1057                        std::vector<libt::file_entry> files; 
    10541058                         
    10551059                        std::copy(info.begin_files(), info.end_files(),  
     
    11191123        } 
    11201124         
    1121         void extractNames(lbt::entry& metadata) 
    1122         { 
    1123                 mutex_t::scoped_lock l(mutex_); 
    1124                  
    1125                 lbt::torrent_info info(metadata);                                
     1125        void extractNames(libt::entry& metadata) 
     1126        { 
     1127                mutex_t::scoped_lock l(mutex_); 
     1128                 
     1129                libt::torrent_info info(metadata);                               
    11261130                name_ = hal::from_utf8_safe(info.name()); 
    11271131                 
     
    11341138        } 
    11351139         
    1136         lbt::torrent_info& infoMemory() 
    1137         { 
    1138                 if (!infoMemory_.is_valid()) infoMemory_ = lbt::torrent_info(metadata_); 
     1140        libt::torrent_info& infoMemory() 
     1141        { 
     1142                if (!infoMemory_.is_valid()) infoMemory_ = libt::torrent_info(metadata_); 
    11391143                 
    11401144                return infoMemory_; 
     
    12091213                        if (!trackers_.empty()) 
    12101214                        { 
    1211                                 std::vector<lbt::announce_entry> trackers; 
     1215                                std::vector<libt::announce_entry> trackers; 
    12121216                                 
    12131217                                foreach (const tracker_detail& tracker, trackers_) 
    12141218                                { 
    12151219                                        trackers.push_back( 
    1216                                                 lbt::announce_entry(hal::to_utf8(tracker.url))); 
     1220                                                libt::announce_entry(hal::to_utf8(tracker.url))); 
    12171221                                        trackers.back().tier = tracker.tier; 
    12181222                                } 
     
    12811285                state_ = TorrentDetail::torrent_stopped; 
    12821286                 
    1283                 removeFromSession(); 
     1287                remove_from_session(); 
    12841288                assert(!in_session()); 
    12851289 
     
    12921296                state_ = TorrentDetail::torrent_stopped; 
    12931297 
    1294                 removeFromSession(false); 
     1298                remove_from_session(false); 
    12951299                assert(!in_session()); 
    12961300 
    1297                 clearResumeData(); 
     1301                clear_resume_data(); 
    12981302 
    12991303                resume(); 
     
    13031307        } 
    13041308                 
    1305         static lbt::session* the_session_; 
     1309        static libt::session* the_session_; 
    13061310        static wpath workingDir_; 
    13071311         
     
    13221326        wpath move_to_directory_; 
    13231327        wstring originalFilename_; 
    1324         lbt::torrent_handle handle_;     
    1325          
    1326         lbt::entry metadata_; 
    1327         lbt::entry resumedata_; 
     1328        libt::torrent_handle handle_;    
     1329         
     1330        libt::entry metadata_; 
     1331        libt::entry resumedata_; 
    13281332         
    13291333        wstring trackerUsername_;        
     
    13331337        boost::int64_t totalBase_; 
    13341338         
    1335         TransferTracker<boost::int64_t> payloadUploaded_; 
    1336         TransferTracker<boost::int64_t> payloadDownloaded_; 
    1337         TransferTracker<boost::int64_t> uploaded_; 
    1338         TransferTracker<boost::int64_t> downloaded_; 
     1339        transfer_tracker<boost::int64_t> payloadUploaded_; 
     1340        transfer_tracker<boost::int64_t> payloadDownloaded_; 
     1341        transfer_tracker<boost::int64_t> uploaded_; 
     1342        transfer_tracker<boost::int64_t> downloaded_; 
    13391343         
    13401344        pt::ptime startTime_; 
    13411345        pt::ptime finishTime_; 
    1342         DurationTracker activeDuration_; 
    1343         DurationTracker seedingDuration_; 
     1346        duration_tracker activeDuration_; 
     1347        duration_tracker seedingDuration_; 
    13441348         
    13451349        std::vector<tracker_detail> trackers_; 
    1346         std::vector<lbt::announce_entry> torrent_trackers_; 
    1347         std::vector<lbt::peer_info> peers_;      
     1350        std::vector<libt::announce_entry> torrent_trackers_; 
     1351        std::vector<libt::peer_info> peers_;     
    13481352        std::vector<int> filePriorities_; 
    13491353         
    13501354        float progress_; 
    13511355         
    1352         lbt::torrent_info infoMemory_; 
    1353         lbt::torrent_status statusMemory_; 
     1356        libt::torrent_info infoMemory_; 
     1357        libt::torrent_status statusMemory_; 
    13541358        FileDetails fileDetailsMemory_; 
    13551359         
     
    13841388                void serialize(Archive& ar, const unsigned int version) 
    13851389                { 
     1390                        using boost::serialization::make_nvp; 
     1391 
    13861392                        if (version < 1) 
    13871393                        { 
    13881394                                TorrentInternalOld t; 
    1389                                 ar & slz::make_nvp("torrent", t); 
     1395                                ar & make_nvp("torrent", t); 
    13901396                                 
    13911397                                torrent.reset(new torrent_internal(t)); 
     
    13931399                        else 
    13941400                        { 
    1395                                 ar & slz::make_nvp("torrent", torrent); 
     1401                                ar & make_nvp("torrent", torrent); 
    13961402                        }  
    13971403                         
    1398                         ar & slz::make_nvp("filename", filename); 
    1399                         ar & slz::make_nvp("name", name); 
     1404                        ar & make_nvp("filename", filename); 
     1405                        ar & make_nvp("name", name); 
    14001406                } 
    14011407        }; 
     
    15111517        void serialize(Archive& ar, const unsigned int version) 
    15121518        { 
    1513                 ar & slz::make_nvp("torrents", torrents_); 
     1519                ar & boost::serialization::make_nvp("torrents", torrents_); 
    15141520        }        
    15151521         
     
    15911597                switch (statusMemory_.state) 
    15921598                { 
    1593                 case lbt::torrent_status::queued_for_checking: 
     1599                case libt::torrent_status::queued_for_checking: 
    15941600                        state = app().res_wstr(HAL_TORRENT_QUEUED_CHECKING); 
    15951601                        break; 
    1596                 case lbt::torrent_status::checking_files: 
     1602                case libt::torrent_status::checking_files: 
    15971603                        state = app().res_wstr(HAL_TORRENT_CHECKING_FILES); 
    15981604                        break; 
    1599                 case lbt::torrent_status::connecting_to_tracker: 
     1605                case libt::torrent_status::connecting_to_tracker: 
    16001606                        state = app().res_wstr(HAL_TORRENT_CONNECTING); 
    16011607                        break; 
    1602                 case lbt::torrent_status::downloading_metadata: 
     1608                case libt::torrent_status::downloading_metadata: 
    16031609                        state = app().res_wstr(HAL_TORRENT_METADATA); 
    16041610                        break; 
    1605                 case lbt::torrent_status::downloading: 
     1611                case libt::torrent_status::downloading: 
    16061612                        state = app().res_wstr(HAL_TORRENT_DOWNLOADING); 
    16071613                        break; 
    1608                 case lbt::torrent_status::finished: 
     1614                case libt::torrent_status::finished: 
    16091615                        state = app().res_wstr(HAL_TORRENT_FINISHED); 
    16101616                        break; 
    1611                 case lbt::torrent_status::seeding: 
     1617                case libt::torrent_status::seeding: 
    16121618                        state = app().res_wstr(HAL_TORRENT_SEEDING); 
    16131619                        break; 
    1614                 case lbt::torrent_status::allocating: 
     1620                case libt::torrent_status::allocating: 
    16151621                        state = app().res_wstr(HAL_TORRENT_ALLOCATING); 
    16161622                        break; 
     
    16381644                activeDuration_.update(); 
    16391645                 
    1640                 if (lbt::torrent_status::seeding == statusMemory_.state) 
     1646                if (libt::torrent_status::seeding == statusMemory_.state) 
    16411647                        seedingDuration_.update(); 
    16421648        }        
     
    16501656 
    16511657        } 
    1652         catch (const lbt::invalid_handle&) 
     1658        catch (const libt::invalid_handle&) 
    16531659        { 
    16541660                event().post(shared_ptr<EventDetail>( 
  • trunk/src/halTypes.hpp

    r437 r447  
    1717        namespace pt = boost::posix_time; 
    1818        namespace xp = boost::xpressive; 
    19         namespace slz = boost::serialization; 
    2019 
    2120        using std::wstring; 
Note: See TracChangeset for help on using the changeset viewer.