| /* Boost.MultiIndex example of serialization of a MRU list. |
| * |
| * Copyright 2003-2008 Joaquin M Lopez Munoz. |
| * Distributed under the Boost Software License, Version 1.0. |
| * (See accompanying file LICENSE_1_0.txt or copy at |
| * http://www.boost.org/LICENSE_1_0.txt) |
| * |
| * See http://www.boost.org/libs/multi_index for library home page. |
| */ |
| |
| #if !defined(NDEBUG) |
| #define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING |
| #define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE |
| #endif |
| |
| #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */ |
| #include <algorithm> |
| #include <boost/archive/text_oarchive.hpp> |
| #include <boost/archive/text_iarchive.hpp> |
| #include <boost/multi_index_container.hpp> |
| #include <boost/multi_index/hashed_index.hpp> |
| #include <boost/multi_index/identity.hpp> |
| #include <boost/multi_index/sequenced_index.hpp> |
| #include <fstream> |
| #include <iostream> |
| #include <iterator> |
| #include <sstream> |
| #include <string> |
| |
| using namespace boost::multi_index; |
| |
| /* An MRU (most recently used) list keeps record of the last n |
| * inserted items, listing first the newer ones. Care has to be |
| * taken when a duplicate item is inserted: instead of letting it |
| * appear twice, the MRU list relocates it to the first position. |
| */ |
| |
| template <typename Item> |
| class mru_list |
| { |
| typedef multi_index_container< |
| Item, |
| indexed_by< |
| sequenced<>, |
| hashed_unique<identity<Item> > |
| > |
| > item_list; |
| |
| public: |
| typedef Item item_type; |
| typedef typename item_list::iterator iterator; |
| |
| mru_list(std::size_t max_num_items_):max_num_items(max_num_items_){} |
| |
| void insert(const item_type& item) |
| { |
| std::pair<iterator,bool> p=il.push_front(item); |
| |
| if(!p.second){ /* duplicate item */ |
| il.relocate(il.begin(),p.first); /* put in front */ |
| } |
| else if(il.size()>max_num_items){ /* keep the length <= max_num_items */ |
| il.pop_back(); |
| } |
| } |
| |
| iterator begin(){return il.begin();} |
| iterator end(){return il.end();} |
| |
| /* Utilities to save and load the MRU list, internally |
| * based on Boost.Serialization. |
| */ |
| |
| void save_to_file(const char* file_name)const |
| { |
| std::ofstream ofs(file_name); |
| boost::archive::text_oarchive oa(ofs); |
| oa<<boost::serialization::make_nvp("mru",*this); |
| } |
| |
| void load_from_file(const char* file_name) |
| { |
| std::ifstream ifs(file_name); |
| if(ifs){ |
| boost::archive::text_iarchive ia(ifs); |
| ia>>boost::serialization::make_nvp("mru",*this); |
| } |
| } |
| |
| private: |
| item_list il; |
| std::size_t max_num_items; |
| |
| /* serialization support */ |
| |
| friend class boost::serialization::access; |
| |
| template<class Archive> |
| void serialize(Archive& ar,const unsigned int) |
| { |
| ar&BOOST_SERIALIZATION_NVP(il); |
| ar&BOOST_SERIALIZATION_NVP(max_num_items); |
| } |
| }; |
| |
| int main() |
| { |
| const char* mru_store="mru_store"; |
| |
| /* Construct a MRU limited to 10 items and retrieve its |
| * previous contents. |
| */ |
| |
| mru_list<std::string> mru(10); |
| mru.load_from_file(mru_store); |
| |
| /* main loop */ |
| |
| for(;;){ |
| std::cout<<"enter a term: "; |
| |
| std::string line; |
| std::getline(std::cin,line); |
| if(line.empty())break; |
| |
| std::string term; |
| std::istringstream iss(line); |
| iss>>term; |
| if(term.empty())break; |
| |
| mru.insert(term); |
| |
| std::cout<<"most recently entered terms:"<<std::endl; |
| std::copy( |
| mru.begin(),mru.end(), |
| std::ostream_iterator<std::string>(std::cout,"\n")); |
| } |
| |
| /* persist the MRU list */ |
| |
| mru.save_to_file(mru_store); |
| |
| return 0; |
| } |