def generate(self, out: FileGenerator):
out.put_line('')
with IfDefScope(out, '__cplusplus'):
out.put_line('#include <stdexcept>')
out.put_line('#include <sstream>')
out.put_line('')
# We always have at least one element
out.put_line('namespace {0}'.format(
self.namespace_info.namespace_name_array[0]))
with IndentScope(out):
self.__generate_body(out)
def include_dependent_declaration_headers(self,
file_generator: FileGenerator,
file_cache: FileCache):
parent_generator = self.enum_argument_generator.parent_generator
if type(parent_generator) is NamespaceGenerator:
header_to_include = file_cache.enums_header(
parent_generator.full_name_array)
else:
header_to_include = file_cache.class_header_decl(
parent_generator.full_name_array)
file_generator.include_user_header(header_to_include)
def generate_callback_implementation_destructor(out: FileGenerator, callback,
impl_class_name,
class_generator):
if callback.lifecycle == TLifecycle.copy_semantic:
out.put_line('~{0}()'.format(impl_class_name))
generate_callback_implementation_destructor_body(
out, class_generator, 'delete_callback')
elif callback.lifecycle == TLifecycle.reference_counted:
out.put_line('~{0}()'.format(impl_class_name))
generate_callback_implementation_destructor_body(
out, class_generator, 'release_callback')
def __generate_forward_declarations_impl(self, out: FileGenerator):
out.put_line('namespace {0}'.format(self.name))
with IndentScope(out):
for nested_namespace_generator in self.nested_namespaces:
nested_namespace_generator.__generate_forward_declarations_impl(
out)
for cur_template in self.templates:
cur_template.generate_forward_declaration(out)
for class_generator in self.classes:
class_generator.generate_forward_declaration(out)
def __generate_deallocate(self, out: FileGenerator, class_generator):
out.put_line('if ({get_raw}())'.format(
get_raw=self.params.get_raw_pointer_method_name))
with IndentScope(out):
self.finish_method_exception_traits.generate_c_call(
out, BuiltinTypeGenerator('void'),
class_generator.release_method, [
'{get_raw}()'.format(
get_raw=self.params.get_raw_pointer_method_name)
])
out.put_line('SetObject(0);')
def __generate_copy_constructor_definition(self, out: FileGenerator,
class_generator):
out.put_line(
'inline {namespace}::{class_short_name}(const {class_name}& other){base_init}'
.format(namespace=class_generator.full_wrap_name,
class_short_name=class_generator.wrap_short_name,
class_name=class_generator.wrap_name,
base_init=get_base_init(class_generator)))
with IndentScope(out):
out.put_line('SetObject(other.{get_raw}());'.format(
get_raw=self.params.get_raw_pointer_method_name))
def __generate_destructor(self, out: FileGenerator):
out.put_line('~Initialization()')
with IndentScope(out):
if_def_then_else(
out, '_WIN32',
DynamicLoaderGenerator.__generate_destructor_windows,
DynamicLoaderGenerator.__generate_destructor_posix)
for c_function in self.namespace_info.c_functions:
self.cur_c_function_name = c_function.name
if_def_then_else(
out, '{0}_zero_function_pointer'.format(c_function.name),
self.__generate_secure_zero, self.__generate_open_zero)
def __put_define_apple_or_linux(self, out: FileGenerator):
out.put_line('#if defined(__GNUC__) && __GNUC__ >= 4')
with Indent(out):
out.put_line('#define {0} {1} __attribute__ ((visibility ("default")))'.format(
self.cur_api_define, self.cur_capi_prefix))
out.put_line('#else')
with Indent(out):
out.put_line('#define {0} {1}'.format(self.cur_api_define, self.cur_capi_prefix))
out.put_line('#endif')
if_def_then_else(out, '__i386__',
self.__generate_posix_i386_attribute,
self.__generate_posix_non_i386_attribute)
def generate_snippet(self, out: FileGenerator):
arguments = ', '.join([
arg_gen.snippet_implementation_declaration()
for arg_gen in self.argument_generators
])
declaration = 'virtual {return_type} {name}({arguments}){const} = 0;'.format(
return_type=self.return_type_generator.
snippet_implementation_declaration(),
name=self.method_object.name,
arguments=arguments,
const=' const' if self.method_object.const else '')
out.put_line(declaration)
def __generate_raw_copy_constructor_definition(self, out: FileGenerator,
class_generator):
constructor_arguments = '{class_name}::ECreateFromRawPointer, void *object_pointer, bool add_ref_object'.format(
class_name=class_generator.full_wrap_name)
out.put_line(
'inline {namespace}::{class_name}({arguments}){base_init}'.format(
namespace=class_generator.full_wrap_name,
class_name=class_generator.wrap_short_name,
arguments=constructor_arguments,
base_init=get_base_init(class_generator)))
with IndentScope(out):
self.generate_raw_copy_constructor_body_definition(
out, class_generator, 'add_ref_object')
def generate_callback_implementation_destructor_body(out: FileGenerator,
class_generator,
callback_function_name):
with IndentScope(out):
out.put_line('if (mObject && {0})'.format(callback_function_name))
with IndentScope(out):
exception_traits = class_generator.callback_lifecycle_traits.finish_method_exception_traits
return_expression = exception_traits.generate_c_call_from_impl(
out, BuiltinTypeGenerator('void'), callback_function_name,
['mObject'])
if return_expression:
out.put_line('{return_expression};'.format(
return_expression=return_expression))
def __generate_class_declaration(self, declaration_header: FileGenerator):
DoxygenCppGenerator().generate_for_class(declaration_header, self)
put_template_line(declaration_header, self.class_object)
if self.base_class_generator:
declaration_header.put_line(
'class {name} : public {base_class}'.format(
name=self.wrap_name,
base_class=self.base_class_generator.full_wrap_name))
declaration_header.include_user_header(
self.file_cache.class_header_decl(
self.base_class_generator.full_name_array))
else:
declaration_header.put_line(
'class {name}'.format(name=self.wrap_name))
with IndentScope(declaration_header, '};'):
self.__generate_class_body(declaration_header)
if self.class_object.typedef_name:
declaration_header.put_line(
'typedef {wrap_name} {typedef}{suffix};'.format(
wrap_name=self.wrap_name,
typedef=self.class_object.typedef_name,
suffix=self.lifecycle_traits.suffix))
for template_argument_generator in self.template_argument_generators:
template_argument_generator.include_dependent_declaration_headers(
declaration_header, self.file_cache)
self.__generate_callback_lifecycle_traits()
generate_callbacks_on_client_side_declarations(declaration_header,
self)
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_c_function(self, capi_generator: CapiGenerator):
argument_declaration_list = [
argument_generator.c_argument_declaration()
for argument_generator in self.argument_generators
]
self.exception_traits.modify_c_arguments(argument_declaration_list)
arguments_declaration = ', '.join(argument_declaration_list)
implementation_arguments = ', '.join([
argument_generator.c_2_implementation()
for argument_generator in self.argument_generators
])
c_function_body = FileGenerator(None)
with IndentScope(c_function_body):
if self.constructor_object.implementation_codes:
calling_instructions = generate_custom_implementation_code(
self.constructor_object.implementation_codes[0],
self.argument_generators,
self.parent_class_as_argument_type)
else:
implementation_call = 'return new {impl_class}({arguments});'.format(
impl_class=self.parent_class_generator.class_object.
implementation_class_name,
arguments=implementation_arguments)
calling_instructions = [implementation_call]
self.exception_traits.generate_implementation_call(
c_function_body, self.parent_class_as_argument_type,
calling_instructions)
capi_generator.add_c_function(
self.parent_class_generator.full_name_array,
self.parent_class_as_argument_type.c_argument_declaration(),
self.full_c_name, arguments_declaration, c_function_body)
def generate_move_constructor_definition(self, out: FileGenerator,
class_generator):
if self.params.enable_cpp11_features_in_wrap_code:
with IfDefScope(out, get_has_rvalue_references(class_generator),
False):
out.put_line(
'inline {namespace}::{class_short_name}({class_name}&& other){base_init}'
.format(namespace=class_generator.full_wrap_name,
class_short_name=class_generator.wrap_short_name,
class_name=class_generator.wrap_name,
base_init=get_base_move_init(class_generator)))
with IndentScope(out):
class_generator.inheritance_traits.generate_object_assignment(
out, class_generator, '', 'other.mObject')
class_generator.inheritance_traits.generate_object_assignment(
out, class_generator, 'other.', '0')
def generate_std_methods_declarations(self, out: FileGenerator,
class_generator):
super().generate_copy_constructor_declaration(out, class_generator)
super().generate_move_constructor_declaration(out, class_generator)
out.put_line(
'enum ECreateFromRawPointer { force_creating_from_raw_pointer };')
out.put_line(
'inline {class_name}(ECreateFromRawPointer, void *object_pointer, bool add_ref_object);'
.format(class_name=class_generator.wrap_short_name))
out.put_line('inline ~{class_name}();'.format(
class_name=class_generator.wrap_short_name))
super().generate_std_methods_declarations(out, class_generator)
out.put_line('inline {class_name}* operator->();'.format(
class_name=class_generator.wrap_name))
out.put_line('inline const {class_name}* operator->() const;'.format(
class_name=class_generator.wrap_name))
def __get_cached_generator(self, file_name: str) -> FileGenerator:
if file_name in self.file2generator:
return self.file2generator[file_name]
else:
new_file_generator = FileGenerator(file_name)
self.file2generator.update({file_name: new_file_generator})
return new_file_generator
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_c_function(self, capi_generator: CapiGenerator):
c_arguments_list = [
argument_generator.c_argument_declaration()
for argument_generator in self.argument_generators
]
self.exception_traits.modify_c_arguments(c_arguments_list)
c_arguments = ', '.join(c_arguments_list)
implementation_arguments = ', '.join([
argument_generator.c_2_implementation()
for argument_generator in self.argument_generators
])
c_function_body = FileGenerator(None)
with IndentScope(c_function_body):
function_name = self.function_object.implementation_name
if not function_name:
function_name = self.function_object.name
implementation_call = '{function_name}({arguments})'.format(
function_name=function_name,
arguments=implementation_arguments)
calling_instructions, return_expression = self.return_type_generator.implementation_2_c_var(
'', implementation_call)
if return_expression:
calling_instructions.append(
'return {0};'.format(return_expression))
self.exception_traits.generate_implementation_call(
c_function_body, self.return_type_generator,
calling_instructions)
capi_generator.add_c_function(
self.parent_namespace_generator.full_name_array,
self.return_type_generator.c_argument_declaration(),
self.full_c_name, c_arguments, c_function_body)
def generate_c_functions(class_generator):
if class_generator.base_class_generator:
body = FileGenerator(None)
with IndentScope(body):
cast_str = 'return static_cast<{base_type}*>(static_cast<{this_type}*>(object_pointer));'
if class_generator.class_object.custom_cast_to_base_filled:
cast_str = class_generator.class_object.custom_cast_to_base
body.put_line(
cast_str.format(
base_type=class_generator.base_class_generator.
class_object.implementation_class_name,
this_type=class_generator.class_object.
implementation_class_name))
class_generator.capi_generator.add_c_function(
class_generator.full_name_array, 'void*',
class_generator.cast_to_base, 'void* object_pointer', body)
def generate_enum_definition(self, out: FileGenerator):
DoxygenCppGenerator().generate_for_enum(out, self.enum_object)
out.put_line('enum {name}'.format(name=self.name))
with IndentScope(out, '};'):
items_definitions = [
self.__get_enum_item_definition(enum_item)
for enum_item in self.enum_object.items
]
items_definitions_with_comma = [
item + ',' for item in items_definitions[:-1]
]
if items_definitions:
items_definitions_with_comma.append(items_definitions[-1])
for item_definition, item in zip(items_definitions_with_comma,
self.enum_object.items):
out.put_line(item_definition +
DoxygenCppGenerator().get_for_enum_item(item))
def __generate_dynamic_capi(self, out: FileGenerator):
out.put_line('')
for c_function in self.cur_namespace_info.c_functions:
self.cur_namespace_info.c_pointers.append(
Pointer2CFunction(
c_function.path_to_namespace,
c_function.return_type,
c_function.name + '_function_type',
c_function.arguments
)
)
self.__generate_callback_typedefs(out)
if_def_then_else(out, self.cur_namespace_name + '_CAPI_DEFINE_FUNCTION_POINTERS',
self.__generate_function_pointer_definitions,
self.__generate_function_pointer_declarations)
DynamicLoaderGenerator(self.cur_namespace_name, self.cur_namespace_info, self.params).generate(out)
out.put_line('')
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_for_namespace(out: FileGenerator,
namespace_object: TNamespace,
full_wrap_name: str):
if namespace_object.documentations:
out.put_line('/**')
out.put_line(' * @namespace ' + full_wrap_name)
for documentation in namespace_object.documentations:
for doc_line in DoxygenCppGenerator.__get_lines_for_documentation(
documentation, False):
out.put_line(' * {0}'.format(doc_line))
out.put_line(' */')
def __generate_assignment_operator(self, out: FileGenerator,
class_generator):
out.put_line(
'inline {class_name}& {class_name}::operator=(const {class_name}& other)'
.format(class_name=class_generator.full_wrap_name))
with IndentScope(out):
out.put_line('if (this != &other)')
with IndentScope(out):
out.put_line('SetObject(other.{get_raw}());'.format(
get_raw=self.params.get_raw_pointer_method_name))
out.put_line('return *this;')
def GenerateTestFileCollection():
#parametr: litera dysku, ilość plików, wielkość danych w MB
#zwraca ścieżke do lokalizacji, gdzie pliki zostały stworzone
createdFilesDirectory = FileGenerator.GenerateTestFiles('D', 1, 1)
copiedFilesDirectory = FileTransferManager.copyFilesFromSpecificDirectory(
createdFilesDirectory, 'D')
FileCleaner.RemoveDirectoryWithFiles(createdFilesDirectory)
FileCleaner.RemoveFilesFromDirectory(copiedFilesDirectory)
#FileCleaner.RemoveFilesFromDirectory(copiedFilesDirectory)
FileCleaner.RemoveDirectory(copiedFilesDirectory)
def generate_c_function(self, capi_generator: CapiGenerator):
argument_declaration_list = [
argument_generator.c_argument_declaration()
for argument_generator in self.c_arguments_list
]
self.exception_traits.modify_c_arguments(argument_declaration_list)
arguments_declaration = ', '.join(argument_declaration_list)
implementation_arguments = ', '.join([
argument_generator.c_2_implementation()
for argument_generator in self.argument_generators
])
c_function_body = FileGenerator(None)
with IndentScope(c_function_body):
c_function_body.put_line(
'{const}{self_impl_class}* self = {to_impl_cast};'.format(
const='const ' if self.method_object.const else '',
self_impl_class=self.parent_class_generator.class_object.
implementation_class_name,
to_impl_cast=self.c_arguments_list[0].c_2_implementation(
)))
self_access = 'self->'
if self.parent_class_generator.class_object.pointer_access:
self_access = '(*self)->'
method_name = self.method_object.implementation_name
if not method_name:
method_name = self.method_object.name
implementation_call = '{self_access}{method_name}({arguments})'.format(
self_access=self_access,
method_name=method_name,
arguments=implementation_arguments)
calling_instructions, return_expression = self.return_type_generator.implementation_2_c_var(
'', implementation_call)
if return_expression:
calling_instructions.append(
'return {0};'.format(return_expression))
self.exception_traits.generate_implementation_call(
c_function_body, self.return_type_generator,
calling_instructions)
capi_generator.add_c_function(
self.parent_class_generator.full_name_array,
self.return_type_generator.c_argument_declaration(),
self.full_c_name, arguments_declaration, c_function_body)
def generate_callbacks_on_client_side_definitions(out: FileGenerator, class_generator):
if class_generator.is_callback:
callback = class_generator.base_class_generator.class_object.callbacks[0]
out.put_line('')
out.put_line(class_generator.parent_namespace.one_line_namespace_begin)
out.put_line('')
first_flag = True
first_flag = generate_callback_declarations_for_lifecycle(out, callback, class_generator, first_flag)
for cur_method_generator in get_all_methods(class_generator.base_class_generator):
first_flag = generate_method_callback_declaration(first_flag, out, cur_method_generator)
first_flag = generate_callback_definitions_for_lifecycle(out, callback, class_generator, first_flag)
for cur_method_generator in get_all_methods(class_generator.base_class_generator):
first_flag = generate_method_callback_definition(first_flag, out, cur_method_generator)
out.put_line('')
out.put_line(class_generator.parent_namespace.one_line_namespace_end)
def __init__(self, main_exception_traits, no_handling_exception_traits,
params: TBeautifulCapiParams, api_root: TBeautifulCapiRoot):
self.params = params
self.api_root = api_root
self.namespace_name_2_info = {}
self.main_exception_traits = main_exception_traits
self.no_handling_exception_traits = no_handling_exception_traits
self.additional_includes = FileGenerator(None)
self.additional_includes.put_include_files()
self.additional_includes.include_system_header('stdexcept')
self.additional_includes.include_system_header('cassert')
self.main_exception_traits.include_wrap_cpp_headers(self.additional_includes)
self.callback_implementations = []
self.cur_api_define = None
self.cur_capi_prefix = None
self.cur_api_convention = None
self.sorted_by_ns = None
self.cur_namespace_name = None
self.cur_namespace_info = None
self.api_keys = {}
def generate_wrap_definition(self, out: FileGenerator):
arguments = ', '.join([
argument_generator.wrap_argument_declaration()
for argument_generator in self.argument_generators
])
arguments_call = [
argument_generator.wrap_2_c()
for argument_generator in self.c_arguments_list
]
out.put_line(
'inline {return_type} {full_name}({arguments}){const}'.format(
return_type=self.return_type_generator.wrap_return_type(),
full_name=self.full_wrap_name,
arguments=arguments,
const=' const' if self.method_object.const else ''))
with IndentScope(out):
self.return_type_generator.copy_or_add_ref_when_c_2_wrap = self.method_object.return_copy_or_add_ref
return_expression = self.exception_traits.generate_c_call(
out, self.return_type_generator, self.full_c_name,
arguments_call)
out.put_return_cpp_statement(return_expression)
def createProject(self, dir, projectName, groupId):
projectDir = dir+"/"+projectName;
SOURCE_MAIN_JAVA = "src/main/java";
SOURCE_MAIN_RESOURCES = "src/main/resources"
SOURCE_TEST_JAVA = "src/test/java"
SOURCE_TEST_RESOURCES = "src/test/resources";
if not os.path.isdir(projectDir):
os.mkdir(projectDir);
# create the POM file
FileGenerator.createPOMFile(projectName, groupId, projectDir);
# create the project directories
os.makedirs(projectDir+"/"+SOURCE_MAIN_JAVA);
os.makedirs(projectDir+"/"+SOURCE_TEST_JAVA);
os.makedirs(projectDir+"/"+SOURCE_MAIN_RESOURCES);
os.makedirs(projectDir+"/"+SOURCE_TEST_RESOURCES);
os.makedirs(projectDir+"/logs");
packageFolderPathSrc = ProjectGenerator.createPackageFolder(self, projectDir, SOURCE_MAIN_JAVA, groupId);
packageFolderPathTest = ProjectGenerator.createPackageFolder(self, projectDir, SOURCE_TEST_JAVA, groupId);
ScriptMonitor.message("Creating source folder path: "+packageFolderPathSrc);
ScriptMonitor.message("Creating test folder path: "+packageFolderPathTest);
#create the MainApplication.java file
FileGenerator.createSourceEntryFile(packageFolderPathSrc, groupId)
FileGenerator.createLogPropertiesFile(groupId, projectDir+"/"+SOURCE_MAIN_RESOURCES+"/log4j.properties");
else:
print("ERR> Folder : "+projectDir+" exists");
