/* Copyright 2003-2007 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_HASH_INDEX_ITERATOR_HPP

#define BOOST_MULTI_INDEX_DETAIL_HASH_INDEX_ITERATOR_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 <boost/operators.hpp>



#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)

#include <boost/serialization/nvp.hpp>

#include <boost/serialization/split_member.hpp>

#endif



namespace boost{



namespace multi_index{



namespace detail{



/* Iterator class for hashed indices.

 */



template<typename Node,typename BucketArray,typename Derived=mpl::na>

class hashed_index_iterator:

  public forward_iterator_helper<

    hashed_index_iterator<Node,BucketArray,Derived>,

    typename Node::value_type,

    std::ptrdiff_t,

    const typename Node::value_type*,

    const typename Node::value_type&>

{

public:

  hashed_index_iterator(){}

  hashed_index_iterator(Node* node_,BucketArray* buckets_):

    node(node_),buckets(buckets_)

  {}



  const typename Node::value_type& operator*()const

  {

    return node->value();

  }



  hashed_index_iterator& operator++()

  {

    Node::increment(node,buckets->begin(),buckets->end());

    return *this;

  }



#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)

  /* Serialization. As for why the following is public,

   * see explanation in safe_mode_iterator notes in safe_mode.hpp.

   */

  

  BOOST_SERIALIZATION_SPLIT_MEMBER()



  typedef typename Node::base_type node_base_type;



  template<class Archive>

  void save(Archive& ar,const unsigned int)const

  {

    node_base_type* bnode=node;

    ar<<serialization::make_nvp("pointer",bnode);

    ar<<serialization::make_nvp("pointer",buckets);

  }



  template<class Archive>

  void load(Archive& ar,const unsigned int)

  {

    node_base_type* bnode;

    ar>>serialization::make_nvp("pointer",bnode);

    node=static_cast<Node*>(bnode);

    ar>>serialization::make_nvp("pointer",buckets);

  }

#endif



  /* get_node is not to be used by the user */



  typedef Node node_type;



  Node* get_node()const{return node;}



private:

  Node*        node;

  BucketArray* buckets;

};



template<typename Node,typename BucketArray,typename Derived>

bool operator==(

  const hashed_index_iterator<Node,BucketArray,Derived>& x,

  const hashed_index_iterator<Node,BucketArray,Derived>& y)

{

  return x.get_node()==y.get_node();

}



} /* namespace multi_index::detail */



} /* namespace multi_index */



} /* namespace boost */



#endif

