javonet-nodejs-sdk 2.5.14 → 2.5.15

package/Binaries/Python/javonet/core/generator/handler/GeneratorHandler.py

@@ -1,65 +0,0 @@
-import importlib
-import importlib.util
-import inspect
-import os
-from os import listdir
-from os.path import isfile, join
-
-from javonet.core.generator.handler.Handlers import Handlers
-from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class GeneratorHandler:
-
-    def analyze(self, package_path):
-        handlers = Handlers()
-        handlers.types_to_analyze.extend(self.return_classes_from_package(package_path))
-        structured_command_for_class = Command(RuntimeName.python, CommandType.GenerateLib, [])
-
-        while len(handlers.types_to_analyze) > 0:
-            structured_command_for_class = structured_command_for_class. \
-                add_arg_to_payload(handlers.GENERATOR_HANDLER[CommandType.GetType].
-                                   generate_command(handlers.types_to_analyze.pop(0), structured_command_for_class,
-                                                    handlers))
-
-        return structured_command_for_class
-
-    def generate(self, command, file_path):
-        generator_handlers = Handlers()
-        for i in range(0, len(command.get_payload())):
-            existing_string_builder = PythonStringBuilder()
-            if isinstance(command.get_payload()[i], Command):
-                generator_handlers.GENERATOR_HANDLER[command.get_payload()[i].command_type].generate_code(
-                    existing_string_builder, command, command.get_payload()[i], generator_handlers)
-                self.generate_class_file(existing_string_builder, str(command.get_payload()[i].get_payload()[0]),
-                                         file_path)
-            else:
-                raise Exception(
-                    "GeneratorHandlerException: Argument is not type of PythonCommand GetTypeCommand: " + str(
-                        command.getPayload()[i]))
-
-    def generate_class_file(self, existing_string_builder, class_file_name, file_path):
-        if not os.path.exists(file_path):
-            os.makedirs(file_path)
-        f = open(os.path.join(file_path, class_file_name) + ".py", "w+")
-        f.write(str(existing_string_builder))
-        f.close()
-
-    def return_classes_from_package(self, package_path):
-
-        onlyfiles = [f for f in listdir(package_path) if
-                     isfile(join(package_path, f))]
-        classes = []
-
-        for x in onlyfiles:
-            spec = importlib.util.spec_from_file_location(x[:-3], os.path.join(package_path, x))
-            foo = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(foo)
-            for name, obj in inspect.getmembers(foo):
-                if inspect.isclass(obj):
-                    classes.append(obj)
-
-        return classes

package/Binaries/Python/javonet/core/generator/handler/GetInstanceFieldGeneratorHandler.py

@@ -1,36 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class GetInstanceFieldGeneratorHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        get_instance_field_command = Command(RuntimeName.python, CommandType.GetInstanceField, [])
-        get_instance_field_command = get_instance_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_command(analyzed_object.__name__,
-                                                                                    get_instance_field_command,
-                                                                                    handlers))
-        get_instance_field_command = get_instance_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(type(analyzed_object),
-                                                                             get_instance_field_command,
-                                                                             handlers))
-        get_instance_field_command = get_instance_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
-                                                                                 get_instance_field_command, handlers))
-        return get_instance_field_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("    ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[2], handlers)
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_code(existing_string_builder, common_command,
-                                                                             used_object.get_payload()[0], handlers)
-        existing_string_builder.append(" ")
-        existing_string_builder.append("=")
-        existing_string_builder.append(" ")
-        handlers.SHARED_BODY_HANDLER[CommandType.GetInstanceField].generate_code(existing_string_builder,
-                                                                                 common_command,
-                                                                                 used_object,
-                                                                                 handlers)

package/Binaries/Python/javonet/core/generator/handler/GetStaticFieldGeneratorHandler.py

@@ -1,39 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class GetStaticFieldGeneratorHandler(AbstractGeneratorHandler):
-
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        get_static_field_command = Command(RuntimeName.python, CommandType.GetStaticField, [])
-        get_static_field_command = get_static_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_command(analyzed_object[0],
-                                                                                    get_static_field_command, handlers))
-        get_static_field_command = get_static_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(analyzed_object[1],
-                                                                             get_static_field_command,
-                                                                             handlers))
-        get_static_field_command = get_static_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object,
-                                                                                 get_static_field_command,
-                                                                                 handlers))
-        get_static_field_command = get_static_field_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.CLASS_NAME].generate_command(parent_command.get_payload()[0],
-                                                                                   get_static_field_command,
-                                                                                   handlers))
-        return get_static_field_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("    ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[2], handlers)
-
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_code(existing_string_builder, common_command,
-                                                                             used_object.get_payload()[0], handlers)
-        existing_string_builder.append(" = ")
-        handlers.SHARED_BODY_HANDLER[CommandType.GetStaticField].generate_code(existing_string_builder,
-                                                                               common_command,
-                                                                               used_object, handlers)

package/Binaries/Python/javonet/core/generator/handler/GetTypeGeneratorHandler.py

@@ -1,92 +0,0 @@
-import inspect
-
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class GetTypeGeneratorHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        get_type_command = Command(RuntimeName.python, CommandType.GetType, [])
-        get_type_command = get_type_command.add_arg_to_payload(analyzed_object.__name__)
-        get_type_command = get_type_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
-                                                                                 get_type_command, handlers))
-        clazz_variables_names = [attr for attr in analyzed_object.__dict__ if
-                                 not callable(getattr(analyzed_object, attr)) and not attr.startswith("__")]
-        clazz_methods = inspect.getmembers(analyzed_object, predicate=inspect.isfunction)
-        clazz_constructor = getattr(analyzed_object, "__init__")
-
-        clazz_variables_dict = dict()
-        for method in clazz_methods:
-            method_type = self.inspect_type(analyzed_object, method[1])
-            if (method_type == 'classmethod' or method_type == 'function' or method_type == 'instancemethod') and (
-                    method[0] == "__init__"):
-                get_type_command = get_type_command.add_arg_to_payload(
-                    handlers.GENERATOR_HANDLER[CommandType.CreateClassInstance].generate_command(
-                        clazz_constructor,
-                        get_type_command,
-                        handlers))
-            if method_type == 'staticmethod':
-                get_type_command = get_type_command.add_arg_to_payload(
-                    handlers.GENERATOR_HANDLER[CommandType.InvokeStaticMethod].generate_command(
-                        method[1],
-                        get_type_command,
-                        handlers))
-            if (method_type == 'classmethod' or method_type == 'function' or method_type == 'instancemethod') and (
-                    method[0] != "__init__"):
-                get_type_command = get_type_command.add_arg_to_payload(
-                    handlers.GENERATOR_HANDLER[CommandType.InvokeInstanceMethod].generate_command(
-                        method[1],
-                        get_type_command,
-                        handlers))
-
-        for clazz_variable_name in clazz_variables_names:
-            clazz_variables_dict[clazz_variable_name] = getattr(analyzed_object, clazz_variable_name)
-        for dict_items in clazz_variables_dict.items():
-            get_type_command = get_type_command.add_arg_to_payload(
-                handlers.GENERATOR_HANDLER[CommandType.GetStaticField].generate_command(
-                    dict_items,
-                    get_type_command,
-                    handlers))
-
-        return get_type_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("\n")
-        existing_string_builder.append("from javonet.sdk import Javonet")
-        existing_string_builder.append("\n")
-        existing_string_builder.append("class ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[1], handlers)
-        handlers.SHARED_HANDLER[SharedHandlerType.CLASS_NAME].generate_code(existing_string_builder, common_command,
-                                                                            used_object.get_payload()[0], handlers)
-        existing_string_builder.append(":")
-        existing_string_builder.append("\n")
-        handlers.SHARED_HANDLER[SharedHandlerType.CLAZZ_INSTANCE].generate_code(existing_string_builder, common_command,
-                                                                                used_object, handlers)
-        existing_string_builder.append("\n")
-        for i in range(2, len(used_object.get_payload())):
-            handlers.GENERATOR_HANDLER[used_object.get_payload()[i].command_type].generate_code(existing_string_builder,
-                                                                                                common_command,
-                                                                                                used_object.get_payload()[
-                                                                                                    i], handlers)
-            existing_string_builder.append("\n")
-
-    def inspect_type(self, cls, func):
-        ftype = None
-        if func.__name__ == func.__qualname__:
-            return 'function'
-        elif '.<locals>' in func.__qualname__:
-            return 'function'
-        ftype = cls.__dict__.get(func.__name__)
-        if type(ftype) == staticmethod:
-            return 'staticmethod'
-        elif type(ftype) == classmethod:
-            return 'classmethod'
-        elif ftype.__class__.__name__ == 'function':
-            return 'instancemethod'
-        else:
-            raise TypeError('Unknown Type %s, Please check input is method or function' % func)

package/Binaries/Python/javonet/core/generator/handler/Handlers.py

@@ -1,59 +0,0 @@
-from javonet.core.generator.handler.CreateInstanceGeneratorHandler import CreateInstanceGeneratorHandler
-from javonet.core.generator.handler.GetInstanceFieldGeneratorHandler import GetInstanceFieldGeneratorHandler
-from javonet.core.generator.handler.GetStaticFieldGeneratorHandler import GetStaticFieldGeneratorHandler
-from javonet.core.generator.handler.GetTypeGeneratorHandler import GetTypeGeneratorHandler
-from javonet.core.generator.handler.InvokeInstanceMethodGeneratorHandler import InvokeInstanceMethodGeneratorHandler
-from javonet.core.generator.handler.InvokeStaticMethodGeneratorHandler import InvokeStaticMethodGeneratorHandler
-from javonet.core.generator.handler.shared.body.SharedBodyHandler import SharedBodyHandler
-from javonet.core.generator.handler.shared.body.SharedCreateInstanceBodyHandler import SharedCreateInstanceBodyHandler
-from javonet.core.generator.handler.shared.body.SharedGetInstanceFieldBodyHandler import \
-    SharedGetInstanceFieldBodyHandler
-from javonet.core.generator.handler.shared.body.SharedGetStaticFieldBodyHandler import SharedGetStaticFieldBodyHandler
-from javonet.core.generator.handler.shared.body.SharedGetTypeBodyHandler import SharedGetTypeBodyHandler
-from javonet.core.generator.handler.shared.body.SharedInvokeInstanceMethodBodyHandler import \
-    SharedInvokeInstanceMethodBodyHandler
-from javonet.core.generator.handler.shared.body.SharedInvokeStaticMethodBodyHandler import \
-    SharedInvokeStaticMethodBodyHandler
-from javonet.utils.CommandType import CommandType
-
-from javonet.core.generator.handler.shared.SharedArgumentNameHandler import SharedArgumentNameHandler
-from javonet.core.generator.handler.shared.SharedClassInstanceHandler import SharedClassInstanceHandler
-from javonet.core.generator.handler.shared.SharedClassNameHandler import SharedClassNameHandler
-from javonet.core.generator.handler.shared.SharedMethodNameHandler import SharedMethodNameHandler
-from javonet.core.generator.handler.shared.SharedModifierHandler import SharedModifierHandler
-from javonet.core.generator.handler.shared.SharedReturnTypeHandler import SharedReturnTypeHandler
-from javonet.core.generator.handler.shared.SharedTypeHandler import SharedTypeHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-
-
-class Handlers:
-
-    types_to_analyze = []
-
-    GENERATOR_HANDLER = dict()
-    SHARED_HANDLER = dict()
-    SHARED_BODY_HANDLER = dict()
-
-    def __init__(self):
-        self.SHARED_HANDLER[SharedHandlerType.ARGUMENT_NAME] = SharedArgumentNameHandler()
-        self.SHARED_HANDLER[SharedHandlerType.METHOD_BODY] = SharedBodyHandler()
-        self.SHARED_HANDLER[SharedHandlerType.CLASS_NAME] = SharedClassNameHandler()
-        self.SHARED_HANDLER[SharedHandlerType.METHOD_NAME] = SharedMethodNameHandler()
-        self.SHARED_HANDLER[SharedHandlerType.MODIFIER] = SharedModifierHandler()
-        self.SHARED_HANDLER[SharedHandlerType.TYPE] = SharedTypeHandler()
-        self.SHARED_HANDLER[SharedHandlerType.CLAZZ_INSTANCE] = SharedClassInstanceHandler()
-        self.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE] = SharedReturnTypeHandler()
-
-        self.SHARED_BODY_HANDLER[CommandType.CreateClassInstance] = SharedCreateInstanceBodyHandler()
-        self.SHARED_BODY_HANDLER[CommandType.GetType] = SharedGetTypeBodyHandler()
-        self.SHARED_BODY_HANDLER[CommandType.InvokeInstanceMethod] = SharedInvokeInstanceMethodBodyHandler()
-        self.SHARED_BODY_HANDLER[CommandType.InvokeStaticMethod] = SharedInvokeStaticMethodBodyHandler()
-        self.SHARED_BODY_HANDLER[CommandType.GetStaticField] = SharedGetStaticFieldBodyHandler()
-        self.SHARED_BODY_HANDLER[CommandType.GetInstanceField] = SharedGetInstanceFieldBodyHandler()
-
-        self.GENERATOR_HANDLER[CommandType.CreateClassInstance] = CreateInstanceGeneratorHandler()
-        self.GENERATOR_HANDLER[CommandType.GetType] = GetTypeGeneratorHandler()
-        self.GENERATOR_HANDLER[CommandType.InvokeInstanceMethod] = InvokeInstanceMethodGeneratorHandler()
-        self.GENERATOR_HANDLER[CommandType.InvokeStaticMethod] = InvokeStaticMethodGeneratorHandler()
-        self.GENERATOR_HANDLER[CommandType.GetStaticField] = GetStaticFieldGeneratorHandler()
-        self.GENERATOR_HANDLER[CommandType.GetInstanceField] = GetInstanceFieldGeneratorHandler()

package/Binaries/Python/javonet/core/generator/handler/InvokeInstanceMethodGeneratorHandler.py

@@ -1,53 +0,0 @@
-import inspect
-import typing
-
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.CommonGenerator import CommonGenerator
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class InvokeInstanceMethodGeneratorHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        invoke_instance_method_command = Command(RuntimeName.python, CommandType.InvokeInstanceMethod, [])
-        invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(analyzed_object.__name__)
-        invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(
-            # TODO: what to do with dynamic language with unknown type
-            handlers.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE].generate_command(
-                typing.get_type_hints(analyzed_object),
-                invoke_instance_method_command,
-                handlers))
-        invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
-                                                                                 invoke_instance_method_command,
-                                                                                 handlers))
-        parameter_types = []
-        parameter_names = list(inspect.getfullargspec(analyzed_object)[0])
-        parameters_dict = inspect.getfullargspec(analyzed_object)[6]
-        for parameter_name in parameter_names:
-            parameter_types.append(handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(
-                str(parameters_dict.get(parameter_name, "")),
-                invoke_instance_method_command,
-                handlers))
-
-        invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(parameter_types[1:])
-        invoke_instance_method_command = invoke_instance_method_command.add_arg_to_payload(parameter_names[1:])
-        return invoke_instance_method_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("    def ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[2], handlers)
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_code(existing_string_builder, common_command,
-                                                                             used_object.get_payload()[0], handlers)
-        existing_string_builder.append("(self")
-        if len(used_object.get_payload()[4]) > 0:
-            existing_string_builder.append(", ")
-        CommonGenerator.process_method_arguments(existing_string_builder, common_command, used_object.get_payload()[3],
-                                                 used_object.get_payload()[4], handlers)
-        existing_string_builder.append("):")
-        existing_string_builder.append("\n")
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_BODY].generate_code(existing_string_builder, common_command,
-                                                                             used_object, handlers)

package/Binaries/Python/javonet/core/generator/handler/InvokeStaticMethodGeneratorHandler.py

@@ -1,54 +0,0 @@
-import inspect
-
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.CommonGenerator import CommonGenerator
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.utils.Command import Command
-from javonet.utils.CommandType import CommandType
-from javonet.utils.RuntimeName import RuntimeName
-
-
-class InvokeStaticMethodGeneratorHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        invoke_static_method_command = Command(RuntimeName.python, CommandType.InvokeStaticMethod, [])
-        invoke_static_method_command = invoke_static_method_command.add_arg_to_payload(analyzed_object.__name__)
-        invoke_static_method_command = invoke_static_method_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE].generate_command(type(analyzed_object),
-                                                                                    invoke_static_method_command,
-                                                                                    handlers))
-        invoke_static_method_command = invoke_static_method_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_command(analyzed_object.__name__,
-                                                                                 invoke_static_method_command,
-                                                                                 handlers))
-        invoke_static_method_command = invoke_static_method_command.add_arg_to_payload(
-            handlers.SHARED_HANDLER[SharedHandlerType.CLASS_NAME].generate_command(parent_command.get_payload()[0],
-                                                                                   invoke_static_method_command,
-                                                                                   handlers))
-        parameter_types = []
-        parameter_names = list(inspect.getfullargspec(analyzed_object)[0])
-        parameters_dict = inspect.getfullargspec(analyzed_object)[6]
-        for parameter_name in parameter_names:
-            parameter_types.append(handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(
-                str(parameters_dict.get(parameter_name, "")),
-                invoke_static_method_command,
-                handlers))
-
-        invoke_static_method_command = invoke_static_method_command.add_arg_to_payload(parameter_types)
-        invoke_static_method_command = invoke_static_method_command.add_arg_to_payload(parameter_names)
-        return invoke_static_method_command
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("    @staticmethod")
-        existing_string_builder.append("\n")
-        existing_string_builder.append("    def ")
-        handlers.SHARED_HANDLER[SharedHandlerType.MODIFIER].generate_code(existing_string_builder, common_command,
-                                                                          used_object.get_payload()[2], handlers)
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_code(existing_string_builder, common_command,
-                                                                             used_object.get_payload()[0], handlers)
-        existing_string_builder.append("(")
-        CommonGenerator.process_method_arguments(existing_string_builder, common_command, used_object.get_payload()[4],
-                                                 used_object.get_payload()[5], handlers)
-        existing_string_builder.append("):")
-        existing_string_builder.append("\n")
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_BODY].generate_code(existing_string_builder, common_command,
-                                                                             used_object, handlers)

package/Binaries/Python/javonet/core/generator/handler/shared/SharedArgumentNameHandler.py

@@ -1,12 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-
-
-class SharedArgumentNameHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_command(analyzed_object, parent_command,
-                                                                                handlers)
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        handlers.SHARED_HANDLER[SharedHandlerType.METHOD_NAME].generate_code(existing_string_builder, common_command,
-                                                                             used_object, handlers)

package/Binaries/Python/javonet/core/generator/handler/shared/SharedClassInstanceHandler.py

@@ -1,12 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-
-
-class SharedClassInstanceHandler(AbstractGeneratorHandler):
-
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        return analyzed_object
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("\n")
-        existing_string_builder.append("    instance = None")
-        existing_string_builder.append("\n")

package/Binaries/Python/javonet/core/generator/handler/shared/SharedClassNameHandler.py

@@ -1,31 +0,0 @@
-import keyword
-
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-
-
-class SharedClassNameHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        return analyzed_object
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        if keyword.iskeyword(used_object):
-            used_object += used_object[-1]
-        if "@" in used_object:
-            used_object = used_object.replace("@", "")
-        if "-" in used_object:
-            used_object = used_object.replace("-", "_")
-        if used_object[0].isdigit():
-            pos = 0
-            for i, x in enumerate(used_object):
-                if x.isdigit():  # True if its a number
-                    pos = i  # first letter position
-                break
-
-            new_str = used_object[pos:]
-            used_object = new_str
-        if used_object[0].islower():
-            used_object.capitalize()
-        if used_object.isidentifier():
-            existing_string_builder.append(used_object)
-        else:
-            raise NameError("SharedMethodNameHandlerError: Given name is not valid: " + used_object)

package/Binaries/Python/javonet/core/generator/handler/shared/SharedMethodNameHandler.py

@@ -1,30 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-import keyword
-
-
-class SharedMethodNameHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        return analyzed_object
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        if keyword.iskeyword(used_object):
-            used_object += used_object[-1]
-        if "@" in used_object:
-            used_object = used_object.replace("@", "")
-        if "-" in used_object:
-            used_object = used_object.replace("-", "_")
-        if used_object[0].isdigit():
-            pos = 0
-            for i, x in enumerate(used_object):
-                if x.isdigit():  # True if its a number
-                    pos = i  # first letter position
-                break
-
-            new_str = used_object[pos:]
-            used_object = new_str
-        if used_object[0].isupper():
-            used_object = used_object[0].lower() + used_object[1:]
-        if used_object.isidentifier():
-            existing_string_builder.append(used_object)
-        else:
-            raise NameError("SharedMethodNameHandlerError: Given name is not valid: " + used_object)

package/Binaries/Python/javonet/core/generator/handler/shared/SharedModifierHandler.py

@@ -1,21 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-
-
-class SharedModifierHandler(AbstractGeneratorHandler):
-
-    def generate_command(self, analyzed_object, parent_command, handlers):
-
-        if analyzed_object[0] == "_" and analyzed_object[1] == "_":
-            return "private"
-        if analyzed_object[0] == "_":
-            return "protected"
-        else:
-            return "public"
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        if used_object == "public" or used_object == "":
-            existing_string_builder.append("")
-        if used_object == "protected":
-            existing_string_builder.append("_")
-        if used_object == "private":
-            existing_string_builder.append("__")

package/Binaries/Python/javonet/core/generator/handler/shared/SharedReturnTypeHandler.py

@@ -1,13 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-
-
-class SharedReturnTypeHandler(AbstractGeneratorHandler):
-
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        return handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_command(analyzed_object, parent_command, handlers)
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("return ")
-        handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_code(existing_string_builder, common_command, used_object, handlers)
-        existing_string_builder.append(" ")

package/Binaries/Python/javonet/core/generator/handler/shared/SharedTypeHandler.py

@@ -1,57 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.utils.Type import Type
-
-
-class SharedTypeHandler(AbstractGeneratorHandler):
-
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        if analyzed_object == "":
-            return Type.Command.value
-        if analyzed_object == "str":
-            return Type.JavonetString.value
-        if analyzed_object == "int":
-            return Type.JavonetInteger.value
-        if analyzed_object == "bool":
-            return Type.JavonetBoolean.value
-        if analyzed_object == "float":
-            return Type.JavonetFloat.value
-        if analyzed_object == "bytes":
-            return Type.JavonetByte.value
-        if analyzed_object == "double":
-            return Type.JavonetDouble.value
-        if analyzed_object == "char":
-            return Type.JavonetChar.value
-        else:
-            self.complex_command_type_generator(handlers, analyzed_object)
-            return str(analyzed_object)
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        if used_object is Type.Command:
-            pass
-        if used_object is Type.JavonetString.value:
-            existing_string_builder.append("str")
-        if used_object is Type.JavonetInteger.value:
-            existing_string_builder.append("int")
-        if used_object is Type.JavonetBoolean.value:
-            existing_string_builder.append("bool")
-        if used_object is Type.JavonetFloat.value:
-            existing_string_builder.append("float")
-        if used_object is Type.JavonetByte.value:
-            existing_string_builder.append("bytes")
-        if used_object is Type.JavonetChar.value:
-            existing_string_builder.append("int")
-        if used_object is Type.JavonetLongLong.value:
-            existing_string_builder.append("double")
-        if used_object is Type.JavonetDouble.value:
-            existing_string_builder.append("int")
-        if used_object is Type.JavonetUnsignedLongLong.value:
-            existing_string_builder.append("int")
-        if used_object is Type.JavonetUnsignedInteger.value:
-            existing_string_builder.append("int")
-        else:
-            existing_string_builder.append("")
-        # else:
-        #     raise Exception("SharedHandlerTypeException: This type is not supported: " + str(used_object))
-
-    def complex_command_type_generator(self, handlers, analyzed_object):
-        return ""

package/Binaries/Python/javonet/core/generator/handler/shared/body/SharedBodyHandler.py

@@ -1,10 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-
-
-class SharedBodyHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        return analyzed_object
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        handlers.SHARED_BODY_HANDLER[used_object.command_type].generate_code(existing_string_builder, common_command,
-                                                                             used_object, handlers)

package/Binaries/Python/javonet/core/generator/handler/shared/body/SharedCreateInstanceBodyHandler.py

@@ -1,21 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.CommonGenerator import CommonGenerator
-
-
-class SharedCreateInstanceBodyHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        return analyzed_object
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        existing_string_builder.append("\n")
-        existing_string_builder.append("        self.instance = Javonet.inMemory().")
-        existing_string_builder.append(str(common_command.runtime_name.name))
-        existing_string_builder.append("().")
-        existing_string_builder.append("get_type(\"")
-        existing_string_builder.append(used_object.get_payload()[0])
-        existing_string_builder.append("\").")
-        existing_string_builder.append("create_instance(")
-        CommonGenerator.process_method_arguments_names(existing_string_builder, common_command,
-                                                       used_object.get_payload()[3], handlers)
-        existing_string_builder.append(")")
-        existing_string_builder.append("\n")

package/Binaries/Python/javonet/core/generator/handler/shared/body/SharedGetInstanceFieldBodyHandler.py

@@ -1,16 +0,0 @@
-from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-
-
-class SharedGetInstanceFieldBodyHandler(AbstractGeneratorHandler):
-    def generate_command(self, analyzed_object, parent_command, handlers):
-        return analyzed_object
-
-    def generate_code(self, existing_string_builder, common_command, used_object, handlers):
-        handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_code(existing_string_builder, common_command,
-                                                                      used_object.get_payload()[1], handlers)
-        existing_string_builder.append("(instance.get_instance_field(\"")
-        existing_string_builder.append(used_object.get_payload()[0])
-        existing_string_builder.append("\").")
-        existing_string_builder.append("execute().get_value())")
-        existing_string_builder.append("\n")