/* Boost.MultiIndex test for serialization, part 3.
 *
 * Copyright 2003-2010 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.
 */

#include "test_serialization3.hpp"
#include "test_serialization_template.hpp"

#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/key_extractors.hpp>
#include "non_std_allocator.hpp"

struct non_default_ctble
{
  non_default_ctble(int n_):n(n_){}

  bool operator==(const non_default_ctble& x)const{return n==x.n;}

  int n;
};

#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
namespace boost{
namespace serialization{
#endif

template<class Archive>
void save_construct_data(
  Archive& ar,const non_default_ctble* p,const unsigned int version)
{
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  if(version<3)return;
#endif

  ar<<boost::serialization::make_nvp("n",p->n);
}

template<class Archive>
void load_construct_data(
  Archive& ar,non_default_ctble* p,const unsigned int version)
{
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  if(version<3)return;
#endif

  int n=0;
  ar>>boost::serialization::make_nvp("n",n);
  ::new(p)non_default_ctble(n);
}

template<class Archive>
void serialize(Archive&,non_default_ctble&,const unsigned int)
{
}

#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
} /* namespace serialization */
} /* namespace boost*/
#endif

namespace boost{
namespace serialization{
template<> struct version<non_default_ctble>
{
  BOOST_STATIC_CONSTANT(int,value=3);
};
} /* namespace serialization */
} /* namespace boost*/

using namespace boost::multi_index;

void test_serialization3()
{
  const int N=100;
  const int SHUFFLE=10232;

  typedef multi_index_container<
    int,
    indexed_by<
      hashed_unique<identity<int> >,
      sequenced<>
    >,
    non_std_allocator<int>
  > hashed_set;

  typedef hashed_set::iterator       iterator;
  typedef hashed_set::local_iterator local_iterator;

  hashed_set hs;

  for(int i=0;i<N;++i){
    hs.insert(i*SHUFFLE);
  }

  std::ostringstream oss;
  {
    boost::archive::text_oarchive oa(oss);
    oa<<const_cast<const hashed_set&>(hs);

    std::vector<iterator> its(N);
    for(int i=0;i<N;++i){
      iterator it=hs.find(i*SHUFFLE);
      its.push_back(it);
      oa<<const_cast<const iterator&>(its.back());
    }
    iterator it=hs.end();
    oa<<const_cast<const iterator&>(it);

    std::vector<local_iterator> lits(2*N);
    for(std::size_t buc=0;buc<hs.bucket_count();++buc){
      for(local_iterator lit=hs.begin(buc),lit_end=hs.end(buc);
          lit!=lit_end;++lit){
        oa<<*lit;
        lits.push_back(lit);
        oa<<const_cast<const local_iterator&>(lits.back());
      }
      local_iterator lit2=hs.end(buc);
      lits.push_back(lit2);
      oa<<const_cast<const local_iterator&>(lits.back());
    }
  }

  hashed_set hs2;
  std::istringstream iss(oss.str());
  boost::archive::text_iarchive ia(iss);
  ia>>hs2;
  BOOST_CHECK(boost::multi_index::get<1>(hs)==boost::multi_index::get<1>(hs2));

  for(int j=0;j<N;++j){
    iterator it;
    ia>>it;
    BOOST_CHECK(*it==j*SHUFFLE);
  }
  iterator it;
  ia>>it;
  BOOST_CHECK(it==hs2.end());

  for(std::size_t buc=0;buc<hs2.bucket_count();++buc){
    for(std::size_t k=0;k<hs2.bucket_size(buc);++k){
      int n;
      local_iterator it;
      ia>>n;
      ia>>it;
      BOOST_CHECK(*it==n);
    }
    local_iterator it2;
    ia>>it2;
    BOOST_CHECK(it2==hs2.end(buc));
  }

  {
    typedef multi_index_container<
      non_default_ctble,
      indexed_by<
        ordered_unique<
          BOOST_MULTI_INDEX_MEMBER(non_default_ctble,int,n)
        >
      >
    > multi_index_t;

    multi_index_t m;
    for(int i=0;i<100;++i)m.insert(non_default_ctble(i));
    test_serialization(m);
  }
}