javonet-nodejs-sdk 2.0.5 → 2.1.1

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

@@ -12,7 +12,7 @@ extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';
 sub new {
     my $class = shift;
     my $self = {
-        required_parameters_count  => 2
+        required_parameters_count => 2
     };
     return bless $self, $class;
 }
@@ -20,35 +20,33 @@ sub new {
 sub process {
     my ($self, $command) = @_;
     try {
-    my $current_payload_ref = $command->{payload};
-    my @cur_payload = @$current_payload_ref;
-    my $parameters_length = @cur_payload;
-    if ($parameters_length < $self->{required_parameters_count}){
-        die Exception->new("Exception: InvokeInstanceMethod parameters mismatch");
-    }
-
-    my $clazz_instance = $command->{payload}[0];
-    my $method_name = $command->{payload}[1];
-    if ($clazz_instance->can($method_name))
-    {
-        if ($parameters_length == $self->{required_parameters_count}) {
-            return $clazz_instance->$method_name();
+        my $current_payload_ref = $command->{payload};
+        my @cur_payload = @$current_payload_ref;
+        my $parameters_length = @cur_payload;
+        if ($parameters_length < $self->{required_parameters_count}) {
+            die Exception->new("Exception: InvokeInstanceMethod parameters mismatch");
         }
-        else{
-            my @method_arguments;
-            for (my $i=2; $i<$parameters_length; $i++){
-                push @method_arguments, $command->{payload}[$i];
+
+        my $clazz_instance = $command->{payload}[0];
+        my $method_name = $command->{payload}[1];
+        if ($clazz_instance->can($method_name)) {
+            if ($parameters_length == $self->{required_parameters_count}) {
+                return $clazz_instance->$method_name();
+            }
+            else {
+                my @method_arguments;
+                for (my $i = 2; $i < $parameters_length; $i++) {
+                    push @method_arguments, $command->{payload}[$i];
+                }
+                return $clazz_instance->$method_name(@method_arguments);
             }
-            return $clazz_instance->$method_name(@method_arguments);
         }
-    }
-    else
-    {
-        die Exception->new("Exception InvokeInstanceMethod: method not found");
-    }
+        else {
+            die Exception->new("Exception InvokeInstanceMethod: method not found");
+        }
     }
     catch ( $e ) {
-        return $e ;
+        return $e;
     }
 }
 

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

@@ -12,7 +12,7 @@ extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';
 sub new {
     my $class = shift;
     my $self = {
-        required_parameters_count  => 2
+        required_parameters_count => 2
     };
     return bless $self, $class;
 }
@@ -46,7 +46,7 @@ sub process {
         }
     }
     catch ( $e ) {
-        return $e ;
+        return $e;
     }
 }
 

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

@@ -12,7 +12,7 @@ extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';
 sub new {
     my $class = shift;
     my $self = {
-        required_parameters_count  => 2
+        required_parameters_count => 2
     };
     return bless $self, $class;
 }
@@ -23,18 +23,18 @@ sub process {
         my $current_payload_ref = $command->{payload};
         my @cur_payload = @$current_payload_ref;
         my $parameters_length = @cur_payload;
-        if ($parameters_length != $self->{required_parameters_count}){
+        if ($parameters_length != $self->{required_parameters_count}) {
             die Exception->new("Exception: LoadLibrary parameters mismatch");
         }
         my $path_to_class = $command->{payload}[0];
         my $class_file = $command->{payload}[1];
 
-        push (@INC,"$path_to_class");
+        push(@INC, "$path_to_class");
         eval(require $class_file);
         return 0;
     }
     catch ( $e ) {
-        return $e ;
+        return $e;
     }
 }
 

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

@@ -13,7 +13,7 @@ extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';
 sub new {
     my $class = shift;
     my $self = {
-        required_parameters_count  => 1
+        required_parameters_count => 1
     };
     return bless $self, $class;
 }
@@ -22,18 +22,18 @@ sub new {
 sub process {
     my ($self, $command) = @_;
     try {
-    my $current_payload_ref = $command->{payload};
-    my @cur_payload = @$current_payload_ref;
-    my $parameters_length = @cur_payload;
-    if ($parameters_length < $self->{required_parameters_count}) {
-        die Exception->new("Exception: ResolveInstance parameters mismatch");
-    }
-    my $reference_cache = ReferencesCache->new();
-    my $resolved_reference = $reference_cache->resolve_reference($command);
-    return $resolved_reference;
+        my $current_payload_ref = $command->{payload};
+        my @cur_payload = @$current_payload_ref;
+        my $parameters_length = @cur_payload;
+        if ($parameters_length < $self->{required_parameters_count}) {
+            die Exception->new("Exception: ResolveInstance parameters mismatch");
+        }
+        my $reference_cache = ReferencesCache->new();
+        my $resolved_reference = $reference_cache->resolve_reference($command);
+        return $resolved_reference;
     }
     catch ( $e ) {
-        return $e ;
+        return $e;
     }
 }
 1;

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

@@ -13,7 +13,7 @@ extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';
 sub new {
     my $class = shift;
     my $self = {
-        required_parameters_count  => 3
+        required_parameters_count => 3
     };
     return bless $self, $class;
 }
@@ -21,23 +21,23 @@ sub new {
 sub process {
     my ($self, $command) = @_;
     try {
-    my $current_payload_ref = $command->{payload};
-    my @cur_payload = @$current_payload_ref;
-    my $parameters_length = @cur_payload;
-    if ($parameters_length < $self->{required_parameters_count}){
-        die Exception->new("Exception: SetStaticField parameters mismatch");
-    }
-    my $class_name = $command->{payload}[0];
-    my $static_field_name = $command->{payload}[1];
-    my $set_variable_value = $command->{payload}[2];
+        my $current_payload_ref = $command->{payload};
+        my @cur_payload = @$current_payload_ref;
+        my $parameters_length = @cur_payload;
+        if ($parameters_length < $self->{required_parameters_count}) {
+            die Exception->new("Exception: SetStaticField parameters mismatch");
+        }
+        my $class_name = $command->{payload}[0];
+        my $static_field_name = $command->{payload}[1];
+        my $set_variable_value = $command->{payload}[2];
 
-    no strict 'refs';
-    ${"${class_name}::${static_field_name}"} = $set_variable_value;
+        no strict 'refs';
+        ${"${class_name}::${static_field_name}"} = $set_variable_value;
 
-    return ${"${class_name}::${static_field_name}"};
+        return ${"${class_name}::${static_field_name}"};
     }
     catch ( $e ) {
-        return $e ;
+        return $e;
     }
 }
 

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

@@ -9,13 +9,13 @@ my $message;
 
 
 sub new {
-    my ($proto,$exception_message) = @_;
+    my ($proto, $exception_message) = @_;
     my $self = bless {}, $proto;
     $message = $exception_message;
     return $self;
 }
 
-sub get_message(){
+sub get_message() {
     my $self = @_;
     return $message;
 }

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

@@ -5,7 +5,7 @@ use Moose;
 
 our %handler_dict;
 
-sub add_handler_to_dict{
+sub add_handler_to_dict {
     my $command_type = shift;
     my $handler = shift;
     $handler_dict{$command_type} = $handler;

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/Core/Transmitter/PerlTransmitterWrapper.pm

@@ -15,50 +15,64 @@ our @EXPORT = qw(send_command_ activate_);
 my $send_command;
 my $read_response;
 my $activate;
+my $get_native_error;
 
 sub initialize_ {
     my $osname = $^O;
     {
-      $ffi = FFI::Platypus->new( api => 1 );
-      use FFI::Platypus::DL qw( dlopen dlerror RTLD_PLATYPUS_DEFAULT );
-      my $dir = File::Spec->rel2abs( __FILE__ );
-      my $current_dir = path($dir)->parent(3);
-      my $perl_native_lib;
-      if($osname eq "linux") {
-          $perl_native_lib = 'Binaries/Native/Linux/X64/libJavonetPerlRuntimeNative.so';
-      }
-      elsif($osname eq "darwin") {
-          $perl_native_lib = 'Binaries/Native/MacOs/X64/libJavonetPerlRuntimeNative.dylib';
-      }
-      else {
-          $perl_native_lib = 'Binaries/Native/Windows/X64/JavonetPerlRuntimeNative.dll';
-      }
-      $ffi->lib("$current_dir/$perl_native_lib");
-      $send_command = $ffi->function('SendCommand' => ['uchar[]', 'int'] => 'int');
-      $read_response = $ffi->function('ReadResponse' => ['uchar[]', 'int'] => 'int');
-      $activate = $ffi->function('Activate' => ['string', 'string', 'string', 'string', 'string'] => 'int');
+        $ffi = FFI::Platypus->new(api => 1);
+        use FFI::Platypus::DL qw(dlopen dlerror RTLD_PLATYPUS_DEFAULT);
+        my $dir = File::Spec->rel2abs(__FILE__);
+        my $current_dir = path($dir)->parent(3);
+        my $perl_native_lib;
+        if ($osname eq "linux") {
+            $perl_native_lib = 'Binaries/Native/Linux/X64/libJavonetPerlRuntimeNative.so';
+        }
+        elsif ($osname eq "darwin") {
+            $perl_native_lib = 'Binaries/Native/MacOs/X64/libJavonetPerlRuntimeNative.dylib';
+        }
+        else {
+            $perl_native_lib = 'Binaries/Native/Windows/X64/JavonetPerlRuntimeNative.dll';
+        }
+        $ffi->lib("$current_dir/$perl_native_lib");
+        $send_command = $ffi->function('SendCommand' => [ 'uchar[]', 'int' ] => 'int');
+        $read_response = $ffi->function('ReadResponse' => [ 'uchar[]', 'int' ] => 'int');
+        $activate = $ffi->function('Activate' => [ 'string', 'string', 'string', 'string', 'string' ] => 'int');
+        $get_native_error = $ffi->function('GetNativeError' => [] => 'string')
     }
 }
 
 sub send_command_ {
-    my($self, $message_ref) = @_;
+    my ($self, $message_ref) = @_;
     my @message_array = @$message_ref;
     my $response_array_len = $send_command->(\@message_array, scalar @message_array);
 
-    if($response_array_len > 0)
-    {
+    if ($response_array_len > 0) {
         my @response_array = (1 .. $response_array_len);
         $read_response->(\@response_array, $response_array_len);
         return @response_array;
-    } else {
-        die "Javonet error code: $response_array_len";
+    }
+    elsif ($response_array_len == 0) {
+        my $error_message = "Response is empty";
+        die "$error_message";
+    }
+    else {
+        my $error_message = $get_native_error->();
+        die "Javonet native error code: $response_array_len. $error_message";
     }
 }
 
 sub activate_ {
-    my($self, $email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
+    my ($self, $email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
     initialize_();
-    return $activate->($email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
+    my $activation_result = $activate->($email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
+    if ($activation_result < 0) {
+        my $error_message = $get_native_error->();
+        die "Javonet activation result: $activation_result. $error_message";
+    }
+    else {
+        return $activation_result;
+    }
 }
 
 1;

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/{MacOs/X64/javonet/core/handler/utils → Linux/X64/javonet/core/exception}/ExceptionSerializer.py

@@ -2,32 +2,37 @@ 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, [])
-        trace = traceback.format_exception(type(exception), exception, exception.__traceback__)
-        exception_message = exception.__cause__
+    def serialize_exception(exception, command):
+        exception_command = Command(command.runtime_name, CommandType.Exception, [])
+        tb = exception.__traceback__
+        trace = traceback.extract_tb(tb)
+        exception_message = str(exception)
         exception_name = exception.__cause__.__class__.__name__
         stack_classes = PythonStringBuilder()
         stack_methods = PythonStringBuilder()
         stack_lines = PythonStringBuilder()
         stack_files = PythonStringBuilder()
-        for frame_summary in stack:
-            stack_classes.append(ExceptionSerializer.format_class_name_from_file(frame_summary.filename)).append("|")
-            stack_methods.append(frame_summary.name).append("|")
-            stack_lines.append(str(frame_summary.lineno)).append("|")
-            stack_files.append(frame_summary.filename).append("|")
+
+        is_debug = False
+
+        for frame_summary in trace:
+            if "javonet" not in frame_summary.filename or is_debug:
+                stack_classes.append(ExceptionSerializer.format_class_name_from_file(frame_summary.filename)).append("|")
+                stack_methods.append(frame_summary.name).append("|")
+                stack_lines.append(str(frame_summary.lineno)).append("|")
+                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 +50,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/exception/ExceptionThrower.py

@@ -0,0 +1,45 @@
+import re
+import sys
+import traceback
+import types
+
+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(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_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])
+        traceback_str = ""
+
+        for i in range(len(stack_methods) - 1):
+            traceback_str += "File \"{}\", line {}, in {}\n".format(stack_files[i], stack_lines[i], stack_methods[i])
+            if stack_classes[i]:
+                traceback_str += "    {}\n".format(stack_classes[i])
+
+        ExceptionThrower.raise_exception(original_exception,exception_message,traceback_str)
+
+
+    @staticmethod
+    def raise_exception(original_exception, exception_message, traceback_str):
+        raise JavonetException(str(original_exception), exception_message, traceback_str)
+
+    @staticmethod
+    def get_local_stack_trace(stack_trace_classes, stack_trace_methods, stack_trace_lines, stack_trace_files):
+        stack_classes = re.split("\\|", stack_trace_classes)
+        stack_methods = re.split("\\|", stack_trace_methods)
+        stack_lines = re.split("\\|", stack_trace_lines)
+        stack_files = re.split("\\|", stack_trace_files)
+
+        return [stack_classes, stack_methods, stack_lines, stack_files]

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))