javonet-nodejs-sdk 2.1.7 → 2.1.9

package/Binaries/Perl/Linux/X64/lib/Javonet/Core/Handler/CommandHandler/AbstractCommandHandler.pm

@@ -29,13 +29,13 @@ sub iterate {
     for (my $i=0; $i< $length; $i++){
         my $payload_item = $command->{payload}[$i];
         if(blessed($payload_item) and $payload_item->isa('Javonet::Sdk::Core::PerlCommand')
-            and !($payload_item->{command_type} eq Javonet::Sdk::Core::PerlCommandType::get_command_type('Response'))) {
+            and !($payload_item->{command_type} eq Javonet::Sdk::Core::PerlCommandType::get_command_type('Value'))) {
             $command->{payload}[$i] = Javonet::Core::Handler::HandlerDictionary::get_handler(
                 $command->{payload}[$i]->{command_type})->handle_command($command->{payload}[$i]
             );
         }
         if(blessed($payload_item) and $payload_item->isa('Javonet::Sdk::Core::PerlCommand')
-            and $payload_item->{command_type} eq Javonet::Sdk::Core::PerlCommandType::get_command_type('Response')) {
+            and $payload_item->{command_type} eq Javonet::Sdk::Core::PerlCommandType::get_command_type('Value')) {
             $command->{payload}[$i] = $payload_item->{payload}[0];
         }
     }

package/Binaries/Perl/Linux/X64/lib/Javonet/Core/Handler/CommandHandler/ValueHandler.pm

@@ -0,0 +1,30 @@
+package Javonet::Core::Handler::CommandHandler::ValueHandler;
+use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
+use strict;
+use warnings FATAL => 'all';
+use Moose;
+use lib 'lib';
+use Nice::Try;
+use aliased 'Javonet::Core::Exception::Exception' => 'Exception';
+extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';
+
+sub new {
+    my $class = shift;
+    my $self = {
+        required_parameters_count => 1
+    };
+    return bless $self, $class;
+}
+
+sub process {
+    my ($self, $command) = @_;
+    try {
+        return $command->{payload}[0];
+    }
+    catch ( $e ) {
+        return Exception->new($e);
+    }
+}
+
+no Moose;
+1;

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

@@ -3,6 +3,7 @@ use strict;
 use warnings FATAL => 'all';
 use Moose;
 use lib 'lib';
+use aliased 'Javonet::Core::Handler::CommandHandler::ValueHandler' => 'ValueHandler';
 use aliased 'Javonet::Core::Handler::CommandHandler::LoadLibraryHandler' => 'LoadLibraryHandler';
 use aliased 'Javonet::Core::Handler::CommandHandler::GetStaticFieldHandler' => 'GetStaticFieldHandler';
 use aliased 'Javonet::Core::Handler::CommandHandler::SetStaticFieldHandler' => 'SetStaticFieldHandler';
@@ -30,6 +31,7 @@ use aliased 'Javonet::Core::Handler::AbstractHandler' => 'AbstractHandler';
 use aliased 'Javonet::Sdk::Core::RuntimeLib' => 'RuntimeLib', qw(get_runtime);
 use aliased 'Javonet::Core::Handler::HandlerDictionary' => 'HandlerDictionary', qw(get_handler);
 
+my $value_handler = ValueHandler->new();
 my $load_library_handler = LoadLibraryHandler->new();
 my $get_static_field_handler = GetStaticFieldHandler->new();
 my $set_static_field_handler = SetStaticFieldHandler->new();
@@ -48,6 +50,10 @@ 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('Value'),
+    $value_handler
+);
 Javonet::Core::Handler::HandlerDictionary::add_handler_to_dict(
     Javonet::Sdk::Core::PerlCommandType::get_command_type('LoadLibrary'),
     $load_library_handler
@@ -120,7 +126,7 @@ sub handle_command {
     if (ref $response eq '') {
         return PerlCommand->new(
             runtime      => Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
-            command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Response'),
+            command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Value'),
             payload      => [ $response ]
         )
     }

package/Binaries/Perl/Linux/X64/lib/Javonet/Core/Interpreter/Interpreter.pm

@@ -13,21 +13,25 @@ our @EXPORT = qw(process execute_);
 
 my $handler = PerlHandler->new();
 
-
 sub execute_ {
     my $self = shift;
     my $command = shift;
     my $connection_type = shift;
     my $tcp_address = shift;
 
-    require Javonet::Core::Transmitter::PerlTransmitter;
     my $commandSerializer = Javonet::Core::Protocol::CommandSerializer->new();
-    my @byte_message = $commandSerializer->encode($command, $connection_type, $tcp_address, 0);
-    my @byte_array = Javonet::Core::Transmitter::PerlTransmitter->send_command(\@byte_message);
-    my $commandDeserializer = CommandDeserializer->new(\@byte_array);
-    my $response_command = $commandDeserializer->decode();
-    return $response_command;
+    my @serialized_command = $commandSerializer->encode($command, $connection_type, $tcp_address, 0);
+    my @response_byte_array;
+    # if ($command->{runtime} eq Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl')) {
+    #     require Javonet::Core::Receiver::Receiver;
+    #     @response_byte_array = Javonet::Core::Receiver::Receiver->send_command(\@serialized_command);
+    # } else {
+    require Javonet::Core::Transmitter::PerlTransmitter;
+    @response_byte_array = Javonet::Core::Transmitter::PerlTransmitter->send_command(\@serialized_command);
+    # }
 
+    my $commandDeserializer = CommandDeserializer->new(\@response_byte_array);
+    return $commandDeserializer->decode();
 }
 
 sub process {

package/Binaries/Perl/Linux/X64/lib/Javonet/Core/Transmitter/PerlTransmitter.pm

@@ -19,24 +19,23 @@ sub activate_with_licence_file {
 }
 
 sub activate_with_credentials {
-    my($self, $email, $licenceKey) = @_;
-    return __activate($email, $licenceKey);
+    my($self, $licenceKey) = @_;
+    return __activate($licenceKey);
 }
 
 sub activate_with_credentials_and_proxy {
-    my($self, $email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
-    return __activate($email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
+    my($self,  $licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
+    return __activate($licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
 }
 
 sub __activate {
-    my($email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
+    my($licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
     #set default values
-    $email //="";
     $licenceKey //="";
     $proxyHost //="";
     $proxyUserName //="";
     $proxyPassword //="";
-    return PerlTransmitterWrapper->activate_($email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
+    return PerlTransmitterWrapper->activate_($licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
 }
 
 1;

package/Binaries/Perl/Linux/X64/lib/Javonet/Core/Transmitter/PerlTransmitterWrapper.pm

@@ -36,7 +36,7 @@ sub initialize_ {
         $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');
+        $activate = $ffi->function('Activate' => ['string', 'string', 'string', 'string' ] => 'int');
         $get_native_error = $ffi->function('GetNativeError' => [] => 'string')
     }
 }
@@ -62,9 +62,9 @@ sub send_command_ {
 }
 
 sub activate_ {
-    my ($self, $email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
+    my ($self, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
     initialize_();
-    my $activation_result = $activate->($email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
+    my $activation_result = $activate->($licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
     if ($activation_result < 0) {
         my $error_message = $get_native_error->();
         die "Javonet activation result: $activation_result. $error_message";

package/Binaries/Perl/Linux/X64/lib/Javonet/Javonet.pm

@@ -14,15 +14,14 @@ sub activate {
     if(@_ == 1) {
         return Transmitter->activate_with_licence_file();
     }
-
-    if(@_ == 3) {
-        my($self, $email, $licenceKey) = @_;
-        return Transmitter->activate_with_credentials($email, $licenceKey);
-    } elsif (@_ > 3) {
-        my($self, $email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
+    if(@_ == 2) {
+        my($self, $licenceKey) = @_;
+        return Transmitter->activate_with_credentials($licenceKey);
+    } elsif (@_ > 2) {
+        my($self, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword) = @_;
         $proxyUserName //="";
         $proxyPassword //="";
-        return Transmitter->activate_with_credentials_and_proxy($email, $licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
+        return Transmitter->activate_with_credentials_and_proxy($licenceKey, $proxyHost, $proxyUserName, $proxyPassword);
     }
 
 }

package/Binaries/Perl/Linux/X64/lib/Javonet/Sdk/Core/PerlCommand.pm

@@ -83,11 +83,16 @@ sub drop_first_payload_argument {
 
 }
 
-sub add_arg_to_payload_on_beginning{
-    my ($self, $argument) = @_;
+sub prepend_arg_to_payload{
+    my ($self, $current_command) = @_;
     my $current_payload_ref = $self->{payload};
     my @cur_payload = @$current_payload_ref;
-    my @merged_payload = ($argument, @cur_payload);
+    my @merged_payload;
+    if(defined $current_command) {
+        @merged_payload = ($current_command, @cur_payload);
+    } else {
+        @merged_payload = @cur_payload;
+    }
 
     return Javonet::Sdk::Core::PerlCommand->new(runtime => $self->{runtime}, command_type => $self->{command_type}, payload => \@merged_payload);
 }

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

@@ -7,32 +7,34 @@ our @ISA = qw(Exporter);
 our @EXPORT = qw(get_command_type);
 
 my %command_type = (
-    'Response'             => 0,
-    'LoadLibrary'          => 1,
-    'InvokeStaticMethod'   => 2,
-    'GetStaticField'       => 3,
-    'SetStaticField'       => 4,
-    'CreateClassInstance'  => 5,
-    'GetType'              => 6,
-    'Reference'            => 7,
-    'GetModule'            => 8,
-    'InvokeInstanceMethod' => 9,
-    'Exception'            => 10,
-    'HeartBeat'            => 11,
-    'Cast'                 => 12,
-    'GetInstanceField'     => 13,
-    'Optimize'             => 14,
-    'GenerateLib'          => 15,
-    'InvokeGlobalMethod'   => 16,
-    'DestructReference'    => 17,
-    'Array'                => 18,
-    'ArrayGetItem'         => 19,
-    'ArrayGetSize'         => 20,
-    'ArrayGetRank'         => 21,
-    'ArraySetItem'         => 22,
-    'Array'                => 23,
-    'RetrieveArray'        => 24,
-    'SetInstanceField'         => 25,
+    'Value'                  => 0,
+    'LoadLibrary'               => 1,
+    'InvokeStaticMethod'        => 2,
+    'GetStaticField'            => 3,
+    'SetStaticField'            => 4,
+    'CreateClassInstance'       => 5,
+    'GetType'                   => 6,
+    'Reference'                 => 7,
+    'GetModule'                 => 8,
+    'InvokeInstanceMethod'      => 9,
+    'Exception'                 => 10,
+    'HeartBeat'                 => 11,
+    'Cast'                      => 12,
+    'GetInstanceField'          => 13,
+    'Optimize'                  => 14,
+    'GenerateLib'               => 15,
+    'InvokeGlobalMethod'        => 16,
+    'DestructReference'         => 17,
+    'Array'                     => 18,
+    'ArrayGetItem'              => 19,
+    'ArrayGetSize'              => 20,
+    'ArrayGetRank'              => 21,
+    'ArraySetItem'              => 22,
+    'Array'                     => 23,
+    'RetrieveArray'             => 24,
+    'SetInstanceField'          => 25,
+    'InvokeGenericStaticMethod' => 26,
+    'InvokeGenericMethod'       => 27,
 
 
 );

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

@@ -4,7 +4,7 @@ use warnings FATAL => 'all';
 use Moose;
 
 use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
-use aliased 'Javonet::Core::Interpreter::Interpreter' => 'Interpreter';
+use aliased 'Javonet::Core::Interpreter::Interpreter' => 'Interpreter', qw(execute_);
 use aliased 'Javonet::Core::Exception::ExceptionThrower' => 'ExceptionThrower';
 
 extends 'Javonet::Sdk::Internal::Abstract::AbstractInstanceContext',
@@ -17,24 +17,25 @@ sub new {
     my $class = shift;
 
     my $self = {
-        runtime_lib     => shift,
-        connection_type => shift,
-        tcp_address     => shift,
-        current_command => shift,
-        isExecuted      => shift
+        runtime_name     => shift,
+        connection_type  => shift,
+        tcp_address      => shift,
+        current_command  => shift,
+        isExecuted       => shift,
+        response_command => 0,
     };
 
+
     bless $self, $class;
     return $self;
 }
 
 DESTROY {
     my $self = $_[0];
-
     if ($self->{current_command}->{command_type} == Javonet::Sdk::Core::PerlCommandType::get_command_type('Reference') &&
         $self->{isExecuted} == 1) {
         $self->{current_command} = Javonet::Sdk::Core::PerlCommand->new(
-            runtime      => $self->{runtime_lib},
+            runtime      => $self->{runtime_name},
             command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('DestructReference'),
             payload      => $self->{current_command}->{payload}
         );
@@ -45,29 +46,28 @@ DESTROY {
 #@override
 sub execute {
     my $self = $_[0];
-    my $response;
-    if ($self->{runtime_lib} == Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl')) {
-        $response = $perl_handler->handle_command($self->{current_command});
-    }
-    else {
-        $response = Interpreter->execute_($self->{current_command}, $self->{connection_type}, $self->{tcp_address});
+
+    if($self->{current_command}->{runtime} eq Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl')) {
+        $self->{response_command} = $perl_handler->handle_command($self->{current_command});
+    } else {
+        $self->{response_command} = Interpreter->execute_($self->{current_command}, $self->{connection_type}, $self->{tcp_address});
     }
 
-    if ($response->{command_type} == Javonet::Sdk::Core::PerlCommandType::get_command_type('Exception')) {
-        ExceptionThrower->throwException($response)
+    if ($self->{response_command}->{command_type} == Javonet::Sdk::Core::PerlCommandType::get_command_type('Exception')) {
+        ExceptionThrower->throwException($self->{response_command})
     }
 
     if ($self->{current_command}->{command_type} == Javonet::Sdk::Core::PerlCommandType::get_command_type('CreateClassInstance')) {
-        $self->{current_command} = $response;
+        $self->{current_command} = $self->{response_command};
         $self->{isExecuted} = 1;
         return $self;
     }
 
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
-        $response,
+        $self->{response_command},
         1
     );
 }
@@ -77,12 +77,12 @@ sub execute {
 sub invoke_instance_method {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('InvokeInstanceMethod'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -94,12 +94,12 @@ sub invoke_instance_method {
 sub get_instance_field {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('GetInstanceField'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -111,12 +111,12 @@ sub get_instance_field {
 sub set_instance_field {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('SetInstanceField'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -128,12 +128,12 @@ sub set_instance_field {
 sub create_instance {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('CreateClassInstance'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -145,12 +145,12 @@ sub create_instance {
 sub invoke_static_method {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('InvokeStaticMethod'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -166,12 +166,12 @@ sub set_generic_type {
 sub get_static_field {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('GetStaticField'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -183,12 +183,12 @@ sub get_static_field {
 sub set_static_field {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('SetStaticField'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -199,12 +199,12 @@ sub set_static_field {
 sub get_index {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('ArrayGetItem'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -215,12 +215,12 @@ sub get_index {
 sub get_size {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('ArrayGetSize'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -231,12 +231,12 @@ sub get_size {
 sub get_rank {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('ArrayGetRank'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -247,12 +247,12 @@ sub get_rank {
 sub set_index {
     my ($self, @arguments) = @_;
     my $command = Javonet::Sdk::Core::PerlCommand->new(
-        runtime      => $self->{runtime_lib},
+        runtime      => $self->{runtime_name},
         command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('ArraySetItem'),
         payload      => \@arguments
     );
     return Javonet::Sdk::Internal::InvocationContext->new(
-        $self->{runtime_lib},
+        $self->{runtime_name},
         $self->{connection_type},
         $self->{tcp_address},
         $self->build_command($command),
@@ -260,6 +260,43 @@ sub set_index {
     );
 }
 
+sub invoke_generic_static_method {
+    my ($self, @arguments) = @_;
+    my $command = Javonet::Sdk::Core::PerlCommand->new(
+        runtime      => $self->{runtime_name},
+        command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('InvokeGenericStaticMethod'),
+        payload      => \@arguments
+    );
+    return Javonet::Sdk::Internal::InvocationContext->new(
+        $self->{runtime_name},
+        $self->{connection_type},
+        $self->{tcp_address},
+        $self->build_command($command),
+        0
+    );
+}
+
+sub invoke_generic_method {
+    my ($self, @arguments) = @_;
+    my $command = Javonet::Sdk::Core::PerlCommand->new(
+        runtime      => $self->{runtime_name},
+        command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('InvokeGenericMethod'),
+        payload      => \@arguments
+    );
+    return Javonet::Sdk::Internal::InvocationContext->new(
+        $self->{runtime_name},
+        $self->{connection_type},
+        $self->{tcp_address},
+        $self->build_command($command),
+        0
+    );
+}
+
+sub get_current_command {
+    my $self = shift;
+    return $self->{current_command};
+}
+
 #@override
 sub get_value {
     my $self = shift;
@@ -268,19 +305,25 @@ sub get_value {
 
 sub build_command {
     my ($self, $command) = @_;
-    my $command_payload_length = @{$self->{current_command}->{payload}};
+    my $command_payload_length = @{$command->{payload}};
 
     for (my $i = 0; $i < $command_payload_length; $i++) {
-        if (blessed($self->{current_command}->{payload}[$i]) and $self->{current_command}->{payload}[$i]->isa('Javonet::Sdk::Internal::InvocationContext')) {
-            $self->{current_command}->{payload}[$i] = $self->{current_command}->{payload}[$i]->current_command;
-        }
+        $command->{payload}[$i] = $self->encapsulate_payload_item($command->{payload}[$i]);
     }
+    return $command->prepend_arg_to_payload($self->{current_command});
+}
 
-    if (!defined $self->{current_command}) {
-        return $command;
-    }
-    else {
-        return $command->add_arg_to_payload_on_beginning($self->{current_command});
+sub encapsulate_payload_item {
+    my ($self, $payload_item) = @_;
+    if (blessed($payload_item) and $payload_item->isa('Javonet::Sdk::Internal::InvocationContext')) {
+        # return Javonet::Sdk::Core::PerlCommand->new(
+        #     runtime      => $self->{runtime_name},
+        #     command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Value'),
+        #     payload      => $payload_item->get_current_command(),
+        # );
+        return $payload_item->get_current_command();
+    } else {
+        return $payload_item;
     }
 }