javonet-ruby-sdk 2.6.10 → 2.6.11

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

@@ -9,13 +9,8 @@ use aliased 'Javonet::Core::Protocol::CommandDeserializer' => 'CommandDeserializ
 use Exporter qw(import);
 our @EXPORT = qw(execute_ process);
 
-my $handler = PerlHandler->new();
-
 sub execute_ {
-    my $self = shift;
-    my $command = shift;
-    my $connection_type = shift;
-    my $tcp_address = shift;
+    my ($class, $command, $connection_type, $tcp_address) = @_;
     my @serialized_command = Javonet::Core::Protocol::CommandSerializer->serialize($command, $connection_type, $tcp_address, 0);
     my $response_byte_array_ref;
     if ($command->{runtime} eq Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl')) {
@@ -26,18 +21,15 @@ sub execute_ {
         $response_byte_array_ref = Javonet::Core::Transmitter::PerlTransmitter->t_send_command(\@serialized_command);
     }
 
-    my $commandDeserializer = CommandDeserializer->new($response_byte_array_ref);
-    return $commandDeserializer->decode();
+    return CommandDeserializer->deserialize($response_byte_array_ref);
 }
 
 sub process {
-    my ($self, $message_byte_array_ref) = @_;
+    my ($class, $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 @response_byte_array = $commandSerializer->serialize($response, 0, 0, 0);
+    my $command = CommandDeserializer->deserialize(\@message_byte_array);
+    my $response = PerlHandler->handle_command($command);
+    my @response_byte_array = CommandSerializer->serialize($response, 0, 0, 0);
     return @response_byte_array;
 }
 

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

@@ -1,204 +1,210 @@
 package Javonet::Core::Protocol::CommandDeserializer;
 use strict;
 use warnings;
-use Moose;
 use lib 'lib';
 use aliased 'Javonet::Sdk::Core::PerlCommand' => 'PerlCommand';
 use aliased 'Javonet::Sdk::Core::Type' => 'Type', qw(get_type);
 use aliased 'Javonet::Core::Protocol::TypeDeserializer' => 'TypeDeserializer';
 
 use Exporter qw(import);
-our @EXPORT = qw(new isAtEnd decode readObject readCommand readCommandRecursively readString readInt readBool readFloat readByte readChar readLongLong readDouble readUnsignedLongLong readUnsignedInt readUndef);
-
-our $position = 0;
-our @buffer = [];
-our $command;
-
-sub new {
-    my ($self, $array_ref) = @_;
-    @buffer = @$array_ref;
-    $command = PerlCommand->new(runtime => $buffer[0],
-        command_type                    => $buffer[10], payload => []);
-    $position = 11;
-    return $self;
-}
-
-sub isAtEnd {
-    my $length = @buffer;
-    return $position == $length;
-}
-
-sub decode {
-    while (!isAtEnd()) {
-        $command = $command->addArgumentToPayload([ readObject($buffer[$position]) ]);
-    }
-    return $command;
-}
-
-sub readObject {
-    my $type_num = $_[0];
-    if ($type_num == Type->get_type('Command')) {
-        return readCommand();
-    }
-    elsif ($type_num == Type->get_type('JavonetString')) {
-        return readString();
-    }
-    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('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";
-    }
-}
-
-sub readCommand {
-    my $p = $position;
-    my @int_buffer = @buffer[$p + 1 .. $p + 4];
-    my $numberOfArgumentInPayload = TypeDeserializer->deserializeInt(\@int_buffer);
-    my $runtime = $buffer[$p + 5];
-    my $commandType = $buffer[$p + 6];
-
-    $position += 7;
-    my $returnCommand = PerlCommand->new(runtime => $runtime, command_type => $commandType);
-    return readCommandRecursively($numberOfArgumentInPayload, $returnCommand);
-}
-
-sub readCommandRecursively {
-    my $numberOfArgumentInPayloadLeft = $_[0];
-    my $cmd = $_[1];
-
-    if ($numberOfArgumentInPayloadLeft == 0) {
-        return $cmd;
-    }
-    else {
+our @EXPORT = qw(deserialize);
+
+# Static deserialize method - takes byte array and returns Command
+sub deserialize {
+    my ($class, $byte_array_ref) = @_;
+    my @buffer = ref $byte_array_ref eq 'ARRAY' ? @$byte_array_ref : @$byte_array_ref;
+    my $position = 11;  # Start position after header
+    my $command = PerlCommand->new(
+        runtime => $buffer[0],
+        command_type => $buffer[10],
+        payload => []
+    );
+    
+    # Helper function to check if at end
+    my $isAtEnd = sub {
+        my $length = @buffer;
+        return $position == $length;
+    };
+    
+    # Define read functions first (they will be referenced by readObject and readCommand)
+    my $readString = sub {
+        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;
+    };
+    
+    my $readInt = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 4;
+        my @int_buffer = @buffer[$p .. $p + 3];
+        return TypeDeserializer->deserializeInt(\@int_buffer);
+    };
+    
+    my $readBool = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 1;
+        my $bool_buffer = $buffer[$p];
+        return TypeDeserializer->deserializeBool($bool_buffer);
+    };
+    
+    my $readFloat = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 4;
+        my @float_buffer = @buffer[$p .. $p + 3];
+        return TypeDeserializer->deserializeFloat(\@float_buffer);
+    };
+    
+    my $readByte = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 1;
+        my $byte_buffer = $buffer[$p];
+        return TypeDeserializer->deserializeByte($byte_buffer);
+    };
+    
+    my $readChar = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 1;
+        my $char_buffer = $buffer[$p];
+        return TypeDeserializer->deserializeChar($char_buffer);
+    };
+    
+    my $readLongLong = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 8;
+        my @longlong_buffer = @buffer[$p .. $p + 7];
+        return TypeDeserializer->deserializeLongLong(\@longlong_buffer);
+    };
+    
+    my $readDouble = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 8;
+        my @double_buffer = @buffer[$p .. $p + 7];
+        return TypeDeserializer->deserializeDouble(\@double_buffer);
+    };
+    
+    my $readUnsignedLongLong = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 8;
+        my @ulonglong_buffer = @buffer[$p .. $p + 7];
+        return TypeDeserializer->deserializeULongLong(\@ulonglong_buffer);
+    };
+    
+    my $readUnsignedInt = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 4;
+        my @uint_buffer = @buffer[$p .. $p + 3];
+        return TypeDeserializer->deserializeUInt(\@uint_buffer);
+    };
+    
+    my $readUndef = sub {
+        $position += 2;
+        my $p = $position;
+        $position += 1;
+        my $undef_buffer = $buffer[$p];
+        return TypeDeserializer->deserializeUndef($undef_buffer);
+    };
+    
+    # Declare readObject first for mutual recursion
+    my $readObject;
+    
+    # Helper function to read command recursively (needs readObject)
+    my $readCommandRecursively;
+    $readCommandRecursively = sub {
+        my ($numberOfArgumentInPayloadLeft, $cmd) = @_;
+        
+        if ($numberOfArgumentInPayloadLeft == 0) {
+            return $cmd;
+        }
+        else {
+            my $p = $position;
+            my @int_buffer = @buffer[$p + 1 .. $p + 4];
+            my $argSize = TypeDeserializer->deserializeInt(\@int_buffer);
+            $cmd = $cmd->AddArgToPayload($readObject->($buffer[$p]));
+            return $readCommandRecursively->($numberOfArgumentInPayloadLeft - 1, $cmd);
+        }
+    };
+    
+    # Helper function to read command (needs readCommandRecursively and readObject)
+    my $readCommand = sub {
         my $p = $position;
         my @int_buffer = @buffer[$p + 1 .. $p + 4];
-        my $argSize = TypeDeserializer->deserializeInt(\@int_buffer);
-        $cmd = $cmd->addArgumentToPayload([ readObject($buffer[$p]) ]);
-        return readCommandRecursively($numberOfArgumentInPayloadLeft - 1, $cmd);
-    }
-}
-
-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;
-    $position += 4;
-    my @int_buffer = @buffer[$p .. $p + 3];
-    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;
-    $position += 4;
-    my @float_buffer = @buffer[$p .. $p + 3];
-    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;
-    $position += 8;
-    my @double_buffer = @buffer[$p .. $p + 7];
-    return TypeDeserializer->deserializeDouble(\@double_buffer);
-}
-
-sub readUnsignedLongLong {
-    $position += 2;
-    my $p = $position;
-    $position += 8;
-    my @ulonglong_buffer = @buffer[$p .. $p + 7];
-    return TypeDeserializer->deserializeULongLong(\@ulonglong_buffer);
-}
-
-sub readUnsignedInt {
-    $position += 2;
-    my $p = $position;
-    $position += 4;
-    my @uint_buffer = @buffer[$p .. $p + 3];
-    return TypeDeserializer->deserializeUInt(\@uint_buffer);
-}
-
-sub readUndef {
-    $position += 2;
-    my $p = $position;
-    $position += 1;
-    my $undef_buffer = $buffer[$p];
-    return TypeDeserializer->deserializeUndef($undef_buffer);
+        my $numberOfArgumentInPayload = TypeDeserializer->deserializeInt(\@int_buffer);
+        my $runtime = $buffer[$p + 5];
+        my $commandType = $buffer[$p + 6];
+        
+        $position += 7;
+        my $returnCommand = PerlCommand->new(runtime => $runtime, command_type => $commandType);
+        return $readCommandRecursively->($numberOfArgumentInPayload, $returnCommand);
+    };
+    
+    # Helper function to read object (references all read functions)
+    $readObject = sub {
+        my ($type_num) = @_;
+        if ($type_num == Type->get_type('Command')) {
+            return $readCommand->();
+        }
+        elsif ($type_num == Type->get_type('JavonetString')) {
+            return $readString->();
+        }
+        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('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";
+        }
+    };
+    
+    
+    # Decode the command
+    while (!$isAtEnd->()) {
+        $command = $command->AddArgToPayload($readObject->($buffer[$position]));
+        # Note: position is managed inside readObject and helper functions
+    }
+    
+    return $command;
 }
 
-no Moose;
 1;

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

@@ -1,7 +1,6 @@
 package Javonet::Core::Protocol::CommandSerializer;
 use strict;
 use warnings FATAL => 'all';
-use Moose;
 
 use lib 'lib';
 use aliased 'Javonet::Sdk::Core::PerlCommand' => 'PerlCommand';
@@ -19,19 +18,19 @@ my @byte_buffer = ();
 my $queue = Thread::Queue->new();
 
 sub serialize {
-    my ($self, $root_command, $connection_type, $tcp_address, $runtimeVersion) = @_;
+    my ($class, $root_command, $connection_type, $tcp_address, $runtimeVersion) = @_;
     @byte_buffer = ();
     $queue = Thread::Queue->new();
     $queue->insert(0, $root_command);
-    insert_into_buffer(($root_command->{runtime}, $runtimeVersion));
-    insert_into_buffer(serialize_tcp_address($connection_type, $tcp_address));
-    insert_into_buffer(Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'), $root_command->{command_type});
-    serialize_recursively();
+    $class->insert_into_buffer(($root_command->{runtime}, $runtimeVersion));
+    $class->insert_into_buffer($class->serialize_tcp_address($connection_type, $tcp_address));
+    $class->insert_into_buffer(Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'), $root_command->{command_type});
+    $class->serialize_recursively();
     return @byte_buffer;
 }
 
 sub serialize_tcp_address {
-    my ($connection_type, $tcp_address) = @_;
+    my ($class, $connection_type, $tcp_address) = @_;
     my @tcp_byte_array;
     if (Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp') eq $connection_type) {
         my @tcp_array = split(':', $tcp_address);
@@ -47,6 +46,7 @@ sub serialize_tcp_address {
 }
 
 sub serialize_recursively {
+    my ($class) = @_;
     my $left = $queue->pending();
     if ($left == 0) {
         return @byte_buffer;
@@ -58,32 +58,31 @@ sub serialize_recursively {
     my $payload_len = @cur_payload;
     if ($payload_len > 0) {
         if (!defined $cur_payload[0]) {
-            insert_into_buffer(TypeSerializer->serializePrimitive(undef));
+            $class->insert_into_buffer(TypeSerializer->serializePrimitive(undef));
         }
         elsif ($cur_payload[0]->isa("Javonet::Sdk::Core::PerlCommand")) {
             my $inner_command = $cur_payload[0];
-            insert_into_buffer(TypeSerializer->serializeCommand($inner_command));
+            $class->insert_into_buffer(TypeSerializer->serializeCommand($inner_command));
             $queue->insert(0, $inner_command);
         }
         elsif (TypesHandler->is_primitive_or_none($cur_payload[0])) {
             my @result = TypeSerializer->serializePrimitive($cur_payload[0]);
-            insert_into_buffer(@result);
+            $class->insert_into_buffer(@result);
         }
         else {
             die "Unsupported payload item type: " . ref($cur_payload[0]) . " for payload item: $cur_payload[0].";
         }
-        return serialize_recursively();
+        return $class->serialize_recursively();
     }
     else {
         $queue->dequeue();
     }
-    return serialize_recursively();
+    return $class->serialize_recursively();
 }
 
 sub insert_into_buffer {
-    my @arguments = @_;
+    my ($class, @arguments) = @_;
     @byte_buffer = (@byte_buffer, @arguments);
 }
 
-no Moose;
 1;

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

@@ -1,7 +1,6 @@
 package Javonet::Core::Protocol::TypeDeserializer;
 use strict;
 use warnings;
-use Moose;
 use Encode;
 use lib 'lib';
 
@@ -21,7 +20,7 @@ our @EXPORT = qw(
 );
 
 sub deserializeString {
-    my ($self, $string_encoding_mode, $acc_ref) = @_;
+    my ($class, $string_encoding_mode, $acc_ref) = @_;
     my @string_array = @$acc_ref;
     my $string_array_joined = join '', map chr, @string_array;
     my $decoded_string = Encode::decode("utf8", $string_array_joined);
@@ -29,69 +28,69 @@ sub deserializeString {
 }
 
 sub deserializeInt {
-    my ($self, $acc_ref) = @_;
+    my ($class, $acc_ref) = @_;
     my @int_array = @$acc_ref;
     my $decoded_int = unpack "i", pack "C4",  @int_array;
     return $decoded_int;
 }
 
 sub deserializeBool {
-    my ($self, $boolean_value) = @_;
+    my ($class, $boolean_value) = @_;
     return $boolean_value;
 }
 
 sub deserializeFloat {
-    my ($self, $acc_ref) = @_;
+    my ($class, $acc_ref) = @_;
     my @float_array = @$acc_ref;
     my $decoded_float = unpack "f", pack "C4",  @float_array;
     return $decoded_float;
 }
 
 sub deserializeByte {
-    my ($self, $acc_ref) = @_;
+    my ($class, $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 ($class, $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 ($class, $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 ($class, $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 ($class, $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 ($class, $acc_ref) = @_;
     my @uint_array = @$acc_ref;
     my $decoded_uint = unpack "V", pack "C4",  @uint_array;
     return $decoded_uint;
 }
 
 sub deserializeUndef {
+    my ($class) = @_;
     return undef;
 }
 
-no Moose;
 1;