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