← Back to branch summary

~tsarev/boostdc/cmake

« back to all changes in this revision

Viewing changes to boost/boost/python/detail/defaults_def.hpp

  • Committer: bigmuscle
  • Date: 2010-05-08 08:47:15 UTC
  • Revision ID: svn-v4:5fb55d53-692c-0410-a46a-e90ab66e00ee:trunk:497
removed old boost version

Show diffs side-by-side

added added

removed removed

Lines of Context:
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/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
 
          boost::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)