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

   1 #ifndef BOOST_SERIALIZATION_FACTORY_HPP
   2 #define BOOST_SERIALIZATION_FACTORY_HPP
   3
   4 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
   5 // MS compatible compilers support #pragma once
   6 #if defined(_MSC_VER)
   7 # pragma once
   8 #endif
   9
  10 // factory.hpp: create an instance from an extended_type_info instance.
  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 #include <cstdarg> // valist
  20 #include <cstddef> // NULL
  21
  22 #include <boost/preprocessor/control/if.hpp>
  23 #include <boost/preprocessor/comparison/greater.hpp>
  24
  25 namespace std{
  26     #if defined(__LIBCOMO__)
  27         using ::va_list;
  28     #endif
  29 } // namespace std
  30
  31 namespace boost {
  32 namespace serialization {
  33
  34 // default implementation does nothing.
  35 template<class T, int N>
  36 T * factory(std::va_list){
  37     BOOST_ASSERT(false);
  38     // throw exception here?
  39     return NULL;
  40 }
  41
  42 } // namespace serialization
  43 } // namespace boost
  44
  45 #define BOOST_SERIALIZATION_FACTORY(N, T, A0, A1, A2, A3) \
  46 namespace boost {                                         \
  47 namespace serialization {                                 \
  48     template<>                                            \
  49     T * factory<T, N>(std::va_list ap){                   \
  50         BOOST_PP_IF(BOOST_PP_GREATER(N,0)                 \
  51             ,A0 a0 = va_arg(ap, A0);                      \
  52         ,BOOST_PP_IF(BOOST_PP_GREATER(N,1)                \
  53             ,A1 a1 = va_arg(ap, A1);                      \
  54         ,BOOST_PP_IF(BOOST_PP_GREATER(N,2)                \
  55             ,A2 a2 = va_arg(ap, A2);                      \
  56         ,BOOST_PP_IF(BOOST_PP_GREATER(N,3)                \
  57             ,A3 a3 = va_arg(ap, A3);                      \
  58             ,BOOST_PP_EMPTY()                             \
  59         ))))                                              \
  60         return new T(                                     \
  61             BOOST_PP_IF(BOOST_PP_GREATER(N,0)             \
  62                 ,a0                                       \
  63             ,BOOST_PP_IF(BOOST_PP_GREATER(N,1)            \
  64                 ,a1                                       \
  65             ,BOOST_PP_IF(BOOST_PP_GREATER(N,2)            \
  66                 ,a2                                       \
  67             ,BOOST_PP_IF(BOOST_PP_GREATER(N,3)            \
  68                 ,a3                                       \
  69                 ,BOOST_PP_EMPTY()                         \
  70             ))))                                          \
  71         );                                                \
  72     }                                                     \
  73 }                                                         \
  74 }                                                         \
  75 /**/
  76
  77 #define BOOST_SERIALIZATION_FACTORY_4(T, A0, A1, A2, A3) \
  78     BOOST_SERIALIZATION_FACTORY(4, T, A0, A1, A2, A3)
  79
  80 #define BOOST_SERIALIZATION_FACTORY_3(T, A0, A1, A2)     \
  81     BOOST_SERIALIZATION_FACTORY(3, T, A0, A1, A2, 0)
  82
  83 #define BOOST_SERIALIZATION_FACTORY_2(T, A0, A1)         \
  84     BOOST_SERIALIZATION_FACTORY(2, T, A0, A1, 0, 0)
  85
  86 #define BOOST_SERIALIZATION_FACTORY_1(T, A0)             \
  87     BOOST_SERIALIZATION_FACTORY(1, T, A0, 0, 0, 0)
  88
  89 #define BOOST_SERIALIZATION_FACTORY_0(T)                 \
  90 namespace boost {                                        \
  91 namespace serialization {                                \
  92     template<>                                           \
  93     T * factory<T, 0>(std::va_list){                     \
  94         return new T();                                  \
  95     }                                                    \
  96 }                                                        \
  97 }                                                        \
  98 /**/
  99
 100 #endif // BOOST_SERIALIZATION_FACTORY_HPP