def is_string_type(ot: str):
t = remove_cvref(ot)
if is_array_type(t):
b = array_base(t)
return b in ARRAY_BASES and ARRAY_BASES[
b] == 'str' # special case: string array
try:
return t in STRING_BASE_TYPES
except KeyError:
return False
def cpp_type_to_python(self, ot: str):
"""
convert to basic type combination
:param t: full name of type
:return:
"""
t = ot
t = remove_cvref(t)
t = self._remove_variable_type_prefix(t)
try:
return cpp_base_type_to_python(t)
except KeyError:
pass
if is_function_pointer_type(t):
func = function_pointer_type_info(t)
args = ",".join(
[self.cpp_type_to_python(arg.type) for arg in func.args])
return f'Callable[[{args}], {self.cpp_type_to_python(func.ret_type)}]'
if is_pointer_type(t):
cpp_base = self.resolve_to_basic_type_remove_const(pointer_base(t))
if is_pointer_type(cpp_base) or is_array_type(cpp_base):
return f'"level 2 pointer:{t}"' # un-convertible: level 2 pointer
if cpp_base in ARRAY_BASES:
return ARRAY_BASES[cpp_base]
return self.cpp_type_to_python(cpp_base)
if is_array_type(t):
b = array_base(t)
if b in ARRAY_BASES: # special case: string array
return ARRAY_BASES[b]
base = self.cpp_type_to_python(b)
return f'List[{base}]'
if is_tuple_type(t):
es = tuple_elements(t)
bases = [self.cpp_type_to_python(i) for i in es]
bases_str = ",".join(bases)
return f'Tuple[{bases_str}]'
# check classes
objects = self.objects
if t in objects:
o = objects[t]
if isinstance(o, GeneratorClass) or isinstance(o, GeneratorEnum):
return t.replace("::", ".").strip(" .") # todo fix this
if isinstance(o, GeneratorTypedef):
return self.cpp_type_to_python(o.target)
if t.startswith("(anonymous"):
return f'"{t}"'
# this means this is
logger.warning(
"%s might be an internal symbol, failed to resolve to basic type",
t)
return t
def resolve_to_basic_type_remove_const(self, ot: str):
t = remove_cvref(ot)
if is_pointer_type(t):
return self.resolve_to_basic_type_remove_const(pointer_base(t)) + " *"
if is_array_type(t):
base = self.resolve_to_basic_type_remove_const(array_base(t))
if is_std_vector(t):
return f'std::vector<{self.resolve_to_basic_type_remove_const(base)}>'
return f'{base} [{array_count_str(t)}]'
try:
obj = self.objects[t]
if isinstance(obj, GeneratorTypedef) and obj.full_name != obj.target:
return self.resolve_to_basic_type_remove_const(obj.target)
except KeyError:
pass
return t
def is_integer_type(ot: str):
t = remove_cvref(ot)
try:
return cpp_base_type_to_python(t) == 'int'
except KeyError:
return False
def cpp_base_type_to_pybind11(t: str):
t = remove_cvref(t)
return PYTHON_TYPE_TO_PYBIND11[cpp_base_type_to_python(t)]
def cpp_base_type_to_python(ot: str):
return CPP_BASE_TYPE_TO_PYTHON[remove_cvref(ot)]
def is_tuple_type(ot: str):
t = remove_cvref(ot)
return t.startswith('std::tuple<')