ceph/src/boost/libs/parameter/test/literate/deduced-template-parameters0.cpp

   1
   2 #include <boost/parameter.hpp>
   3 #include <boost/mpl/is_sequence.hpp>
   4 #include <boost/noncopyable.hpp>
   5 #include <memory>
   6 #include <boost/config.hpp>
   7
   8 using namespace boost::parameter;
   9 using boost::mpl::_;
  10
  11 namespace boost { namespace python {
  12
  13 BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
  14 BOOST_PARAMETER_TEMPLATE_KEYWORD(base_list)
  15 BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
  16 BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)
  17
  18 }}
  19 namespace boost { namespace python {
  20
  21 namespace detail { struct bases_base {}; }
  22
  23 template <class A0 = void, class A1 = void, class A2 = void  >
  24 struct bases : detail::bases_base
  25 {};
  26
  27 }}
  28
  29
  30 #include <boost/type_traits/is_class.hpp>
  31 namespace boost { namespace python {
  32 typedef parameter::parameters<
  33     required<tag::class_type, is_class<_> >
  34
  35   , parameter::optional<
  36         deduced<tag::base_list>
  37       , is_base_and_derived<detail::bases_base,_>
  38     >
  39
  40   , parameter::optional<
  41         deduced<tag::held_type>
  42       , mpl::not_<
  43             mpl::or_<
  44                 is_base_and_derived<detail::bases_base,_>
  45               , is_same<noncopyable,_>
  46             >
  47         >
  48     >
  49
  50   , parameter::optional<deduced<tag::copyable>, is_same<noncopyable,_> >
  51
  52 > class_signature;
  53 template <
  54     class A0
  55   , class A1 = parameter::void_
  56   , class A2 = parameter::void_
  57   , class A3 = parameter::void_
  58 >
  59 struct class_
  60 {
  61     // Create ArgumentPack
  62     typedef typename
  63       class_signature::bind<A0,A1,A2,A3>::type
  64     args;
  65
  66     // Extract first logical parameter.
  67     typedef typename parameter::value_type<
  68       args, tag::class_type>::type class_type;
  69
  70     typedef typename parameter::value_type<
  71       args, tag::base_list, bases<> >::type base_list;
  72
  73     typedef typename parameter::value_type<
  74       args, tag::held_type, class_type>::type held_type;
  75
  76     typedef typename parameter::value_type<
  77       args, tag::copyable, void>::type copyable;
  78 };
  79
  80 }}
  81
  82
  83
  84 struct B {};
  85 struct D {};
  86
  87 using boost::python::bases;
  88 typedef boost::python::class_<B, boost::noncopyable> c1;
  89
  90 #if defined(BOOST_NO_CXX11_SMART_PTR)
  91
  92 typedef boost::python::class_<D, std::auto_ptr<D>, bases<B> > c2;
  93
  94 #else
  95
  96 typedef boost::python::class_<D, std::unique_ptr<D>, bases<B> > c2;
  97
  98 #endif
  99
 100 BOOST_MPL_ASSERT((boost::is_same<c1::class_type, B>));
 101 BOOST_MPL_ASSERT((boost::is_same<c1::base_list, bases<> >));
 102 BOOST_MPL_ASSERT((boost::is_same<c1::held_type, B>));
 103 BOOST_MPL_ASSERT((
 104      boost::is_same<c1::copyable, boost::noncopyable>
 105 ));
 106
 107 BOOST_MPL_ASSERT((boost::is_same<c2::class_type, D>));
 108 BOOST_MPL_ASSERT((boost::is_same<c2::base_list, bases<B> >));
 109
 110 #if defined(BOOST_NO_CXX11_SMART_PTR)
 111
 112 BOOST_MPL_ASSERT((
 113     boost::is_same<c2::held_type, std::auto_ptr<D> >
 114 ));
 115
 116 #else
 117
 118 BOOST_MPL_ASSERT((
 119     boost::is_same<c2::held_type, std::unique_ptr<D> >
 120 ));
 121
 122 #endif
 123
 124 BOOST_MPL_ASSERT((boost::is_same<c2::copyable, void>));