/* Copyright 2003-2005 Joaquín M López Muñoz.

  * 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