def register_alias(self, alias):
"""Re-register the class with another base name, in addition to any
registrations that might have already been done."""
self.module.register_type(None, alias, self)
self.ThisContainerParameter.CTYPES.append(alias)
try:
param_type_matcher.register(alias, self.ThisContainerParameter)
except ValueError: pass
self.ThisContainerRefParameter.CTYPES.append(alias+'&')
try:
param_type_matcher.register(alias+'&', self.ThisContainerRefParameter)
except ValueError: pass
self.ThisContainerReturn.CTYPES.append(alias)
try:
return_type_matcher.register(alias, self.ThisContainerReturn)
except ValueError: pass
def __init__(self,
name,
value_type,
container_type,
outer_class=None,
custom_name=None):
"""
:param name: C++ type name of the container, e.g. std::vector<int> or MyIntList
:param value_type: a ReturnValue of the element type: note,
for mapping containers, value_type is a tuple with two
ReturnValue's: (key, element).
:param container_type: a string with the type of container,
one of 'list', 'deque', 'queue', 'priority_queue',
'vector', 'stack', 'set', 'multiset', 'hash_set',
'hash_multiset', 'map'
:param outer_class: if the type is defined inside a class, must be a reference to the outer class
:type outer_class: None or L{CppClass}
:param custom_name: alternative name to register with in the Python module
"""
if '<' in name or '::' in name:
self.name = utils.mangle_name(name)
self.full_name = name
self._full_name_is_definitive = True
else:
self._full_name_is_definitive = False
self.full_name = None
self.name = name
self._module = None
self.outer_class = outer_class
self.mangled_name = None
self.mangled_full_name = None
self.container_traits = container_traits_list[container_type]
self.custom_name = custom_name
self._pystruct = None
self.pytypestruct = "***GIVE ME A NAME***"
self.pytype = PyTypeObject()
self.iter_pytypestruct = "***GIVE ME A NAME***"
self.iter_pytype = PyTypeObject()
self._iter_pystruct = None
if self.container_traits.is_mapping:
(key_type, value_type) = value_type
self.key_type = utils.eval_retval(key_type, self)
self.value_type = utils.eval_retval(value_type, self)
else:
self.key_type = None
self.value_type = utils.eval_retval(value_type, self)
self.python_to_c_converter = None
if name != 'dummy':
## register type handlers
class ThisContainerParameter(ContainerParameter):
"""Register this C++ container as pass-by-value parameter"""
CTYPES = []
container_type = self
self.ThisContainerParameter = ThisContainerParameter
try:
param_type_matcher.register(name, self.ThisContainerParameter)
except ValueError:
pass
class ThisContainerRefParameter(ContainerRefParameter):
"""Register this C++ container as pass-by-value parameter"""
CTYPES = []
container_type = self
self.ThisContainerRefParameter = ThisContainerRefParameter
try:
param_type_matcher.register(name + '&',
self.ThisContainerRefParameter)
except ValueError:
pass
class ThisContainerPtrParameter(ContainerPtrParameter):
"""Register this C++ container as pass-by-ptr parameter"""
CTYPES = []
container_type = self
self.ThisContainerPtrParameter = ThisContainerPtrParameter
try:
param_type_matcher.register(name + '*',
self.ThisContainerPtrParameter)
except ValueError:
pass
class ThisContainerReturn(ContainerReturnValue):
"""Register this C++ container as value return"""
CTYPES = []
container_type = self
self.ThisContainerReturn = ThisContainerReturn
self.ThisContainerRefReturn = ThisContainerReturn
try:
return_type_matcher.register(name, self.ThisContainerReturn)
return_type_matcher.register(name, self.ThisContainerRefReturn)
except ValueError:
pass
def set_module(self, module):
"""Set the Module object this class belongs to; can only be set once"""
assert self._module is None
self._module = module
if not self.name:
return
if self.outer_class is None:
if self._module.cpp_namespace_prefix:
if self._module.cpp_namespace_prefix == '::':
self.full_name = '::' + self.name
else:
self.full_name = self._module.cpp_namespace_prefix + '::' + self.name
else:
self.full_name = self.name
else:
self.full_name = '::'.join([self.outer_class.full_name, self.name])
## Register type handlers for the enum type
assert self.name
assert self.full_name
class ThisEnumParameter(inttype.IntParam):
CTYPES = []
full_type_name = self.full_name
def __init__(self, ctype, name, *args, **kwargs):
super(ThisEnumParameter, self).__init__(self.full_type_name, name, *args, **kwargs)
class ThisEnumReturn(inttype.IntReturn):
CTYPES = []
full_type_name = self.full_name
def __init__(self, ctype, *args, **kwargs):
super(ThisEnumReturn, self).__init__(self.full_type_name, *args, **kwargs)
class ThisEnumRefParameter(inttype.IntRefParam):
CTYPES = []
full_type_name = self.full_name + " &"
def __init__(self, ctype, name, *args, **kwargs):
super(ThisEnumRefParameter, self).__init__(self.full_type_name, name, *args, **kwargs)
class ThisEnumPtrParameter(inttype.IntPtrParam):
CTYPES = []
full_type_name = self.full_name + " *"
def __init__(self, ctype, name, *args, **kwargs):
super(ThisEnumPtrParameter, self).__init__(self.full_type_name, name, *args, **kwargs)
self.ThisEnumParameter = ThisEnumParameter
self.ThisEnumReturn = ThisEnumReturn
self.ThisEnumRefParameter = ThisEnumRefParameter
self.ThisEnumPtrParameter = ThisEnumPtrParameter
param_type_matcher.register(self.full_name, self.ThisEnumParameter)
return_type_matcher.register(self.full_name, self.ThisEnumReturn)
param_type_matcher.register(self.full_name + ' &', self.ThisEnumRefParameter)
param_type_matcher.register(self.full_name + ' *', self.ThisEnumPtrParameter)
if self.name != self.full_name:
try:
param_type_matcher.register(self.name, self.ThisEnumParameter)
except ValueError:
pass
try:
return_type_matcher.register(self.name, self.ThisEnumReturn)
except ValueError:
pass
try:
param_type_matcher.register(self.name+' &', self.ThisEnumRefParameter)
except ValueError:
pass
try:
param_type_matcher.register(self.name+' *', self.ThisEnumPtrParameter)
except ValueError:
pass
def __init__(self, name, value_type, container_type, outer_class=None, custom_name=None):
"""
:param name: C++ type name of the container, e.g. std::vector<int> or MyIntList
:param value_type: a ReturnValue of the element type: note,
for mapping containers, value_type is a tuple with two
ReturnValue's: (key, element).
:param container_type: a string with the type of container,
one of 'list', 'deque', 'queue', 'priority_queue',
'vector', 'stack', 'set', 'multiset', 'hash_set',
'hash_multiset', 'map'
:param outer_class: if the type is defined inside a class, must be a reference to the outer class
:type outer_class: None or L{CppClass}
:param custom_name: alternative name to register with in the Python module
"""
if '<' in name or '::' in name:
self.name = utils.mangle_name(name)
self.full_name = name
self._full_name_is_definitive = True
else:
self._full_name_is_definitive = False
self.full_name = None
self.name = name
self._module = None
self.outer_class = outer_class
self.mangled_name = None
self.mangled_full_name = None
self.container_traits = container_traits_list[container_type]
self.custom_name = custom_name
self._pystruct = None
self.pytypestruct = "***GIVE ME A NAME***"
self.pytype = PyTypeObject()
self.iter_pytypestruct = "***GIVE ME A NAME***"
self.iter_pytype = PyTypeObject()
self._iter_pystruct = None
if self.container_traits.is_mapping:
(key_type, value_type) = value_type
self.key_type = utils.eval_retval(key_type, self)
self.value_type = utils.eval_retval(value_type, self)
else:
self.key_type = None
self.value_type = utils.eval_retval(value_type, self)
self.python_to_c_converter = None
if name != 'dummy':
## register type handlers
class ThisContainerParameter(ContainerParameter):
"""Register this C++ container as pass-by-value parameter"""
CTYPES = []
container_type = self
self.ThisContainerParameter = ThisContainerParameter
try:
param_type_matcher.register(name, self.ThisContainerParameter)
except ValueError:
pass
class ThisContainerRefParameter(ContainerRefParameter):
"""Register this C++ container as pass-by-value parameter"""
CTYPES = []
container_type = self
self.ThisContainerRefParameter = ThisContainerRefParameter
try:
param_type_matcher.register(name+'&', self.ThisContainerRefParameter)
except ValueError:
pass
class ThisContainerPtrParameter(ContainerPtrParameter):
"""Register this C++ container as pass-by-ptr parameter"""
CTYPES = []
container_type = self
self.ThisContainerPtrParameter = ThisContainerPtrParameter
try:
param_type_matcher.register(name+'*', self.ThisContainerPtrParameter)
except ValueError:
pass
class ThisContainerReturn(ContainerReturnValue):
"""Register this C++ container as value return"""
CTYPES = []
container_type = self
self.ThisContainerReturn = ThisContainerReturn
self.ThisContainerRefReturn = ThisContainerReturn
try:
return_type_matcher.register(name, self.ThisContainerReturn)
return_type_matcher.register(name, self.ThisContainerRefReturn)
except ValueError:
pass