ceph/src/boost/libs/serialization/include/boost/serialization/base_object.hpp

   1 #ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP
   2 #define BOOST_SERIALIZATION_BASE_OBJECT_HPP
   3
   4 // MS compatible compilers support #pragma once
   5 #if defined(_MSC_VER)
   6 # pragma once
   7 #endif
   8
   9 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
  10 // base_object.hpp:
  11
  12 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
  13 // Use, modification and distribution is subject to the Boost Software
  14 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  15 // http://www.boost.org/LICENSE_1_0.txt)
  16
  17 //  See http://www.boost.org for updates, documentation, and revision history.
  18
  19 // if no archive headers have been included this is a no op
  20 // this is to permit BOOST_EXPORT etc to be included in a
  21 // file declaration header
  22
  23 #include <boost/config.hpp>
  24 #include <boost/detail/workaround.hpp>
  25
  26 #include <boost/mpl/eval_if.hpp>
  27 #include <boost/mpl/int.hpp>
  28 #include <boost/mpl/identity.hpp>
  29
  30 #include <boost/type_traits/is_base_and_derived.hpp>
  31 #include <boost/type_traits/is_pointer.hpp>
  32 #include <boost/type_traits/is_const.hpp>
  33 #include <boost/type_traits/is_polymorphic.hpp>
  34
  35 #include <boost/static_assert.hpp>
  36 #include <boost/serialization/access.hpp>
  37 #include <boost/serialization/force_include.hpp>
  38 #include <boost/serialization/void_cast_fwd.hpp>
  39
  40 namespace boost {
  41 namespace serialization {
  42
  43 namespace detail
  44 {
  45     // get the base type for a given derived type
  46     // preserving the const-ness
  47     template<class B, class D>
  48     struct base_cast
  49     {
  50         typedef typename
  51         mpl::if_<
  52             is_const<D>,
  53             const B,
  54             B
  55         >::type type;
  56         BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value);
  57     };
  58
  59     // only register void casts if the types are polymorphic
  60     template<class Base, class Derived>
  61     struct base_register
  62     {
  63         struct polymorphic {
  64             static void const * invoke(){
  65                 Base const * const b = 0;
  66                 Derived const * const d = 0;
  67                 return & void_cast_register(d, b);
  68             }
  69         };
  70         struct non_polymorphic {
  71             static void const * invoke(){
  72                 return 0;
  73             }
  74         };
  75         static void const * invoke(){
  76             typedef typename mpl::eval_if<
  77                 is_polymorphic<Base>,
  78                 mpl::identity<polymorphic>,
  79                 mpl::identity<non_polymorphic>
  80             >::type type;
  81             return type::invoke();
  82         }
  83     };
  84
  85 } // namespace detail
  86 template<class Base, class Derived>
  87 typename detail::base_cast<Base, Derived>::type &
  88 base_object(Derived &d)
  89 {
  90     BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
  91     BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
  92     typedef typename detail::base_cast<Base, Derived>::type type;
  93     detail::base_register<type, Derived>::invoke();
  94     return access::cast_reference<type, Derived>(d);
  95 }
  96
  97 } // namespace serialization
  98 } // namespace boost
  99
 100 #endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP