def generate_instantiation_function(self,
global_indent="",
has_functions=False):
"""
void define...Classes(py::module &m) { ... }
"""
s = []
a = s.append
i = INDENT
a("{ind}void define{sub}{name}Classes(py::module &{base}) {ob}")
for line in self.generate_templated_class_calls():
a("{ind}{i}%s;" % line)
if has_functions:
a("{ind}{i}define{sub}{name}Functions({base});")
for var in self.variables:
a("{ind}{i}%s" % define_variable(var))
for enum in self.enums:
enum = Enum(enum)
a("{ind}{i}%s;" % enum.to_str(prefix=enum.cppenum["namespace"],
class_var_name=BASE_SUB_MODULE_NAME))
a("{ind}{cb}")
data = {
"ind": global_indent,
"i": i,
"base": BASE_SUB_MODULE_NAME,
"name": function_definition_name(self.header_name),
"sub": camelize(self.module),
"ob": "{",
"cb": "}"
}
return "\n".join([line.format(**data) for line in s])
def generate_loader(module, headers):
lines = [common_includes]
a = lines.append
a(cpp_header)
for header in headers:
inc_name = '%s/%s' % (module, header) if module != "base" else header
include_expression = '#include "%spp"' % (inc_name, )
a(include_expression)
a("\n")
a("void define%sClasses(py::module &m) {" % camelize(module))
# add submodule
submodule_object_name = ("m_%s" % module) if module != "base" else "m"
module_python = module if module != "2d" else "module_2d"
if submodule_object_name != "m":
module_creation = '{i}py::module {obj_name} = m.def_submodule("{module_python}", "Submodule {sub}");'
a(
module_creation.format(obj_name=submodule_object_name,
module_python=module_python,
sub=module,
i=INDENT))
# add function calls
sub = camelize(module) if module != "base" else ""
for header in headers:
name = function_definition_name(header_name=header)
function_call = "{i}define{sub}{name}Classes({sub_name});".format(
i=INDENT, name=name, sub_name=submodule_object_name, sub=sub)
a(function_call)
a("}")
return "\n".join(lines)
def generate_function_definitions(cppfunctions: List[CppMethod],
module_name,
header_name,
indent="",
not_every_point_type=False):
cppfunctions = filter_functions(cppfunctions, header_name)
cppfunctions = list(sorted(cppfunctions, key=lambda x: x["name"]))
cppfunctions, cppfunctions_with_other_templated = split_templated_functions_with_same_name(
cppfunctions)
functions = [Method(f, is_an_overload=True) for f in cppfunctions]
for f in cppfunctions_with_other_templated:
functions.append(Method(f, is_an_overload=True, use_c_overload=True))
s = []
a = s.append
i = INDENT
# group functions by template types
templated_functions_grouped = defaultdict(list)
for f in functions:
template = f.cppmethod["template"]
if template:
template = template.replace("\n", "")
pos = template.find("<")
template_types = filter_template_types(template[pos + 1:-1],
keep=["typename", "class"])
all_templated_types = filter_template_types(template[pos + 1:-1],
keep_all=True)
f.templated_types = OrderedDict(
((t, [t]) for t in all_templated_types))
templated_functions_grouped[template_types].append(f)
else:
templated_functions_grouped[tuple()].append(f)
templated_functions_grouped = OrderedDict(
sorted(templated_functions_grouped.items()))
for n, (type_names,
group) in enumerate(templated_functions_grouped.items(), 1):
if type_names:
a(group[0].cppmethod.get("template"))
a("{ind}void define{sub}{name}Functions%s(py::module &m) {ob}" % n)
for f in group:
function_prefix = f.cppmethod["namespace"]
function_prefix = function_prefix[:-2] if function_prefix.endswith(
"::") else function_prefix
value = f.to_str(function_prefix, "m")
if f.templated_types:
value = value[0]
a("{ind}{i}%s;" % value)
a("{cb}")
a("")
a("{ind}void define{sub}{name}Functions(py::module &m) {ob}")
for n, (type_names,
group) in enumerate(templated_functions_grouped.items(), 1):
if type_names:
types = [
t[1] for t in template_types_generator(
type_names, header_name, group[0].cppmethod["name"])
]
if isinstance(types[0], str):
all_types = filter_types(
types) if not_every_point_type else types
elif isinstance(types[0], list):
if not_every_point_type:
types = list(map(filter_types, types))
all_types = list(product(*types))
else:
raise NotImplementedError
for t in all_types:
a("{ind}{i}define{sub}{name}Functions%s<%s>(m);" %
(n, ", ".join(t)))
else:
a("{ind}{i}define{sub}{name}Functions%s(m);" % (n, ))
a("{ind}{cb}")
a("")
data = {
"ind": indent,
"i": i,
"name": function_definition_name(header_name),
"sub": camelize(module_name),
"ob": "{",
"cb": "}"
}
return "\n".join([line.format(**data) for line in s])