javonet-ruby-sdk 2.1.11 → 2.1.13

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/core/protocol/TypeSerializer.py

@@ -5,22 +5,47 @@ from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class TypeSerializer:
+    
+    @staticmethod
+    def serialize_command(command):
+        length = list(bytearray(struct.pack("<i", len(command.payload))))
+        return [Type.Command.value] + length + [command.runtime_name.value, command.command_type.value]
 
     @staticmethod
-    def serialize_type(type_value):
-        return TypeSerializer.serialize_int(type_value)
+    def serialize_string(string_value):
+        encoded_string_list = list(bytearray(string_value, 'utf-8'))
+        length = list(bytearray(struct.pack("<i", len(encoded_string_list))))
+        return [Type.JavonetString.value] + [StringEncodingMode.UTF8.value] + length + encoded_string_list
 
     @staticmethod
     def serialize_int(int_value):
         encoded_int_list = list(bytearray(struct.pack("<i", int_value)))
         length = len(encoded_int_list)
         return [Type.JavonetInteger.value, length] + encoded_int_list
+    
+    @staticmethod
+    def serialize_bool(bool_value):
+        encoded_bool_list = list(bytearray(struct.pack("?", bool_value)))
+        length = len(encoded_bool_list)
+        return [Type.JavonetBoolean.value, length] + encoded_bool_list
+    
+    @staticmethod
+    def serialize_float(float_value):
+        encoded_float_list = list(bytearray(struct.pack("<f", float_value)))
+        length = len(encoded_float_list)
+        return [Type.JavonetFloat.value, length] + encoded_float_list
 
     @staticmethod
-    def serialize_unsigned_int(unsigned_int_value):
-        encoded_unsigned_int_list = list(bytearray(struct.pack("<I", unsigned_int_value)))
-        length = len(encoded_unsigned_int_list)
-        return [Type.JavonetUnsignedInteger.value, length] + encoded_unsigned_int_list
+    def serialize_byte(bytes_value):
+        encoded_byte_list = list(bytearray(struct.pack("<B", bytes_value)))
+        length = len(encoded_byte_list)
+        return [Type.JavonetByte.value, length] + encoded_byte_list
+    
+    @staticmethod
+    def serialize_char(char_value):
+        encoded_char_list = list(bytearray(struct.pack("<b", char_value)))
+        length = len(encoded_char_list)
+        return [Type.JavonetChar.value, length] + encoded_char_list
 
     @staticmethod
     def serialize_longlong(longlong_value):
@@ -28,12 +53,6 @@ class TypeSerializer:
         length = len(encoded_longlong_list)
         return [Type.JavonetLongLong.value, length] + encoded_longlong_list
 
-    @staticmethod
-    def serialize_unsignedlonglong(unsigned_longlong_value):
-        encoded_unsignedlonglong_list = list(bytearray(struct.pack("<q", unsigned_longlong_value)))
-        length = len(encoded_unsignedlonglong_list)
-        return [Type.JavonetUnsignedLongLong.value, length] + encoded_unsignedlonglong_list
-
     @staticmethod
     def serialize_double(double_value):
         encoded_double_list = list(bytearray(struct.pack("<d", double_value)))
@@ -41,36 +60,13 @@ class TypeSerializer:
         return [Type.JavonetDouble.value, length] + encoded_double_list
 
     @staticmethod
-    def serialize_string(string_value):
-        encoded_string_list = list(bytearray(string_value, 'utf-8'))
-        length = list(bytearray(struct.pack("<i", len(encoded_string_list))))
-        return [Type.JavonetString.value] + [StringEncodingMode.UTF8.value] + length + encoded_string_list
-
-    @staticmethod
-    def serialize_float(float_value):
-        encoded_float_list = list(bytearray(struct.pack("<f", float_value)))
-        length = len(encoded_float_list)
-        return [Type.JavonetFloat.value, length] + encoded_float_list
-
-    @staticmethod
-    def serialize_bool(bool_value):
-        encoded_bool_list = list(bytearray(struct.pack("?", bool_value)))
-        length = len(encoded_bool_list)
-        return [Type.JavonetBoolean.value, length] + encoded_bool_list
-
-    @staticmethod
-    def serialize_char(char_value):
-        encoded_char_list = list(bytearray(struct.pack("<c", char_value)))
-        length = len(encoded_char_list)
-        return [Type.JavonetChar.value, length] + encoded_char_list
-
-    @staticmethod
-    def serialize_bytes(bytes_value):
-        encoded_bytes_list = list(bytearray(struct.pack("<s", bytes_value)))
-        length = len(encoded_bytes_list)
-        return [Type.JavonetBytes.value, length] + encoded_bytes_list
+    def serialize_ullong(unsigned_longlong_value):
+        encoded_unsignedlonglong_list = list(bytearray(struct.pack("<Q", unsigned_longlong_value)))
+        length = len(encoded_unsignedlonglong_list)
+        return [Type.JavonetUnsignedLongLong.value, length] + encoded_unsignedlonglong_list
 
     @staticmethod
-    def serialize_command(command):
-        length = list(bytearray(struct.pack("<i", len(command.payload))))
-        return [Type.Command.value] + length + [command.runtime_name.value, command.command_type.value]
+    def serialize_uint(unsigned_int_value):
+        encoded_unsigned_int_list = list(bytearray(struct.pack("<I", unsigned_int_value)))
+        length = len(encoded_unsigned_int_list)
+        return [Type.JavonetUnsignedInteger.value, length] + encoded_unsigned_int_list

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/utils/CommandType.py

@@ -30,7 +30,9 @@ class CommandType(Enum):
     SetInstanceField = 25
     InvokeGenericStaticMethod = 26
     InvokeGenericMethod = 27
-    CreateGenericClassInstance = 28
-    GetEnumItem = 29
-    GetEnumName = 30
-    GetEnumValue = 31
+    GetEnumItem = 28
+    GetEnumName = 29
+    GetEnumValue = 30
+    AsRef = 31
+    AsOut = 32
+    GetRefValue = 33

data/lib/javonet-ruby-sdk/Binaries/Python/Windows/X64/javonet/utils/Type.py

@@ -7,11 +7,10 @@ class Type(Enum):
     JavonetInteger = 2
     JavonetBoolean = 3
     JavonetFloat = 4
-    JavonetBytes = 5
+    JavonetByte = 5
     JavonetChar = 6
     JavonetLongLong = 7
     JavonetDouble = 8
     JavonetUnsignedLongLong = 9
     JavonetUnsignedInteger = 10
     JavonetNoneType = 11
-

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/handler/command_handler/array_set_item_handler.rb

@@ -25,11 +25,11 @@ class ArraySetItemHandler < AbstractCommandHandler
 
   def set_item_array(command)
     array = command.payload[0]
-    value = command.payload[1]
-    indexes = if command.payload[2].is_a? Array
-                command.payload[2]
+    value = command.payload[2]
+    indexes = if command.payload[1].is_a? Array
+                command.payload[1]
               else
-                command.payload[2..]
+                [command.payload[1]]
               end
     indexes[..-2].each { |i|
       array = array[i]

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/interpreter/interpreter.rb

@@ -6,7 +6,7 @@ class Interpreter
   def execute(command, connection_type, tcp_address)
 
     command_serializer = CommandSerializer.new
-    message_byte_array = command_serializer.encode(command, connection_type, tcp_address)
+    message_byte_array = command_serializer.serialize(command, connection_type, tcp_address)
     if command.runtime_name == RuntimeName::RUBY
       require_relative '../receiver/receiver'
       response_byte_array = Receiver.new.send_command(message_byte_array, message_byte_array.length)
@@ -16,15 +16,15 @@ class Interpreter
     end
 
     command_deserializer = CommandDeserializer.new(response_byte_array,response_byte_array.length)
-    encoded_response = command_deserializer.decode
+    encoded_response = command_deserializer.deserialize
     return encoded_response
   end
 
   def process(byte_array, byte_array_len)
     command_deserializer = CommandDeserializer.new(byte_array,byte_array_len)
-    received_command = command_deserializer.decode
+    received_command = command_deserializer.deserialize
     handler = Handler.new
     command_serializer = CommandSerializer.new
-    return command_serializer.encode(handler.handle_command(received_command), 0, "0.0.0.0:0")
+    return command_serializer.serialize(handler.handle_command(received_command), 0, "0.0.0.0:0")
   end
 end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/protocol/command_deserializer.rb

@@ -5,122 +5,157 @@ require_relative '../../utils/string_encoding_mode'
 
 class CommandDeserializer
 
-
-    def initialize(buffer,byte_array_len)
-        @buffer = buffer
-        @byte_array_len = byte_array_len
-        @command = Command.new(buffer[0], buffer[10], [])
-        @position = 11
-    end
-
-    def is_at_end
-        return @position == @byte_array_len
-    end
-
-    def decode
-        until is_at_end
-            @command = @command.add_arg_to_payload(read_object(@buffer[@position]))
-        end
-        return @command
-    end
-
-    # def copy_from(self, bytes_to_copy, elements_to_skip):
-    #     size = len(bytes_to_copy) - elements_to_skip
-    #     new_byte_array = bytes_to_copy[size]
-    #
-    #
-    #     return new_byte_array
-
-    def read_object(type_num)
-        type_value = type_num
-        if type_value == Type::COMMAND
-            return self.read_command
-        elsif type_value == Type::JAVONET_INTEGER
-            return self.read_int
-        elsif type_value == Type::JAVONET_STRING
-            return self.read_string
-        elsif type_value == Type::JAVONET_BOOLEAN
-            return self.read_bool
-        elsif type_value == Type::JAVONET_FLOAT
-            return self.read_float
-        elsif type_value == Type::JAVONET_DOUBLE
-            return self.read_double
-        else
-            Exception("Type not supported")
-        end
+  def initialize(buffer, byte_array_len)
+    @buffer = buffer
+    @byte_array_len = byte_array_len
+    @command = Command.new(buffer[0], buffer[10], [])
+    @position = 11
+  end
+
+  def is_at_end
+    @position == @byte_array_len
+  end
+
+  def deserialize
+    until is_at_end
+      @command = @command.add_arg_to_payload(read_object(@buffer[@position]))
     end
-
-
-    def read_command
-        p = @position
-        number_of_elements_in_payload = TypeDeserializer.deserialize_int(@buffer[p+1..p+4])
-        runtime = @buffer[p + 5]
-        command_type = @buffer[p + 6]
-
-        @position += 7
-        return_command = Command.new(runtime, command_type, [])
-        return read_command_recursively(number_of_elements_in_payload, return_command)
-    end
-
-    def read_command_recursively(number_of_elements_in_payload_left, cmd)
-        if number_of_elements_in_payload_left == 0
-            return cmd
-        else
-            p = @position
-            new_command = cmd.add_arg_to_payload(self.read_object(@buffer[p]))
-            return read_command_recursively(number_of_elements_in_payload_left - 1, new_command)
-        end
-
+    @command
+  end
+
+  # def copy_from(self, bytes_to_copy, elements_to_skip):
+  #     size = len(bytes_to_copy) - elements_to_skip
+  #     new_byte_array = bytes_to_copy[size]
+  #     return new_byte_array
+
+  def read_object(type_num)
+    case type_num
+    when Type::COMMAND
+      return self.read_command
+    when Type::JAVONET_STRING
+      return self.read_string
+    when Type::JAVONET_INTEGER
+      return self.read_int
+    when Type::JAVONET_BOOLEAN
+      return self.read_bool
+    when Type::JAVONET_FLOAT
+      return self.read_float
+    when Type::JAVONET_BYTE
+      return self.read_byte
+    when Type::JAVONET_CHAR
+      return self.read_char
+    when Type::JAVONET_LONG_LONG
+      return self.read_longlong
+    when Type::JAVONET_DOUBLE
+      return self.read_double
+    when Type::JAVONET_UNSIGNED_LONG_LONG
+      return self.read_ullong
+    when Type::JAVONET_UNSIGNED_INTEGER
+      return self.read_uint
+    else
+      raise Exception.new("Type #{type_num} not supported in command deserializer")
     end
-
-    def read_int
-        @position += 2
-        p = @position
-        @position += 4
-        return TypeDeserializer.deserialize_int(@buffer[p..p + 4 - 1])
-    end
-
-
-    def read_string
-        p = @position
-        string_encoding_mode = @buffer[p+1]
-        size = TypeDeserializer.deserialize_int(@buffer[p+2..p + 5])
-        @position += 6
-        p = @position
-        decoded_string = TypeDeserializer.deserialize_string(string_encoding_mode, @buffer[p..p + size-1])
-        @position += size
-        return decoded_string
-    end
-
-    def read_bool
-        p = @position
-        size = @buffer[p + 1]
-        @position += 2
-        p = @position
-        decoded_bool = TypeDeserializer.deserialize_bool(@buffer[p..p + size])
-        @position += size
-        return decoded_bool
-    end
-
-
-    def read_float
-        p = @position
-        size = @buffer[p + 1]
-        @position += 2
-        p = @position
-        decoded_float = TypeDeserializer.deserialize_float(@buffer[p..p + size - 1])
-        @position += size
-        return decoded_float
-    end
-
-
-    def read_double
-        p = @position
-        size = @buffer[p + 1]
-        @position += 2
-        p = @position
-        decoded_double = TypeDeserializer.deserialize_double(@buffer[p..p + size -1])
-        @position += size
-        return decoded_double
+  end
+
+  def read_command
+    p = @position
+    number_of_elements_in_payload = TypeDeserializer.deserialize_int(@buffer[p + 1..p + 4])
+    runtime = @buffer[p + 5]
+    command_type = @buffer[p + 6]
+    @position += 7
+    return_command = Command.new(runtime, command_type, [])
+    read_command_recursively(number_of_elements_in_payload, return_command)
+  end
+
+  def read_command_recursively(number_of_elements_in_payload_left, cmd)
+    if number_of_elements_in_payload_left == 0
+      cmd
+    else
+      p = @position
+      cmd = cmd.add_arg_to_payload(self.read_object(@buffer[p]))
+      read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
     end
+  end
+
+  def read_string
+    p = @position
+    string_encoding_mode = @buffer[p + 1]
+    size = TypeDeserializer.deserialize_int(@buffer[p + 2..p + 5])
+    @position += 6
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_string(string_encoding_mode, @buffer[p..p + size - 1])
+  end
+
+  def read_int
+    size = 4
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_int(@buffer[p..p + size - 1])
+  end
+
+  def read_bool
+    size = 1
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_bool(@buffer[p..p + size])
+  end
+
+  def read_float
+    size = 4
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_float(@buffer[p..p + size - 1])
+  end
+
+  def read_byte
+    size = 1
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_byte(@buffer[p..p + size])
+  end
+
+  def read_char
+    size = 1
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_char(@buffer[p..p + size])
+  end
+
+  def read_longlong
+    size = 8
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_longlong(@buffer[p..p + size - 1])
+  end
+
+  def read_double
+    size = 8
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_double(@buffer[p..p + size - 1])
+  end
+
+  def read_ullong
+    size = 8
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_ullong(@buffer[p..p + size - 1])
+  end
+
+  def read_uint
+    size = 4
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_uint(@buffer[p..p + size - 1])
+  end
 end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Linux/X64/core/protocol/command_serializer.rb

@@ -8,11 +8,10 @@ class CommandSerializer
     @byte_buffer = []
   end
 
-
-  def encode(root_command, connection_type = ConnectionType::IN_MEMORY, tcp_address = nil, runtimeVersion = 0)
+  def serialize(root_command, connection_type = ConnectionType::IN_MEMORY, tcp_address = nil, runtime_version = 0)
     queue = []
     queue.unshift(root_command)
-    self.insert_into_buffer([root_command.runtime_name, runtimeVersion])
+    self.insert_into_buffer([root_command.runtime_name, runtime_version])
     if connection_type == ConnectionType::TCP
       self.insert_into_buffer([ConnectionType::TCP])
       self.insert_into_buffer(self.serialize_tcp(tcp_address))
@@ -22,50 +21,50 @@ class CommandSerializer
       self.insert_into_buffer([0, 0, 0, 0, 0, 0])
     end
     self.insert_into_buffer([RuntimeName::RUBY, root_command.command_type])
-    return self.serialize_recursively(queue)
+    self.serialize_recursively(queue)
   end
 
   def serialize_tcp(tcp_address)
     if tcp_address.kind_of?(Array)
-      return tcp_address
+      tcp_address
     else
       tcp_address_array = tcp_address.split(':')
       tcp_address_ip = tcp_address_array[0].split('.')
       tcp_address_port = tcp_address_array[1]
       tcp_address_bytearray = []
-      for address in tcp_address_ip
+      tcp_address_ip.each { |address|
         tcp_address_bytearray.concat([address.to_i])
-      end
+      }
       port_byte = [tcp_address_port.to_i].pack("s_").bytes
       tcp_address_bytearray.concat(port_byte)
-      return tcp_address_bytearray
-
+      tcp_address_bytearray
     end
 
   end
 
   def serialize_primitive(payload_item)
-    if payload_item.is_a? Integer
-      serialized_int = TypeSerializer.serialize_int(payload_item)
-      return serialized_int
+    if [true, false].include? payload_item
+      TypeSerializer.serialize_bool(payload_item)
+    elsif payload_item.is_a? Integer
+      if (-2 ** 31..2 ** 31).include?(payload_item)
+        return TypeSerializer.serialize_int(payload_item)
+      elsif (-2 ** 63..2 ** 63).include?(payload_item)
+        return TypeSerializer.serialize_longlong(payload_item)
+      else
+        return TypeSerializer.serialize_ullong(payload_item)
+      end
     elsif payload_item.is_a? String
-      serialized_string = TypeSerializer.serialize_string(payload_item)
-      return serialized_string
+      TypeSerializer.serialize_string(payload_item)
     elsif payload_item.is_a? Float
-      serialized_float = TypeSerializer.serialize_float(payload_item)
-      return serialized_float
-    elsif [true,false].include? payload_item
-      serialized_bool = TypeSerializer.serialize_bool(payload_item)
-      return serialized_bool
+      TypeSerializer.serialize_double(payload_item)
+    elsif payload_item.is_a?
     else
-      return nil
+      raise Exception.new("Payload not supported in command serializer")
     end
   end
 
   def insert_into_buffer(arguments)
-    new_byte_buffer = @byte_buffer + arguments
-    @byte_buffer = new_byte_buffer
-
+    @byte_buffer = @byte_buffer + arguments
   end
 
   def serialize_recursively(queue)
@@ -87,7 +86,7 @@ class CommandSerializer
     else
       queue.shift
     end
-    return self.serialize_recursively(queue)
+    self.serialize_recursively(queue)
   end
 
 end