1
2
3
4
5
6 """Contains definition of call policies classes"""
7
8 import algorithm
9 import python_traits
10 from pygccxml import declarations
19
21 """base class for all classes, which generate "call policies" code"""
24
26 """Creates code from the call policies class instance.
27 @param function_creator: parent code creator
28 @type function_creator: L{code_creators.function_t} or L{code_creators.constructor_t}
29
30 @param creation_policy: indicates whether we this call policy used as template
31 argument or as an instance
32 @type creation_policy: L{CREATION_POLICY}
33 """
34 code = self._create_impl( function_creator )
35 if code and creation_policy == CREATION_POLICY.AS_INSTANCE:
36 code = code + '()'
37 return code
38
42
46
48 """return True is self is instance of L{default_call_policies_t} class"""
49 return False
50
52 """return True if call policy is defined in Boost.Python library, False otherwise"""
53 return True
54
56 raise NotImplementedError()
57
58 @property
60 """return a name of the header file the call policy is defined in"""
61 return "boost/python.hpp"
62
64 """implements code generation for boost::python::default_call_policies"""
67
70
73
75 return 'default_call_policies'
76
78 """create ::boost::python::default_call_policies call policies code generator"""
79 return default_call_policies_t()
80
82 """base class for all call policies, except the default one"""
88
92 self._base = new_policy
93 base_policy = property( _get_base_policy, _set_base_policy
94 , doc="base call policy, by default is reference to L{default_call_policies_t} call policy")
95
98
100 raise NotImplementedError()
101
108
114
116 """implements code generation for boost::python::return_argument call policies"""
117 - def __init__( self, position=1, base=None):
120
122 return self._position
124 self._position = new_position
125 position = property( _get_position, _set_position )
126
128 if self.position == 1:
129 return '::boost::python::return_self'
130 else:
131 return '::boost::python::return_arg'
132
134 if self.position == 1:
135 return []
136 else:
137 return [ str( self.position ) ]
138
140 """create boost::python::return_arg call policies code generator"""
141 return return_argument_t( arg_pos, base )
142
144 """create boost::python::return_self call policies code generator"""
145 return return_argument_t( 1, base )
146
148 """implements code generation for boost::python::return_internal_reference call policies"""
149 - def __init__( self, position=1, base=None):
152
154 return self._position
156 self._position = new_position
157 position = property( _get_position, _set_position )
158
160 return '::boost::python::return_internal_reference'
161
163 if self.position == 1:
164 return []
165 else:
166 return [ str( self.position ) ]
167
171
173 """implements code generation for boost::python::with_custodian_and_ward call policies"""
174 - def __init__( self, custodian, ward, base=None):
178
180 return self._custodian
182 self._custodian = new_custodian
183 custodian = property( _get_custodian, _set_custodian )
184
188 self._ward = new_ward
189 ward = property( _get_ward, _set_ward )
190
192 return '::boost::python::with_custodian_and_ward'
193
196
200
201 -class with_custodian_and_ward_postcall_t( with_custodian_and_ward_t ):
202 """implements code generation for boost::python::with_custodian_and_ward_postcall call policies"""
203 - def __init__( self, custodian, ward, base=None):
205
206 - def _get_name(self, function_creator):
207 return '::boost::python::with_custodian_and_ward_postcall'
208
209 -def with_custodian_and_ward_postcall( custodian, ward, base=None):
210 """create boost::python::with_custodian_and_ward_postcall call policies code generator"""
211 return with_custodian_and_ward_postcall_t( custodian, ward, base )
212
252
253
254 copy_const_reference = '::boost::python::copy_const_reference'
255 copy_non_const_reference = '::boost::python::copy_non_const_reference'
256 manage_new_object = '::boost::python::manage_new_object'
257 reference_existing_object = '::boost::python::reference_existing_object'
258 return_by_value = '::boost::python::return_by_value'
259 return_opaque_pointer = '::boost::python::return_opaque_pointer'
260 return_pointee_value = '::pyplusplus::call_policies::return_pointee_value'
261 return_addressof = '::pyplusplus::call_policies::return_addressof'
266
271
273 """implements code generation for user defined call policies"""
274 - def __init__( self, call_policies, header_file=None ):
278
280 return str( self.__call_policies )
281
283 return 'custom call policies'
284
286 return self.__header_file
288 self.__header_file = header_file_name
289 header_file = property( get_header_file, set_header_file
290 , doc="""Return name of the header file to be included""" )
291
295
297 """implements code generation for Py++ defined memory managers
298
299 For complete documentation and usage example see http://language-binding.net/pyplusplus/documentation/functions/call_policies.html
300 """
301 none = 'none'
302 delete_ = 'delete_'
303 all = [ none, delete_ ]
304
305 @staticmethod
306 - def create( manager, function_creator=None):
307 mem_manager = 'pyplusplus::call_policies::memory_managers::' + manager
308 if function_creator:
309 mem_manager = algorithm.create_identifier( function_creator, mem_manager )
310 return mem_manager
311
313 """implements code generation for Py++ defined "as_tuple" value policy
314
315 For complete documentation and usage example see http://language-binding.net/pyplusplus/documentation/functions/call_policies.html
316 """
317 - def __init__( self, array_size, memory_manager, make_object_call_policies=None, base=None):
322
324 """Returns True if call policy is defined in Boost.Python library, False otherwise"""
325 return False
326
327 @property
331
333 return self._array_size
335 self._array_size = new_array_size
336 array_size = property( _get_array_size, _set_array_size )
337
339 return self._memory_manager
341 self._memory_manager = new_memory_manager
342 memory_manager = property( _get_memory_manager, _set_memory_manager )
343
345 if None is self._make_objec_call_policies:
346 self._make_objec_call_policies = default_call_policies()
347 return self._make_objec_call_policies
349 self._make_objec_call_policies = new_make_objec_call_policies
350 make_objec_call_policies = property( _get_make_objec_call_policies, _set_make_objec_call_policies )
351
353 return '::boost::python::return_value_policy'
354
364
368
370 """implements code generation for Py++ defined "return_range" call policies
371
372 For complete documentation and usage example see http://language-binding.net/pyplusplus/documentation/functions/call_policies.html
373 """
374 HEADER_FILE = "__return_range.pypp.hpp"
375 - def __init__( self, get_size_class, value_type, value_policies):
380
382 """Returns True if call policy is defined in Boost.Python library, False otherwise"""
383 return False
384
385 @property
387 """Return name of the header file to be included"""
388 return self.HEADER_FILE
389
391 return self._get_size_class
393 self._get_size_class = new_get_size_class
394 get_size_class = property( _get_get_size_class, _set_get_size_class )
395
397 return self._value_type
399 self._value_type = new_value_type
400 value_type = property( _get_value_type, _set_value_type )
401
403 return self._value_policies
405 self._value_policies = new_value_policies
406 value_policies = property( _get_value_policies, _set_value_policies )
407
414
415 -def return_range( function, get_size_class, value_policies=None ):
429