ceph/src/boost/boost/python/detail/defaults_def.hpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 // Copyright David Abrahams 2002, Joel de Guzman, 2002.
   4 // Distributed under the Boost Software License, Version 1.0. (See
   5 // accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt)
   7 //
   8 ///////////////////////////////////////////////////////////////////////////////
   9 #if !defined(BOOST_PP_IS_ITERATING)
  10
  11 #ifndef DEFAULTS_DEF_JDG20020811_HPP
  12 #define DEFAULTS_DEF_JDG20020811_HPP
  13
  14 #include <boost/python/detail/defaults_gen.hpp>
  15 #include <boost/python/detail/type_traits.hpp>
  16 #include <boost/mpl/front.hpp>
  17 #include <boost/mpl/size.hpp>
  18 #include <boost/static_assert.hpp>
  19 #include <boost/preprocessor/iterate.hpp>
  20 #include <boost/python/class_fwd.hpp>
  21 #include <boost/python/scope.hpp>
  22 #include <boost/preprocessor/debug/line.hpp>
  23 #include <boost/python/detail/scope.hpp>
  24 #include <boost/python/detail/make_keyword_range_fn.hpp>
  25 #include <boost/python/object/add_to_namespace.hpp>
  26
  27 ///////////////////////////////////////////////////////////////////////////////
  28 namespace boost { namespace python {
  29
  30 struct module;
  31
  32 namespace objects
  33 {
  34   struct class_base;
  35 }
  36
  37 namespace detail
  38 {
  39   // Called as::
  40   //
  41   //    name_space_def(ns, "func", func, kw, policies, docstring, &ns)
  42   //
  43   // Dispatch to properly add f to namespace ns.
  44   //
  45   // @group define_stub_function helpers {
  46   template <class Func, class CallPolicies, class NameSpaceT>
  47   static void name_space_def(
  48       NameSpaceT& name_space
  49       , char const* name
  50       , Func f
  51       , keyword_range const& kw
  52       , CallPolicies const& policies
  53       , char const* doc
  54       , objects::class_base*
  55       )
  56   {
  57       typedef typename NameSpaceT::wrapped_type wrapped_type;
  58
  59       objects::add_to_namespace(
  60           name_space, name,
  61           detail::make_keyword_range_function(
  62               f, policies, kw, get_signature(f, (wrapped_type*)0))
  63         , doc
  64       );
  65   }
  66
  67   template <class Func, class CallPolicies>
  68   static void name_space_def(
  69       object& name_space
  70       , char const* name
  71       , Func f
  72       , keyword_range const& kw
  73       , CallPolicies const& policies
  74       , char const* doc
  75       , ...
  76       )
  77   {
  78       scope within(name_space);
  79
  80       detail::scope_setattr_doc(
  81           name
  82           , detail::make_keyword_range_function(f, policies, kw)
  83           , doc);
  84   }
  85
  86   // For backward compatibility -- is this obsolete?
  87   template <class Func, class CallPolicies, class NameSpaceT>
  88   static void name_space_def(
  89       NameSpaceT& name_space
  90       , char const* name
  91       , Func f
  92       , keyword_range const& kw // ignored
  93       , CallPolicies const& policies
  94       , char const* doc
  95       , module*
  96       )
  97   {
  98       name_space.def(name, f, policies, doc);
  99   }
 100   // }
 101
 102
 103   //  Expansions of ::
 104   //
 105   //      template <typename OverloadsT, typename NameSpaceT>
 106   //      inline void
 107   //      define_stub_function(
 108   //          char const* name, OverloadsT s, NameSpaceT& name_space, mpl::int_<N>)
 109   //      {
 110   //          name_space.def(name, &OverloadsT::func_N);
 111   //      }
 112   //
 113   //  where N runs from 0 to BOOST_PYTHON_MAX_ARITY.
 114   //
 115   //  The set of overloaded functions (define_stub_function) expects:
 116   //
 117   //      1. char const* name:        function name that will be visible to python
 118   //      2. OverloadsT:              a function overloads struct (see defaults_gen.hpp)
 119   //      3. NameSpaceT& name_space:  a python::class_ or python::module instance
 120   //      4. int_t<N>:                the Nth overloaded function (OverloadsT::func_N)
 121   //                                  (see defaults_gen.hpp)
 122   //      5. char const* name:        doc string
 123   //
 124   // @group define_stub_function<N> {
 125   template <int N>
 126   struct define_stub_function {};
 127
 128 #define BOOST_PP_ITERATION_PARAMS_1                                             \
 129     (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/defaults_def.hpp>))
 130
 131 #include BOOST_PP_ITERATE()
 132
 133   // }
 134
 135   //  This helper template struct does the actual recursive
 136   //  definition.  There's a generic version
 137   //  define_with_defaults_helper<N> and a terminal case
 138   //  define_with_defaults_helper<0>. The struct and its
 139   //  specialization has a sole static member function def that
 140   //  expects:
 141   //
 142   //    1. char const* name:        function name that will be
 143   //                                visible to python
 144   //
 145   //    2. OverloadsT:              a function overloads struct
 146   //                                (see defaults_gen.hpp)
 147   //
 148   //    3. NameSpaceT& name_space:  a python::class_ or
 149   //                                python::module instance
 150   //
 151   //    4. char const* name:        doc string
 152   //
 153   //  The def static member function calls a corresponding
 154   //  define_stub_function<N>. The general case recursively calls
 155   //  define_with_defaults_helper<N-1>::def until it reaches the
 156   //  terminal case case define_with_defaults_helper<0>.
 157   template <int N>
 158   struct define_with_defaults_helper {
 159
 160       template <class StubsT, class CallPolicies, class NameSpaceT>
 161       static void
 162       def(
 163           char const* name,
 164           StubsT stubs,
 165           keyword_range kw,
 166           CallPolicies const& policies,
 167           NameSpaceT& name_space,
 168           char const* doc)
 169       {
 170           //  define the NTH stub function of stubs
 171           define_stub_function<N>::define(name, stubs, kw, policies, name_space, doc);
 172
 173           if (kw.second > kw.first)
 174               --kw.second;
 175
 176           //  call the next define_with_defaults_helper
 177           define_with_defaults_helper<N-1>::def(name, stubs, kw, policies, name_space, doc);
 178       }
 179   };
 180
 181   template <>
 182   struct define_with_defaults_helper<0> {
 183
 184       template <class StubsT, class CallPolicies, class NameSpaceT>
 185       static void
 186       def(
 187           char const* name,
 188           StubsT stubs,
 189           keyword_range const& kw,
 190           CallPolicies const& policies,
 191           NameSpaceT& name_space,
 192           char const* doc)
 193       {
 194           //  define the Oth stub function of stubs
 195           define_stub_function<0>::define(name, stubs, kw, policies, name_space, doc);
 196           //  return
 197       }
 198   };
 199
 200   //  define_with_defaults
 201   //
 202   //      1. char const* name:        function name that will be
 203   //                                  visible to python
 204   //
 205   //      2. OverloadsT:              a function overloads struct
 206   //                                  (see defaults_gen.hpp)
 207   //
 208   //      3. CallPolicies& policies:  Call policies
 209   //      4. NameSpaceT& name_space:  a python::class_ or
 210   //                                  python::module instance
 211   //
 212   //      5. SigT sig:                Function signature typelist
 213   //                                  (see defaults_gen.hpp)
 214   //
 215   //      6. char const* name:        doc string
 216   //
 217   //  This is the main entry point. This function recursively
 218   //  defines all stub functions of StubT (see defaults_gen.hpp) in
 219   //  NameSpaceT name_space which can be either a python::class_ or
 220   //  a python::module. The sig argument is a typelist that
 221   //  specifies the return type, the class (for member functions,
 222   //  and the arguments. Here are some SigT examples:
 223   //
 224   //      int foo(int)        mpl::vector<int, int>
 225   //      void bar(int, int)  mpl::vector<void, int, int>
 226   //      void C::foo(int)    mpl::vector<void, C, int>
 227   //
 228   template <class OverloadsT, class NameSpaceT, class SigT>
 229   inline void
 230   define_with_defaults(
 231       char const* name,
 232       OverloadsT const& overloads,
 233       NameSpaceT& name_space,
 234       SigT const&)
 235   {
 236       typedef typename mpl::front<SigT>::type return_type;
 237       typedef typename OverloadsT::void_return_type void_return_type;
 238       typedef typename OverloadsT::non_void_return_type non_void_return_type;
 239
 240       typedef typename mpl::if_c<
 241           is_same<void, return_type>::value
 242           , void_return_type
 243           , non_void_return_type
 244       >::type stubs_type;
 245
 246       BOOST_STATIC_ASSERT(
 247           (stubs_type::max_args) <= mpl::size<SigT>::value);
 248
 249       typedef typename stubs_type::template gen<SigT> gen_type;
 250       define_with_defaults_helper<stubs_type::n_funcs-1>::def(
 251           name
 252           , gen_type()
 253           , overloads.keywords()
 254           , overloads.call_policies()
 255           , name_space
 256           , overloads.doc_string());
 257   }
 258
 259 } // namespace detail
 260
 261 }} // namespace boost::python
 262
 263 #endif // DEFAULTS_DEF_JDG20020811_HPP
 264
 265 #else // defined(BOOST_PP_IS_ITERATING)
 266 // PP vertical iteration code
 267
 268
 269 template <>
 270 struct define_stub_function<BOOST_PP_ITERATION()> {
 271     template <class StubsT, class CallPolicies, class NameSpaceT>
 272     static void define(
 273         char const* name
 274         , StubsT const&
 275         , keyword_range const& kw
 276         , CallPolicies const& policies
 277         , NameSpaceT& name_space
 278         , char const* doc)
 279     {
 280         detail::name_space_def(
 281             name_space
 282             , name
 283             , &StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION())
 284             , kw
 285             , policies
 286             , doc
 287             , &name_space);
 288     }
 289 };
 290
 291 #endif // !defined(BOOST_PP_IS_ITERATING)