/* Copyright 2003-2006 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_NODE_BASE_HPP

#define BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_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/type_traits/aligned_storage.hpp>

#include <boost/type_traits/alignment_of.hpp> 

#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)

#include <boost/archive/archive_exception.hpp>

#include <boost/serialization/access.hpp>

#include <boost/throw_exception.hpp> 

#endif

namespace boost{

namespace multi_index{

namespace detail{

/* index_node_base tops the node hierarchy of multi_index_container. It holds

 * the value of the element contained.

 */

template<typename Value>

struct pod_value_holder

{

  typename aligned_storage<

    sizeof(Value),

    alignment_of<Value>::value

  >::type                      space;

};

template<typename Value>

struct index_node_base:private pod_value_holder<Value>

{

  typedef index_node_base base_type; /* used for serialization purposes */

  typedef Value           value_type;

  value_type& value()

  {

    return *static_cast<value_type*>(

      static_cast<void*>(&this->space));

  }

  const value_type& value()const

  {

    return *static_cast<const value_type*>(

      static_cast<const void*>(&this->space));

  }

  static index_node_base* from_value(const value_type* p)

  {

    return static_cast<index_node_base *>(

      reinterpret_cast<pod_value_holder<Value>*>( /* std 9.2.17 */

        const_cast<value_type*>(p))); 

  }

private:

#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)

  friend class boost::serialization::access;

  /* nodes do not emit any kind of serialization info. They are

   * fed to Boost.Serialization so that pointers to nodes are

   * tracked correctly.

   */

  template<class Archive>

  void serialize(Archive&,const unsigned int)

  {

  }

#endif

};

template<typename Node,typename Value>

Node* node_from_value(

  const Value* p

  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Node))

{

  return static_cast<Node*>(index_node_base<Value>::from_value(p));

}

} /* namespace multi_index::detail */

} /* namespace multi_index */

#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)

/* Index nodes never get constructed directly by Boost.Serialization,

 * as archives are always fed pointers to previously existent

 * nodes. So, if this is called it means we are dealing with a

 * somehow invalid archive.

 */

#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)

namespace serialization{

#else

namespace multi_index{

namespace detail{

#endif

template<class Archive,typename Value>

inline void load_construct_data(

  Archive&,boost::multi_index::detail::index_node_base<Value>*,

  const unsigned int)

{

  throw_exception(

    archive::archive_exception(archive::archive_exception::other_exception));

}

#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)

} /* namespace serialization */

#else

} /* namespace multi_index::detail */

} /* namespace multi_index */

#endif

#endif

} /* namespace boost */

#endif