boost_ext/boost/multi_index/detail/index_node_base.hpp

   1 /* Copyright 2003-2007 Joaquín M López Muñoz.
   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
  26 namespace boost{
  27
  28 namespace multi_index{
  29
  30 namespace 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
  36 template<typename Value>
  37 struct pod_value_holder
  38 {
  39   typename aligned_storage<
  40     sizeof(Value),
  41     alignment_of<Value>::value
  42   >::type                      space;
  43 };
  44
  45 template<typename Value,typename Allocator>
  46 struct 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
  71 private:
  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
  87 template<typename Node,typename Value>
  88 Node* 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)
 109 namespace serialization{
 110 #else
 111 namespace multi_index{
 112 namespace detail{
 113 #endif
 114
 115 template<class Archive,typename Value,typename Allocator>
 116 inline 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