]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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) |