javonet-ruby-sdk 2.4.7 → 2.4.9

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Handler/CommandHandler/ResolveInstanceHandler.pm

@@ -1,15 +1,14 @@
 package Javonet::Core::Handler::CommandHandler::ResolveInstanceHandler;
-use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
 use strict;
 use warnings FATAL => 'all';
-use Moose;
 use lib 'lib';
-use lib 'data_seed';
+use Moose;
 use Nice::Try;
 use aliased 'Javonet::Core::Exception::Exception' => 'Exception';
 use aliased 'Javonet::Core::Handler::ReferencesCache' => 'ReferencesCache', qw(get_instance resolve_reference);
 extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';
 
+
 sub new {
     my $class = shift;
     my $self = {

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Handler/CommandHandler/SetInstanceFieldHandler.pm

@@ -1,12 +1,9 @@
 package Javonet::Core::Handler::CommandHandler::SetInstanceFieldHandler;
-use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
 use strict;
 use warnings FATAL => 'all';
-use Moose;
 use lib 'lib';
-use lib 'data_seed';
+use Moose;
 use Nice::Try;
-use Data::Dumper;
 use aliased 'Javonet::Core::Exception::Exception' => 'Exception';
 extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';
 
@@ -31,8 +28,7 @@ sub process {
         my $field_name = $command->{payload}[1];
         my $new_value = $command->{payload}[2];
 
-        no strict 'refs';
-        ${"${instance}->${field_name}"} = $new_value;
+        $instance->{$field_name} = $new_value;
         return 0;
     }
     catch ($e){

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Handler/CommandHandler/SetStaticFieldHandler.pm

@@ -1,9 +1,8 @@
 package Javonet::Core::Handler::CommandHandler::SetStaticFieldHandler;
-use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
 use strict;
 use warnings FATAL => 'all';
-use Moose;
 use lib 'lib';
+use Moose;
 use Nice::Try;
 use aliased 'Javonet::Core::Exception::Exception' => 'Exception';
 extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Handler/CommandHandler/ValueHandler.pm

@@ -1,9 +1,8 @@
 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 Moose;
 use Nice::Try;
 use aliased 'Javonet::Core::Exception::Exception' => 'Exception';
 extends 'Javonet::Core::Handler::CommandHandler::AbstractCommandHandler';

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Handler/HandlerDictionary.pm

@@ -1,6 +1,7 @@
 package Javonet::Core::Handler::HandlerDictionary;
 use strict;
 use warnings FATAL => 'all';
+use lib 'lib';
 use Moose;
 
 our %handler_dict;
@@ -17,4 +18,5 @@ sub get_handler {
     return $handler;
 }
 
+no Moose;
 1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Handler/PerlHandler.pm

@@ -1,8 +1,8 @@
 package Javonet::Core::Handler::PerlHandler;
 use strict;
 use warnings FATAL => 'all';
-use Moose;
 use lib 'lib';
+use Moose;
 use aliased 'Javonet::Core::Handler::CommandHandler::ValueHandler' => 'ValueHandler';
 use aliased 'Javonet::Core::Handler::CommandHandler::LoadLibraryHandler' => 'LoadLibraryHandler';
 use aliased 'Javonet::Core::Handler::CommandHandler::GetStaticFieldHandler' => 'GetStaticFieldHandler';
@@ -123,6 +123,14 @@ sub handle_command {
     my ($self, $command) = @_;
     my $response = Javonet::Core::Handler::HandlerDictionary::get_handler($command->{command_type})->handle_command($command);
 
+    if (!defined $response) {
+        return PerlCommand->new(
+            runtime      => Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
+            command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Value'),
+            payload      => [ $response ]
+        )
+    }
+
     if (ref $response eq '') {
         return PerlCommand->new(
             runtime      => Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Handler/ReferencesCache.pm

@@ -40,5 +40,4 @@ sub delete_reference{
 
 
 no Moose;
-
 1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Interpreter/Interpreter.pm

@@ -6,11 +6,6 @@ use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
 use aliased 'Javonet::Core::Protocol::CommandSerializer' => 'CommandSerializer', qw(encode);
 use aliased 'Javonet::Core::Protocol::CommandDeserializer' => 'CommandDeserializer', qw(decode);
 
-use Exporter;
-
-our @ISA = qw(Exporter);
-our @EXPORT = qw(process execute_);
-
 my $handler = PerlHandler->new();
 
 sub execute_ {
@@ -21,28 +16,28 @@ sub execute_ {
 
     my $commandSerializer = Javonet::Core::Protocol::CommandSerializer->new();
     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);
+    my $response_byte_array_ref;
+    if ($command->{runtime} eq Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl')) {
+        require Javonet::Core::Receiver::Receiver;
+        $response_byte_array_ref = Javonet::Core::Receiver::Receiver->send_command(\@serialized_command);
+    } else {
+        require Javonet::Core::Transmitter::PerlTransmitter;
+        $response_byte_array_ref = Javonet::Core::Transmitter::PerlTransmitter->send_command(\@serialized_command);
+    }
+
+    my $commandDeserializer = CommandDeserializer->new($response_byte_array_ref);
     return $commandDeserializer->decode();
 }
 
 sub process {
-    my ($self, $array_ref) = @_;
-    my @byte_array = @$array_ref;
-    my $commandDeserializer = CommandDeserializer->new(\@byte_array);
+    my ($self, $message_byte_array_ref) = @_;
+    my @message_byte_array = @$message_byte_array_ref;
+    my $commandDeserializer = CommandDeserializer->new(\@message_byte_array);
     my $command = $commandDeserializer->decode();
     my $response = $handler->handle_command($command);
     my $commandSerializer = CommandSerializer->new();
-    my @byte_message = $commandSerializer->encode($response, 0, 0, 0);
-    return @byte_message;
+    my @response_byte_array = $commandSerializer->encode($response, 0, 0, 0);
+    return @response_byte_array;
 }
 
 1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Protocol/CommandDeserializer.pm

@@ -44,17 +44,35 @@ sub readObject {
     elsif($type_num == Type->get_type('JavonetInteger')){
         return readInt();
     }
+    elsif($type_num == Type->get_type('JavonetBool')){
+        return readBool();
+    }
     elsif($type_num == Type->get_type('JavonetFloat')){
         return readFloat();
     }
+    elsif($type_num == Type->get_type('JavonetByte')){
+        return readByte();
+    }
+    elsif($type_num == Type->get_type('JavonetChar')){
+        return readChar();
+    }
+    elsif($type_num == Type->get_type('JavonetLongLong')){
+        return readLongLong();
+    }
     elsif($type_num == Type->get_type('JavonetDouble')){
         return readDouble();
     }
-    elsif($type_num == Type->get_type('JavonetBoolean')){
-        return readBoolean();
+    elsif($type_num == Type->get_type('JavonetUnsignedLongLong')){
+        return readUnsignedLongLong();
+    }
+    elsif($type_num == Type->get_type('JavonetUnsignedInteger')){
+        return readUnsignedInt();
+    }
+    elsif($type_num == Type->get_type('JavonetNull')){
+        return readUndef();
     }
     else{
-        die "Type is not supported: $type_num"
+        die "Type is not supported: $type_num";
     }
 }
 
@@ -86,6 +104,20 @@ sub readCommandRecursively {
     }
 }
 
+sub readString{
+    my $p = $position;
+    my $string_encoding_mode = $buffer[$p + 1];
+    my @int_buffer = @buffer[$p + 2 .. $p + 5];
+    my $size = TypeDeserializer->deserializeInt(\@int_buffer);
+    $position += 6;
+    $p = $position;
+    $position += $size;
+    my @string_buffer = @buffer[$p .. $p + $size - 1];
+    my $decodedString = TypeDeserializer->deserializeString($string_encoding_mode, \@string_buffer);
+
+    return $decodedString
+}
+
 sub readInt{
     $position += 2;
     my $p = $position;
@@ -94,6 +126,14 @@ sub readInt{
     return TypeDeserializer->deserializeInt(\@int_buffer);
 }
 
+sub readBool{
+    $position += 2;
+    my $p = $position;
+    $position += 1;
+    my $bool_buffer = $buffer[$p];
+    return TypeDeserializer->deserializeBool($bool_buffer);
+}
+
 sub readFloat{
     $position += 2;
     my $p = $position;
@@ -102,6 +142,30 @@ sub readFloat{
     return TypeDeserializer->deserializeFloat(\@float_buffer);
 }
 
+sub readByte {
+    $position += 2;
+    my $p = $position;
+    $position += 1;
+    my $byte_buffer = $buffer[$p];
+    return TypeDeserializer->deserializeByte($byte_buffer);
+}
+
+sub readChar {
+    $position += 2;
+    my $p = $position;
+    $position += 1;
+    my $char_buffer = $buffer[$p];
+    return TypeDeserializer->deserializeChar($char_buffer);
+}
+
+sub readLongLong {
+    $position += 2;
+    my $p = $position;
+    $position += 8;
+    my @longlong_buffer = @buffer[$p .. $p + 7];
+    return TypeDeserializer->deserializeLongLong(\@longlong_buffer);
+}
+
 sub readDouble{
     $position += 2;
     my $p = $position;
@@ -110,26 +174,28 @@ sub readDouble{
     return TypeDeserializer->deserializeDouble(\@double_buffer);
 }
 
-sub readString{
+sub readUnsignedLongLong {
+    $position += 2;
     my $p = $position;
-    my $string_encoding_mode = $buffer[$p + 1];
-    my @int_buffer = @buffer[$p + 2 .. $p + 5];
-    my $size = TypeDeserializer->deserializeInt(\@int_buffer);
-    $position += 6;
-    $p = $position;
-    $position += $size;
-    my @string_buffer = @buffer[$p .. $p + $size - 1];
-    my $decodedString = TypeDeserializer->deserializeString($string_encoding_mode, \@string_buffer);
+    $position += 8;
+    my @ulonglong_buffer = @buffer[$p .. $p + 7];
+    return TypeDeserializer->deserializeULongLong(\@ulonglong_buffer);
+}
 
-    return $decodedString
+sub readUnsignedInt {
+    $position += 2;
+    my $p = $position;
+    $position += 4;
+    my @uint_buffer = @buffer[$p .. $p + 3];
+    return TypeDeserializer->deserializeUInt(\@uint_buffer);
 }
 
-sub readBoolean{
+sub readUndef {
     $position += 2;
     my $p = $position;
     $position += 1;
-    my $bool_buffer = $buffer[$p];
-    return TypeDeserializer->deserializeBoolean($bool_buffer);
+    my $undef_buffer = $buffer[$p];
+    return TypeDeserializer->deserializeUndef($undef_buffer);
 }
 
 

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Protocol/CommandSerializer.pm

@@ -51,17 +51,18 @@ sub insert_into_buffer {
 
 sub serialize_primitive {
     my ($payload_item) = @_;
+    if(!defined $payload_item) {
+        return TypeSerializer->serializeUndef();
+    }
+
     if(isint($payload_item)){
-        my @serialized_int = TypeSerializer->serializeInt($payload_item);
-        return @serialized_int;
+        return TypeSerializer->serializeInt($payload_item);
     }
     if(type($payload_item) eq "FLOAT"){
-        my @serialized_double = TypeSerializer->serializeDouble($payload_item);
-        return @serialized_double;
+        return TypeSerializer->serializeDouble($payload_item);
     }
     else{
-        my @serialized_string = TypeSerializer->serializeString($payload_item);
-        return @serialized_string;
+        return TypeSerializer->serializeString($payload_item);
     }
 }
 
@@ -76,14 +77,19 @@ sub serialize_recursively{
     my @cur_payload = @$current_payload_ref;
     my $payload_len = @cur_payload;
     if ($payload_len > 0){
-        if($cur_payload[0]->isa("Javonet::Sdk::Core::PerlCommand")){
-            my $inner_command = $cur_payload[0];
-            insert_into_buffer(TypeSerializer->serializeCommand($inner_command));
-            $queue->insert(0, $inner_command);
+        if (!defined $cur_payload[0]){
+            insert_into_buffer(serialize_primitive(undef));
         }
-        else{
-            my @result = serialize_primitive($cur_payload[0]);
-            insert_into_buffer(@result);
+        else {
+            if ($cur_payload[0]->isa("Javonet::Sdk::Core::PerlCommand")) {
+                my $inner_command = $cur_payload[0];
+                insert_into_buffer(TypeSerializer->serializeCommand($inner_command));
+                $queue->insert(0, $inner_command);
+            }
+            else {
+                my @result = serialize_primitive($cur_payload[0]);
+                insert_into_buffer(@result);
+            }
         }
         return serialize_recursively();
     }

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Protocol/TypeDeserializer.pm

@@ -5,13 +5,6 @@ use Moose;
 use Encode;
 use lib 'lib';
 
-sub deserializeInt {
-    my ($self, $acc_ref) = @_;
-    my @int_array = @$acc_ref;
-    my $decoded_int = unpack "V", pack "C4",  @int_array;
-    return $decoded_int;
-}
-
 sub deserializeString {
     my ($self, $string_encoding_mode, $acc_ref) = @_;
     my @string_array = @$acc_ref;
@@ -20,11 +13,16 @@ sub deserializeString {
     return $decoded_string;
 }
 
-sub deserializeDouble {
+sub deserializeInt {
     my ($self, $acc_ref) = @_;
-    my @double_array = @$acc_ref;
-    my $decoded_double = unpack "d", pack "C8",  @double_array;
-    return $decoded_double;
+    my @int_array = @$acc_ref;
+    my $decoded_int = unpack "i", pack "C4",  @int_array;
+    return $decoded_int;
+}
+
+sub deserializeBool {
+    my ($self, $boolean_value) = @_;
+    return $boolean_value;
 }
 
 sub deserializeFloat {
@@ -34,9 +32,50 @@ sub deserializeFloat {
     return $decoded_float;
 }
 
-sub deserializeBoolean {
-    my ($self, $boolean_value) = @_;
-    return $boolean_value;
+sub deserializeByte {
+    my ($self, $acc_ref) = @_;
+    my @byte_array = $acc_ref;
+    my $decoded_byte = unpack "C", pack "C",  @byte_array;
+    return $decoded_byte;
+}
+
+sub deserializeChar {
+    my ($self, $acc_ref) = @_;
+    my @char_array = $acc_ref;
+    my $decoded_char = unpack "C", pack "C",  @char_array;
+    return $decoded_char;
+}
+
+sub deserializeLongLong {
+    my ($self, $acc_ref) = @_;
+    my @longlong_array = @$acc_ref;
+    my $decoded_longlong = unpack "q", pack "C8",  @longlong_array;
+    return $decoded_longlong;
+}
+
+sub deserializeDouble {
+    my ($self, $acc_ref) = @_;
+    my @double_array = @$acc_ref;
+    my $decoded_double = unpack "d", pack "C8",  @double_array;
+    return $decoded_double;
+}
+
+sub deserializeULongLong {
+    my ($self, $acc_ref) = @_;
+    my @ulonglong_array = @$acc_ref;
+    my $decoded_ulonglong = unpack "Q", pack "C8",  @ulonglong_array;
+    return $decoded_ulonglong;
+}
+
+sub deserializeUInt {
+    my ($self, $acc_ref) = @_;
+    my @uint_array = @$acc_ref;
+    my $decoded_uint = unpack "V", pack "C4",  @uint_array;
+    return $decoded_uint;
+}
+
+sub deserializeUndef {
+    return undef;
 }
 
 no Moose;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Protocol/TypeSerializer.pm

@@ -8,12 +8,14 @@ use lib 'lib';
 use aliased 'Javonet::Sdk::Core::Type' => 'Type', qw(get_type);
 use aliased 'Javonet::Sdk::Core::StringEncodingMode' => 'StringEncodingMode', qw(get_string_encoding_mode);
 
-sub serializeInt {
-    my ($self, $int_value) = @_;
-    my $length = 4;
-    my @initial_array = (Type->get_type('JavonetInteger'), $length);
-    my @bytes =  unpack "C*", pack "V",  $int_value;
-    return (@initial_array, @bytes);
+sub serializeCommand {
+    my $self = $_[0];
+    my $command = $_[1];
+    my $length = @{$command->{payload}};
+    my @length =  unpack "C*", pack "V",  $length;
+    my @initial_array =(Type->get_type('Command'), @length, $command->{runtime},$command->{command_type});
+
+    return @initial_array;
 }
 
 sub serializeString {
@@ -25,31 +27,23 @@ sub serializeString {
     my @length =  unpack "C*", pack "V",  $length;
     my @initial_array =(Type->get_type('JavonetString'),
         StringEncodingMode->get_string_encoding_mode('UTF8'),
-    @length, @serialized_string);
+        @length, @serialized_string);
 
     return @initial_array;
 }
 
-sub serializeDouble {
-    my ($self, $double_value) = @_;
-    my $length = 8;
-    my @initial_array = (Type->get_type('JavonetDouble'), $length);
-    my @bytes =  unpack "C*", pack "d",  $double_value;
-    return (@initial_array, @bytes);
-}
-
-sub serializeFloat {
-    my ($self, $float_value) = @_;
+sub serializeInt {
+    my ($self, $int_value) = @_;
     my $length = 4;
-    my @initial_array = (Type->get_type('JavonetFloat'), $length);
-    my @bytes = unpack "C*", pack "f",  $float_value;
+    my @initial_array = (Type->get_type('JavonetInteger'), $length);
+    my @bytes =  unpack "C*", pack "i",  $int_value;
     return (@initial_array, @bytes);
 }
 
-sub serializeBoolean {
+sub serializeBool {
     my ($self, $bool_value) = @_;
     my $length = 1;
-    my @initial_array = (Type->get_type('JavonetBoolean'), $length);
+    my @initial_array = (Type->get_type('JavonetBool'), $length);
     my @bytes;
     if ($bool_value) {
         @bytes =  ($bool_value);
@@ -61,13 +55,68 @@ sub serializeBoolean {
     return (@initial_array, @bytes);
 }
 
-sub serializeCommand {
-    my $self = $_[0];
-    my $command = $_[1];
-    my $length = @{$command->{payload}};
-    my @length =  unpack "C*", pack "V",  $length;
-    my @initial_array =(Type->get_type('Command'), @length, $command->{runtime},$command->{command_type});
+sub serializeFloat {
+    my ($self, $float_value) = @_;
+    my $length = 4;
+    my @initial_array = (Type->get_type('JavonetFloat'), $length);
+    my @bytes = unpack "C*", pack "f",  $float_value;
+    return (@initial_array, @bytes);
+}
 
-    return @initial_array;
+sub serializeByte {
+    my ($self, $byte_value) = @_;
+    my $length = 1;
+    my @initial_array = (Type->get_type('JavonetByte'), $length);
+    my @bytes =  ($byte_value);
+    return (@initial_array, @bytes);
 }
+
+sub serializeChar {
+    my ($self, $char_value) = @_;
+    my $length = 1;
+    my @initial_array = (Type->get_type('JavonetChar'), $length);
+    my @bytes =  ($char_value);
+    return (@initial_array, @bytes);
+}
+
+sub serializeLongLong {
+    my ($self, $longlong_value) = @_;
+    my $length = 8;
+    my @initial_array = (Type->get_type('JavonetLongLong'), $length);
+    my @bytes =  unpack "C*", pack "q",  $longlong_value;
+    return (@initial_array, @bytes);
+}
+
+sub serializeDouble {
+    my ($self, $double_value) = @_;
+    my $length = 8;
+    my @initial_array = (Type->get_type('JavonetDouble'), $length);
+    my @bytes =  unpack "C*", pack "d",  $double_value;
+    return (@initial_array, @bytes);
+}
+
+sub serializeUllong {
+    my ($self, $ullong_value) = @_;
+    my $length = 8;
+    my @initial_array = (Type->get_type('JavonetUnsignedLongLong'), $length);
+    my @bytes =  unpack "C*", pack "Q",  $ullong_value;
+    return (@initial_array, @bytes);
+}
+
+sub serializeUint {
+    my ($self, $uint_value) = @_;
+    my $length = 4;
+    my @initial_array = (Type->get_type('JavonetUnsignedInteger'), $length);
+    my @bytes =  unpack "C*", pack "V",  $uint_value;
+    return (@initial_array, @bytes);
+}
+
+sub serializeUndef {
+    my $length = 1;
+    my @initial_array = (Type->get_type('JavonetNull'), $length);
+    my @bytes =  (0);
+    return (@initial_array, @bytes);
+}
+
+
 1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Receiver/Receiver.pm

@@ -1,7 +1,6 @@
 package Javonet::Core::Receiver::Receiver;
 use strict;
 use warnings;
-use Exporter;
 use Config;
 use File::Basename;
 
@@ -16,23 +15,19 @@ BEGIN {
 
 use lib "$perlLibDirJavonet";
 use lib "$perlLibDirDeps";
-
 use aliased 'Javonet::Core::Interpreter::Interpreter' => 'Interpreter', qw(process);
 
-our @ISA = qw(Exporter);
-our @EXPORT = qw(send_command heart_beat);
-
 sub heart_beat {
-    my (@byte_array) = @_;
-    my $response = "10";
-    return $response;
+    my ($self, $message_byte_array_ref) = @_;
+    my @response_byte_array = (49, 48);
+    return \@response_byte_array;
 }
 
 sub send_command {
-    my ($byte_array_as_string) = @_;
-    my @byte_array = unpack("C*", Encode::encode("ascii", $byte_array_as_string));
-    my @response = Interpreter->process(\@byte_array);
-    return join '', map chr, @response;
+    my ($self, $message_byte_array_ref) = @_;
+    my @message_byte_array = @$message_byte_array_ref;
+    my @response_byte_array = Javonet::Core::Interpreter::Interpreter->process(\@message_byte_array);
+    return \@response_byte_array;
 }
 
 1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Transmitter/PerlTransmitter.pm

@@ -3,15 +3,11 @@ use strict;
 use warnings;
 use Cwd;
 use aliased 'Javonet::Core::Transmitter::PerlTransmitterWrapper' => 'PerlTransmitterWrapper' , qw(send_command_ activate_);
-use Exporter;
-
-our @ISA = qw(Exporter);
-our @EXPORT = qw(send_command activate_with_license_file activate_with_credentials activate_with_credentials_and_proxy);
 
 sub send_command {
-    my ($self, $message_ref) = @_;
-    my @response = PerlTransmitterWrapper->send_command($message_ref);
-    return @response;
+    my ($self, $message_byte_array_ref) = @_;
+    my $response_byte_array_ref = PerlTransmitterWrapper->send_command($message_byte_array_ref);
+    return $response_byte_array_ref;
 }
 
 sub activate_with_license_file {

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Transmitter/PerlTransmitterWrapper.pm

@@ -4,13 +4,9 @@ use strict;
 use lib 'lib';
 use FFI::Platypus;
 use Path::Tiny;
-use Exporter;
 use File::Spec;
 my $ffi;
 
-our @ISA = qw(Exporter);
-our @EXPORT = qw(send_command_ activate_);
-
 my $send_command_native;
 my $read_response_native;
 my $activate_native;
@@ -51,7 +47,7 @@ sub send_command {
     if ($response_array_len > 0) {
         my @response_array = (1 .. $response_array_len);
         $read_response_native->(\@response_array, $response_array_len);
-        return @response_array;
+        return \@response_array;
     }
     elsif ($response_array_len == 0) {
         my $error_message = "Response is empty";