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