javonet-nodejs-sdk 2.0.4 → 2.1.0

package/Binaries/Perl/Windows/X64/lib/Javonet/Core/Handler/PerlHandler.pm

@@ -15,6 +15,11 @@ use aliased 'Javonet::Core::Handler::Exception' => 'Exception';
 use aliased 'Javonet::Core::Handler::CommandHandler::CastingHandler' => 'CastingHandler';
 use aliased 'Javonet::Core::Handler::CommandHandler::GetInstanceFieldHandler' => 'GetInstanceFieldHandler';
 use aliased 'Javonet::Core::Handler::CommandHandler::DestructReferenceHandler' => 'DestructReferenceHandler';
+use aliased 'Javonet::Core::Handler::CommandHandler::ArrayGetItemHandler' => 'ArrayGetItemHandler';
+use aliased 'Javonet::Core::Handler::CommandHandler::ArrayGetSizeHandler' => 'ArrayGetSizeHandler';
+use aliased 'Javonet::Core::Handler::CommandHandler::ArrayGetRankHandler' => 'ArrayGetRankHandler';
+use aliased 'Javonet::Core::Handler::CommandHandler::ArraySetItemHandler' => 'ArraySetItemHandler';
+
 
 use aliased 'Javonet::Sdk::Core::PerlCommandType' => 'PerlCommandType', qw(get_command_type);
 use aliased 'Javonet::Sdk::Core::PerlCommand' => 'PerlCommand';
@@ -34,6 +39,11 @@ my $get_type_handler = GetTypeHandler->new();
 my $casting_handler = CastingHandler->new();
 my $get_instance_field_handler = GetInstanceFieldHandler->new();
 my $destruct_reference_handler = DestructReferenceHandler->new();
+my $array_get_item_handler = ArrayGetItemHandler->new();
+my $array_get_size_handler = ArrayGetSizeHandler->new();
+my $array_get_rank_handler = ArrayGetRankHandler->new();
+my $array_set_item_handler = ArraySetItemHandler->new();
+
 
 Javonet::Core::Handler::HandlerDictionary::add_handler_to_dict(
     Javonet::Sdk::Core::PerlCommandType::get_command_type('LoadLibrary'),
@@ -79,6 +89,22 @@ Javonet::Core::Handler::HandlerDictionary::add_handler_to_dict(
     Javonet::Sdk::Core::PerlCommandType::get_command_type('DestructReference'),
     $destruct_reference_handler
 );
+Javonet::Core::Handler::HandlerDictionary::add_handler_to_dict(
+    Javonet::Sdk::Core::PerlCommandType::get_command_type('ArrayGetItem'),
+    $array_get_item_handler
+);
+Javonet::Core::Handler::HandlerDictionary::add_handler_to_dict(
+    Javonet::Sdk::Core::PerlCommandType::get_command_type('ArrayGetSize'),
+    $array_get_size_handler
+);
+Javonet::Core::Handler::HandlerDictionary::add_handler_to_dict(
+    Javonet::Sdk::Core::PerlCommandType::get_command_type('ArrayGetRank'),
+    $array_get_rank_handler
+);
+Javonet::Core::Handler::HandlerDictionary::add_handler_to_dict(
+    Javonet::Sdk::Core::PerlCommandType::get_command_type('ArraySetSize'),
+    $array_set_item_handler
+);
 
 sub handle_command {
     my ($self, $command) = @_;
@@ -91,16 +117,18 @@ sub handle_command {
             payload      => [ $response ]
         )
     }
-    elsif (ref $response eq 'ARRAY') {
-        {
-            return PerlCommand->new(
-                runtime      => Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
-                command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Array'),
-                payload      => [ $response ]
-            )
-        }
-    }
-    elsif ($response->isa("Javonet::Core::Handler::Exception")) {
+    # elsif (ref $response eq 'ARRAY') {
+    #     {
+    #         my $reference_cache = ReferencesCache->new();
+    #         my $guid = $reference_cache->cache_reference($response);
+    #         return PerlCommand->new(
+    #             runtime      => Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
+    #             command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Reference'),
+    #             payload      => [ $guid ]
+    #         )
+    #     }
+    # }
+    elsif (ref $response eq "Javonet::Core::Handler::Exception") {
         return PerlCommand->new(
             runtime      => Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
             command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Exception'),

package/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/PerlCommandType.pm

@@ -6,7 +6,6 @@ use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT = qw(get_command_type);
 
-
 my %command_type = (
     'Response'             => 0,
     'LoadLibrary'          => 1,
@@ -26,7 +25,11 @@ my %command_type = (
     'GenerateLib'          => 15,
     'InvokeGlobalMethod'   => 16,
     'DestructReference'    => 17,
-    'Array'                => 18
+    'Array'                => 18,
+    'ArrayGetItem'         => 19,
+    'ArrayGetSize'         => 20,
+    'ArrayGetRank'         => 21,
+    'ArraySetSize'         => 22,
 
 );
 

package/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/Abstract/AbstractMethodInvocationContext.pm

@@ -12,5 +12,7 @@ sub set_generic_type : Abstract;
 
 sub get_static_field : Abstract;
 
+sub set_static_field : Abstract;
+
 no Moose;
 1;

package/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/InvocationContext.pm

@@ -161,6 +161,7 @@ sub get_static_field {
     );
 }
 
+#@override
 sub set_static_field {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
@@ -177,6 +178,69 @@ sub set_static_field {
     );
 }
 
+sub get_index {
+    my ($self, @arguments) = @_;
+    my $command = Javonet::Sdk::Core::PerlCommand->new(
+        runtime      => $self->{runtime_lib},
+        command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('ArrayGetItem'),
+        payload      => \@arguments
+    );
+    return Javonet::Sdk::Internal::InvocationContext->new(
+        $self->{runtime_lib},
+        $self->{connection_type},
+        $self->{tcp_address},
+        $self->build_command($command),
+        0
+    );
+}
+
+sub get_size {
+    my ($self, @arguments) = @_;
+    my $command = Javonet::Sdk::Core::PerlCommand->new(
+        runtime      => $self->{runtime_lib},
+        command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('ArrayGetSize'),
+        payload      => \@arguments
+    );
+    return Javonet::Sdk::Internal::InvocationContext->new(
+        $self->{runtime_lib},
+        $self->{connection_type},
+        $self->{tcp_address},
+        $self->build_command($command),
+        0
+    );
+}
+
+sub get_rank {
+    my ($self, @arguments) = @_;
+    my $command = Javonet::Sdk::Core::PerlCommand->new(
+        runtime      => $self->{runtime_lib},
+        command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('ArrayGetRank'),
+        payload      => \@arguments
+    );
+    return Javonet::Sdk::Internal::InvocationContext->new(
+        $self->{runtime_lib},
+        $self->{connection_type},
+        $self->{tcp_address},
+        $self->build_command($command),
+        0
+    );
+}
+
+sub set_index {
+    my ($self, @arguments) = @_;
+    my $command = Javonet::Sdk::Core::PerlCommand->new(
+        runtime      => $self->{runtime_lib},
+        command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('ArraySetSize'),
+        payload      => \@arguments
+    );
+    return Javonet::Sdk::Internal::InvocationContext->new(
+        $self->{runtime_lib},
+        $self->{connection_type},
+        $self->{tcp_address},
+        $self->build_command($command),
+        0
+    );
+}
 
 #@override
 sub get_value {

package/Binaries/Python/Linux/X64/javonet/core/{handler/utils → exception}/ExceptionSerializer.py

@@ -2,17 +2,17 @@ import os
 import traceback
 
 from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
-from javonet.sdk.core.ExceptionType import ExceptionType
+from javonet.utils.ExceptionType import ExceptionType
 
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
 
 
 class ExceptionSerializer:
 
     @staticmethod
-    def serialize_exception(exception, python_command, stack):
-        exception_command = PythonCommand(python_command.target_runtime, PythonCommandType.Exception, [])
+    def serialize_exception(exception, command, stack):
+        exception_command = Command(command.runtime_name, CommandType.Exception, [])
         trace = traceback.format_exception(type(exception), exception, exception.__traceback__)
         exception_message = exception.__cause__
         exception_name = exception.__cause__.__class__.__name__
@@ -27,7 +27,7 @@ class ExceptionSerializer:
             stack_files.append(frame_summary.filename).append("|")
 
         exception_command = exception_command.add_arg_to_payload(ExceptionSerializer.get_exception_code(exception_name))
-        exception_command = exception_command.add_arg_to_payload(str(python_command))
+        exception_command = exception_command.add_arg_to_payload(str(command))
         exception_command = exception_command.add_arg_to_payload(exception_name)
         exception_command = exception_command.add_arg_to_payload(str(exception_message))
         exception_command = exception_command.add_arg_to_payload(stack_classes.__str__())
@@ -45,7 +45,7 @@ class ExceptionSerializer:
     IOException = 1
     FileNotFoundException = 2
     RuntimeException = 3
-    ArithemticException = 4
+    ArithmeticException = 4
     IllegalArgumentException = 5
     IndexOutOfBoundsException = 6
     NullPointerException = 7

package/Binaries/Python/Linux/X64/javonet/core/{handler/utils → exception}/ExceptionThrower.py

@@ -1,27 +1,26 @@
 import re
-import sys
 import traceback
 
-from javonet.core.handler.utils.JavonetException import JavonetException
-from javonet.sdk.core.ExceptionType import ExceptionType
-from javonet.sdk.core.PythonCommand import PythonCommand
+from javonet.core.exception.JavonetException import JavonetException
+from javonet.utils.ExceptionType import ExceptionType
+from javonet.utils.Command import Command
 
 
 class ExceptionThrower:
 
     @staticmethod
-    def throw_exception(python_command_exception: PythonCommand):
-        original_exception = ExceptionType.to_exception(python_command_exception.get_payload()[0])
-        javonet_stack_command = python_command_exception.get_payload()[1]
-        exception_name = python_command_exception.get_payload()[2]
-        exception_message = python_command_exception.get_payload()[3]
+    def throw_exception(command_exception: Command):
+        original_exception = ExceptionType.to_exception(command_exception.get_payload()[0])
+        javonet_stack_command = command_exception.get_payload()[1]
+        exception_name = command_exception.get_payload()[2]
+        exception_message = command_exception.get_payload()[3]
 
         stack_trace = []
-        if len(python_command_exception.get_payload()) > 7:
-            stack_classes, stack_methods, stack_lines, stack_files = ExceptionThrower.get_local_stack_trace(python_command_exception.get_payload()[4],
-                                                python_command_exception.get_payload()[5],
-                                                python_command_exception.get_payload()[6],
-                                                python_command_exception.get_payload()[7])
+        if len(command_exception.get_payload()) > 7:
+            stack_classes, stack_methods, stack_lines, stack_files = ExceptionThrower.get_local_stack_trace(command_exception.get_payload()[4],
+                                                command_exception.get_payload()[5],
+                                                command_exception.get_payload()[6],
+                                                command_exception.get_payload()[7])
         else:
             stack_trace = []
         traceback_str = ""

package/Binaries/Python/Linux/X64/javonet/core/generator/handler/CreateInstanceGeneratorHandler.py

@@ -3,14 +3,14 @@ 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.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class CreateInstanceGeneratorHandler(AbstractGeneratorHandler):
     def generate_command(self, analyzed_object, parent_command, handlers):
-        create_instance_command = PythonCommand(RuntimeLib.python, PythonCommandType.CreateClassInstance, [])
+        create_instance_command = Command(RuntimeName.python, CommandType.CreateClassInstance, [])
         create_instance_command = create_instance_command.add_arg_to_payload(
             handlers.SHARED_HANDLER[SharedHandlerType.CLASS_NAME].generate_command(parent_command.get_payload()[0],
                                                                                    create_instance_command, handlers))

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

@@ -7,9 +7,9 @@ from os.path import isfile, join
 
 from javonet.core.generator.handler.Handlers import Handlers
 from javonet.core.generator.internal.PythonStringBuilder import PythonStringBuilder
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
+from javonet.utils.RuntimeName import RuntimeName
 
 
 class GeneratorHandler:
@@ -17,11 +17,11 @@ 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 = PythonCommand(RuntimeLib.python, PythonCommandType.GenerateLib, [])
+        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[PythonCommandType.GetType].
+                add_arg_to_payload(handlers.GENERATOR_HANDLER[CommandType.GetType].
                                    generate_command(handlers.types_to_analyze.pop(0), structured_command_for_class,
                                                     handlers))
 
@@ -31,7 +31,7 @@ class GeneratorHandler:
         generator_handlers = Handlers()
         for i in range(0, len(command.get_payload())):
             existing_string_builder = PythonStringBuilder()
-            if isinstance(command.get_payload()[i], PythonCommand):
+            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]),

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

@@ -1,13 +1,13 @@
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
 from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+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 = PythonCommand(RuntimeLib.python, PythonCommandType.GetInstanceField, [])
+        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,
@@ -30,7 +30,7 @@ class GetInstanceFieldGeneratorHandler(AbstractGeneratorHandler):
         existing_string_builder.append(" ")
         existing_string_builder.append("=")
         existing_string_builder.append(" ")
-        handlers.SHARED_BODY_HANDLER[PythonCommandType.GetInstanceField].generate_code(existing_string_builder,
-                                                                                       common_command,
-                                                                                       used_object,
-                                                                                       handlers)
+        handlers.SHARED_BODY_HANDLER[CommandType.GetInstanceField].generate_code(existing_string_builder,
+                                                                                 common_command,
+                                                                                 used_object,
+                                                                                 handlers)

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

@@ -1,14 +1,14 @@
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
 from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+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 = PythonCommand(RuntimeLib.python, PythonCommandType.GetStaticField, [])
+        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))
@@ -34,6 +34,6 @@ class GetStaticFieldGeneratorHandler(AbstractGeneratorHandler):
         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[PythonCommandType.GetStaticField].generate_code(existing_string_builder,
-                                                                                     common_command,
-                                                                                     used_object, handlers)
+        handlers.SHARED_BODY_HANDLER[CommandType.GetStaticField].generate_code(existing_string_builder,
+                                                                               common_command,
+                                                                               used_object, handlers)

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

@@ -2,14 +2,14 @@ import inspect
 
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
 from javonet.core.generator.internal.SharedHandlerType import SharedHandlerType
-from javonet.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+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 = PythonCommand(RuntimeLib.python, PythonCommandType.GetType, [])
+        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__,
@@ -25,20 +25,20 @@ class GetTypeGeneratorHandler(AbstractGeneratorHandler):
             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[PythonCommandType.CreateClassInstance].generate_command(
+                    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[PythonCommandType.InvokeStaticMethod].generate_command(
+                    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[PythonCommandType.InvokeInstanceMethod].generate_command(
+                    handlers.GENERATOR_HANDLER[CommandType.InvokeInstanceMethod].generate_command(
                         method[1],
                         get_type_command,
                         handlers))
@@ -47,7 +47,7 @@ class GetTypeGeneratorHandler(AbstractGeneratorHandler):
             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[PythonCommandType.GetStaticField].generate_command(
+                handlers.GENERATOR_HANDLER[CommandType.GetStaticField].generate_command(
                     dict_items,
                     get_type_command,
                     handlers))

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

@@ -14,7 +14,7 @@ from javonet.core.generator.handler.shared.body.SharedInvokeInstanceMethodBodyHa
     SharedInvokeInstanceMethodBodyHandler
 from javonet.core.generator.handler.shared.body.SharedInvokeStaticMethodBodyHandler import \
     SharedInvokeStaticMethodBodyHandler
-from javonet.sdk.core.PythonCommandType import PythonCommandType
+from javonet.utils.CommandType import CommandType
 
 from javonet.core.generator.handler.shared.SharedArgumentNameHandler import SharedArgumentNameHandler
 from javonet.core.generator.handler.shared.SharedClassInstanceHandler import SharedClassInstanceHandler
@@ -44,16 +44,16 @@ class Handlers:
         self.SHARED_HANDLER[SharedHandlerType.CLAZZ_INSTANCE] = SharedClassInstanceHandler()
         self.SHARED_HANDLER[SharedHandlerType.RETURN_TYPE] = SharedReturnTypeHandler()
 
-        self.SHARED_BODY_HANDLER[PythonCommandType.CreateClassInstance] = SharedCreateInstanceBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.GetType] = SharedGetTypeBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.InvokeInstanceMethod] = SharedInvokeInstanceMethodBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.InvokeStaticMethod] = SharedInvokeStaticMethodBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.GetStaticField] = SharedGetStaticFieldBodyHandler()
-        self.SHARED_BODY_HANDLER[PythonCommandType.GetInstanceField] = SharedGetInstanceFieldBodyHandler()
-
-        self.GENERATOR_HANDLER[PythonCommandType.CreateClassInstance] = CreateInstanceGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.GetType] = GetTypeGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.InvokeInstanceMethod] = InvokeInstanceMethodGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.InvokeStaticMethod] = InvokeStaticMethodGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.GetStaticField] = GetStaticFieldGeneratorHandler()
-        self.GENERATOR_HANDLER[PythonCommandType.GetInstanceField] = GetInstanceFieldGeneratorHandler()
+        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/Linux/X64/javonet/core/generator/handler/InvokeInstanceMethodGeneratorHandler.py

@@ -4,14 +4,14 @@ 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.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+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 = PythonCommand(RuntimeLib.python, PythonCommandType.InvokeInstanceMethod, [])
+        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

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

@@ -3,14 +3,14 @@ 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.sdk.core.PythonCommand import PythonCommand
-from javonet.sdk.core.PythonCommandType import PythonCommandType
-from javonet.sdk.core.RuntimeLib import RuntimeLib
+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 = PythonCommand(RuntimeLib.python, PythonCommandType.InvokeStaticMethod, [])
+        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),

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

@@ -1,5 +1,5 @@
 from javonet.core.generator.handler.AbstractGeneretatorHandler import AbstractGeneratorHandler
-from javonet.sdk.core.Type import Type
+from javonet.utils.Type import Type
 
 
 class SharedTypeHandler(AbstractGeneratorHandler):

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

@@ -9,7 +9,7 @@ class SharedCreateInstanceBodyHandler(AbstractGeneratorHandler):
     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.target_runtime.name))
+        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])

package/Binaries/Python/Linux/X64/javonet/core/generator/handler/shared/body/SharedGetStaticFieldBodyHandler.py

@@ -10,7 +10,7 @@ class SharedGetStaticFieldBodyHandler(AbstractGeneratorHandler):
         handlers.SHARED_HANDLER[SharedHandlerType.TYPE].generate_code(existing_string_builder, common_command,
                                                                       used_object.get_payload()[1], handlers)
         existing_string_builder.append("(Javonet.inMemory().")
-        existing_string_builder.append(str(common_command.target_runtime.name))
+        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()[3])

package/Binaries/Python/Linux/X64/javonet/core/generator/handler/shared/body/SharedGetTypeBodyHandler.py

@@ -7,7 +7,7 @@ class SharedGetTypeBodyHandler(AbstractGeneratorHandler):
 
     def generate_code(self, existing_string_builder, common_command, used_object, handlers):
         existing_string_builder.append("return Javonet.inMemory().")
-        existing_string_builder.append(str(common_command.target_runtime))
+        existing_string_builder.append(str(common_command.runtime_name))
         existing_string_builder.append("().")
         existing_string_builder.append("get_type(\"")
         existing_string_builder.append(used_object.get_payload()[0])

package/Binaries/Python/Linux/X64/javonet/core/generator/handler/shared/body/SharedInvokeStaticMethodBodyHandler.py

@@ -12,7 +12,7 @@ class SharedInvokeStaticMethodBodyHandler(AbstractGeneratorHandler):
             existing_string_builder.append("        ")
             existing_string_builder.append("result = ")
             existing_string_builder.append("Javonet.inMemory().")
-            existing_string_builder.append(str(common_command.target_runtime.name))
+            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()[3])
@@ -40,7 +40,7 @@ class SharedInvokeStaticMethodBodyHandler(AbstractGeneratorHandler):
                                                                                 used_object.get_payload()[1],
                                                                                 handlers)
             existing_string_builder.append("(Javonet.inMemory().")
-            existing_string_builder.append(str(common_command.target_runtime.name))
+            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()[3])

package/Binaries/Python/Linux/X64/javonet/core/handler/AbstractHandler.py

@@ -1,3 +1,3 @@
 class AbstractHandler:
-    def HandleCommand(self, python_command):
+    def handle_command(self, command):
         raise NotImplementedError('subclasses must override HandleCommand()!')

package/Binaries/Python/Linux/X64/javonet/core/handler/CommandHandler/AbstractCommandHandler.py

@@ -1,25 +1,26 @@
 from javonet.core.handler.HandlerDictionary import handler_dict
-from javonet.sdk.core.PythonCommand import PythonCommand
+from javonet.utils.Command import Command
 
 
 class AbstractCommandHandler:
-    pass
     _required_parameters_count = 0
 
-    def HandleCommand(self, python_command):
+    def process(self, command):
+        pass
+
+    def handle_command(self, command):
         try:
-            self.iterate(python_command)
-            return self.process(python_command)
+            self.__iterate(command)
+            return self.process(command)
         except Exception as e:
             raise e
 
-    def iterate(self, command):
+    @staticmethod
+    def __iterate(command):
         for i in range(0, len(command.payload)):
-            if isinstance(command.payload[i], PythonCommand):
+            if isinstance(command.payload[i], Command):
                 try:
-                    command.payload[i] = handler_dict.get(command.payload[i].command_type).HandleCommand(command.payload[i])
+                    command.payload[i] = handler_dict.get(command.payload[i].command_type).handle_command(
+                        command.payload[i])
                 except Exception as e:
                     raise e
-
-    def process(self, python_command):
-        pass