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<')