def generate_method_callback_definition(first_flag, out: FileGenerator, cur_method_generator) -> bool:
add_method_callback_typedef(cur_method_generator)
first_flag = if_required_then_add_empty_line(first_flag, out)
c_argument_declaration_list = [
arg_gen.c_argument_declaration() for arg_gen in cur_method_generator.c_arguments_list]
cur_method_generator.exception_traits.modify_c_arguments(c_argument_declaration_list)
out.put_line('template<typename ImplementationClass>')
out.put_line('{return_type} {top_ns}_API_CONVENTION {callback_name}({arguments})'.format(
top_ns=cur_method_generator.parent_class_generator.full_name_array[0].upper(),
return_type=cur_method_generator.return_type_generator.c_argument_declaration(),
callback_name=get_method_callback_name(cur_method_generator),
arguments=', '.join(c_argument_declaration_list)
))
with IndentScope(out):
out.put_line(
'{const}ImplementationClass* self = static_cast<ImplementationClass*>(object_pointer);'.format(
const='const ' if cur_method_generator.method_object.const else ''
))
wrap_arg_call = [arg_gen.c_2_wrap() for arg_gen in cur_method_generator.argument_generators]
method_call = 'self->{0}({1})'.format(
cur_method_generator.wrap_name,
', '.join(wrap_arg_call))
calling_instructions, return_expression = cur_method_generator.return_type_generator.wrap_2_c_var(
'', method_call)
if return_expression:
calling_instructions.append('return {0};'.format(return_expression))
cur_method_generator.exception_traits.generate_callback_call(
out,
cur_method_generator.return_type_generator,
calling_instructions)
return first_flag
def __generate_method_definitions(self, definition_header, first_method):
for method_generator in self.method_generators:
first_method = if_required_then_add_empty_line(
first_method, definition_header)
method_generator.generate_wrap_definition(definition_header)
method_generator.include_dependent_definition_headers(
definition_header, self.file_cache)
def __generate_capi_impl(self, out: FileGenerator):
plain_functions_list = []
for namespace_name, namespace_info in self.sorted_by_ns.items():
for c_function in namespace_info.c_functions:
plain_functions_list.append((namespace_name, namespace_info, c_function))
if not self.params.open_api:
random.shuffle(plain_functions_list)
first_function = True
for namespace_name, namespace_info, c_function in plain_functions_list:
self.cur_namespace_name = namespace_name
self.cur_namespace_info = namespace_info
first_function = if_required_then_add_empty_line(first_function, out)
generated_name = c_function.name
if not self.params.open_api:
generated_name = get_c_name('fx' + str(uuid.uuid4()))
if namespace_name not in self.api_keys:
self.api_keys.update({namespace_name: {}})
self.api_keys[namespace_name][c_function.name] = generated_name
out.put_line('{api} {return_type} {convention} {name}({arguments})'.format(
api=self.cur_api_define,
return_type=c_function.return_type,
convention=self.cur_api_convention,
name=generated_name,
arguments=c_function.arguments))
out.put_file(c_function.body)
def __generate_constructor_definitions(self, definition_header,
first_method):
for constructor_generator in self.constructor_generators:
first_method = if_required_then_add_empty_line(
first_method, definition_header)
constructor_generator.generate_wrap_definition(
definition_header, self.capi_generator)
constructor_generator.include_dependent_definition_headers(
definition_header, self.file_cache)
return first_method
def generate_method_callback_declaration(first_flag, out: FileGenerator, cur_method_generator) -> bool:
first_flag = if_required_then_add_empty_line(first_flag, out)
c_argument_declaration_list = [
arg_gen.c_argument_declaration() for arg_gen in cur_method_generator.c_arguments_list]
cur_method_generator.exception_traits.modify_c_arguments(c_argument_declaration_list)
out.put_line('template<typename ImplementationClass>')
out.put_line('{return_type} {top_ns}_API_CONVENTION {callback_name}({arguments});'.format(
top_ns=cur_method_generator.parent_class_generator.full_name_array[0].upper(),
return_type=cur_method_generator.return_type_generator.c_argument_declaration(),
callback_name=get_method_callback_name(cur_method_generator),
arguments=', '.join(c_argument_declaration_list)
))
return first_flag
def generate_delete_callback_declaration(first_flag, out: FileGenerator, class_generator, definition) -> bool:
first_flag = if_required_then_add_empty_line(first_flag, out)
argument_list = ['void* object_pointer']
class_generator.callback_lifecycle_traits.finish_method_exception_traits.modify_c_arguments(argument_list)
arguments = ', '.join(argument_list)
out.put_line('template<typename ImplementationClass>')
out.put_line('void {top_ns}_API_CONVENTION {name}({arguments}){semicolon}'.format(
top_ns=class_generator.full_name_array[0].upper(),
name=get_delete_callback_name(class_generator),
arguments=arguments,
semicolon='' if definition else ';'))
if definition:
class_generator.capi_generator.add_c_function_pointer(
class_generator.full_name_array,
'void', class_generator.base_class_generator.delete_callback_type, arguments)
return first_flag
def generate_create_callback_declaration(first_flag, out: FileGenerator, class_generator):
first_flag = if_required_then_add_empty_line(first_flag, out)
out.put_line('template<typename ImplementationClass>')
out.put_line(
'inline {return_type} create_callback_for_{class_suffix}(ImplementationClass* implementation_class);'.format(
return_type=class_generator.full_wrap_name,
class_suffix=class_generator.base_class_generator.c_name))
out.put_line('')
out.put_line('template<typename ImplementationClass>')
out.put_line(
'inline {return_type} create_callback_for_{class_suffix}(ImplementationClass& implementation_class);'.format(
return_type=class_generator.full_wrap_name,
class_suffix=class_generator.base_class_generator.c_name))
return first_flag
def generate_create_callback_definition(first_flag, out: FileGenerator, class_generator):
first_flag = if_required_then_add_empty_line(first_flag, out)
callback = class_generator.base_class_generator.class_object.callbacks[0]
out.put_line('template<typename ImplementationClass>')
out.put_line(
'{return_type} create_callback_for_{class_suffix}(ImplementationClass* implementation_class)'.format(
return_type=class_generator.full_wrap_name,
class_suffix=class_generator.base_class_generator.c_name))
with IndentScope(out):
out.put_line('{callback_class} result;'.format(callback_class=class_generator.full_wrap_name))
generate_set_callbacks_for_lifecycle(out, callback, class_generator)
for cur_method_generator in get_all_methods(class_generator.base_class_generator):
generate_set_callback_for_method(out, cur_method_generator)
out.put_line('result.SetObjectPointer(implementation_class);')
out.put_line('return result;')
out.put_line('')
generate_create_callback_from_reference(out, class_generator)
return first_flag