| /* 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. |
| */ |
| |
| #ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP |
| #define BOOST_MULTI_INDEX_DETAIL_INDEX_LOADER_HPP |
| |
| #if defined(_MSC_VER)&&(_MSC_VER>=1200) |
| #pragma once |
| #endif |
| |
| #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */ |
| #include <algorithm> |
| #include <boost/archive/archive_exception.hpp> |
| #include <boost/noncopyable.hpp> |
| #include <boost/multi_index/detail/auto_space.hpp> |
| #include <boost/serialization/nvp.hpp> |
| #include <boost/throw_exception.hpp> |
| #include <cstddef> |
| |
| namespace boost{ |
| |
| namespace multi_index{ |
| |
| namespace detail{ |
| |
| /* Counterpart of index_saver (check index_saver.hpp for serialization |
| * details.)* multi_index_container is in charge of supplying the info about |
| * the base sequence, and each index can subsequently load itself using the |
| * const interface of index_loader. |
| */ |
| |
| template<typename Node,typename FinalNode,typename Allocator> |
| class index_loader:private noncopyable |
| { |
| public: |
| index_loader(const Allocator& al,std::size_t size): |
| spc(al,size),size_(size),n(0),sorted(false) |
| { |
| } |
| |
| template<class Archive> |
| void add(Node* node,Archive& ar,const unsigned int) |
| { |
| ar>>serialization::make_nvp("position",*node); |
| entries()[n++]=node; |
| } |
| |
| template<class Archive> |
| void add_track(Node* node,Archive& ar,const unsigned int) |
| { |
| ar>>serialization::make_nvp("position",*node); |
| } |
| |
| /* A rearranger is passed two nodes, and is expected to |
| * reposition the second after the first. |
| * If the first node is 0, then the second should be moved |
| * to the beginning of the sequence. |
| */ |
| |
| template<typename Rearranger,class Archive> |
| void load(Rearranger r,Archive& ar,const unsigned int)const |
| { |
| FinalNode* prev=unchecked_load_node(ar); |
| if(!prev)return; |
| |
| if(!sorted){ |
| std::sort(entries(),entries()+size_); |
| sorted=true; |
| } |
| |
| check_node(prev); |
| |
| for(;;){ |
| for(;;){ |
| FinalNode* node=load_node(ar); |
| if(!node)break; |
| |
| if(node==prev)prev=0; |
| r(prev,node); |
| |
| prev=node; |
| } |
| prev=load_node(ar); |
| if(!prev)break; |
| } |
| } |
| |
| private: |
| Node** entries()const{return &*spc.data();} |
| |
| /* We try to delay sorting as much as possible just in case it |
| * is not necessary, hence this version of load_node. |
| */ |
| |
| template<class Archive> |
| FinalNode* unchecked_load_node(Archive& ar)const |
| { |
| Node* node=0; |
| ar>>serialization::make_nvp("pointer",node); |
| return static_cast<FinalNode*>(node); |
| } |
| |
| template<class Archive> |
| FinalNode* load_node(Archive& ar)const |
| { |
| Node* node=0; |
| ar>>serialization::make_nvp("pointer",node); |
| check_node(node); |
| return static_cast<FinalNode*>(node); |
| } |
| |
| void check_node(Node* node)const |
| { |
| if(node!=0&&!std::binary_search(entries(),entries()+size_,node)){ |
| throw_exception( |
| archive::archive_exception( |
| archive::archive_exception::other_exception)); |
| } |
| } |
| |
| auto_space<Node*,Allocator> spc; |
| std::size_t size_; |
| std::size_t n; |
| mutable bool sorted; |
| }; |
| |
| } /* namespace multi_index::detail */ |
| |
| } /* namespace multi_index */ |
| |
| } /* namespace boost */ |
| |
| #endif |