/Src/Dependencies/Boost/boost/multi_index/detail/index_node_base.hpp

  1/* Copyright 2003-2008 Joaquin M Lopez Munoz.
  2 * Distributed under the Boost Software License, Version 1.0.
  3 * (See accompanying file LICENSE_1_0.txt or copy at
  4 * http://www.boost.org/LICENSE_1_0.txt)
  5 *
  6 * See http://www.boost.org/libs/multi_index for library home page.
  7 */
  8
  9#ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP
 10#define BOOST_MULTI_INDEX_DETAIL_INDEX_NODE_BASE_HPP
 11
 12#if defined(_MSC_VER)&&(_MSC_VER>=1200)
 13#pragma once
 14#endif
 15
 16#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
 17#include <boost/type_traits/aligned_storage.hpp>
 18#include <boost/type_traits/alignment_of.hpp> 
 19
 20#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
 21#include <boost/archive/archive_exception.hpp>
 22#include <boost/serialization/access.hpp>
 23#include <boost/throw_exception.hpp> 
 24#endif
 25
 26namespace boost{
 27
 28namespace multi_index{
 29
 30namespace detail{
 31
 32/* index_node_base tops the node hierarchy of multi_index_container. It holds
 33 * the value of the element contained.
 34 */
 35
 36template<typename Value>
 37struct pod_value_holder
 38{
 39  typename aligned_storage<
 40    sizeof(Value),
 41    alignment_of<Value>::value
 42  >::type                      space;
 43};
 44
 45template<typename Value,typename Allocator>
 46struct index_node_base:private pod_value_holder<Value>
 47{
 48  typedef index_node_base base_type; /* used for serialization purposes */
 49  typedef Value           value_type;
 50  typedef Allocator       allocator_type;
 51
 52  value_type& value()
 53  {
 54    return *static_cast<value_type*>(
 55      static_cast<void*>(&this->space));
 56  }
 57
 58  const value_type& value()const
 59  {
 60    return *static_cast<const value_type*>(
 61      static_cast<const void*>(&this->space));
 62  }
 63
 64  static index_node_base* from_value(const value_type* p)
 65  {
 66    return static_cast<index_node_base *>(
 67      reinterpret_cast<pod_value_holder<Value>*>( /* std 9.2.17 */
 68        const_cast<value_type*>(p))); 
 69  }
 70
 71private:
 72#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
 73  friend class boost::serialization::access;
 74  
 75  /* nodes do not emit any kind of serialization info. They are
 76   * fed to Boost.Serialization so that pointers to nodes are
 77   * tracked correctly.
 78   */
 79
 80  template<class Archive>
 81  void serialize(Archive&,const unsigned int)
 82  {
 83  }
 84#endif
 85};
 86
 87template<typename Node,typename Value>
 88Node* node_from_value(
 89  const Value* p
 90  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Node))
 91{
 92  typedef typename Node::allocator_type allocator_type;
 93  return static_cast<Node*>(
 94    index_node_base<Value,allocator_type>::from_value(p));
 95}
 96
 97} /* namespace multi_index::detail */
 98
 99} /* namespace multi_index */
100
101#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
102/* Index nodes never get constructed directly by Boost.Serialization,
103 * as archives are always fed pointers to previously existent
104 * nodes. So, if this is called it means we are dealing with a
105 * somehow invalid archive.
106 */
107
108#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
109namespace serialization{
110#else
111namespace multi_index{
112namespace detail{
113#endif
114
115template<class Archive,typename Value,typename Allocator>
116inline void load_construct_data(
117  Archive&,boost::multi_index::detail::index_node_base<Value,Allocator>*,
118  const unsigned int)
119{
120  throw_exception(
121    archive::archive_exception(archive::archive_exception::other_exception));
122}
123
124#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
125} /* namespace serialization */
126#else
127} /* namespace multi_index::detail */
128} /* namespace multi_index */
129#endif
130
131#endif
132
133} /* namespace boost */
134
135#endif