javonet-ruby-sdk 2.6.10 → 2.6.11

data/lib/javonet-ruby-sdk/core/protocol/command_deserializer.rb

@@ -1,184 +1,184 @@
-require_relative 'type_deserializer'
-require_relative '../../utils/type'
-require_relative '../../utils/command'
-require_relative '../../utils/string_encoding_mode_javonet'
-require_relative '../../utils/command_type'
-require_relative '../../utils/runtime_name_javonet'
-
-class CommandDeserializer
-  def initialize(buffer)
-    @buffer = buffer
-    @buffer_len = buffer.length
-    @command = Command.new(buffer[0], buffer[10], [])
-    @position = 11
-  end
-
-  def is_at_end
-    @position == @buffer_len
-  end
-
-  def deserialize
-    until is_at_end
-      @command = @command.add_arg_to_payload(read_object(@buffer[@position]))
-    end
-    @command
-  end
-
-  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
-    when Type::JAVONET_NULL
-      return self.read_nil
-    else
-      raise Exception.new("Type #{type_num} not supported in command deserializer")
-    end
-  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
-
-    payload = []
-    i = 0
-    while i < number_of_elements_in_payload
-      payload << read_object(@buffer[@position])
-      i += 1
-    end
-    Command.new(runtime, command_type, payload)
-  end
-
-  # old implementation
-  #  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])
-  end
-
-  def read_int
-    size = 4
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_int(@buffer[p...p + size])
-  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])
-  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])
-  end
-
-  def read_double
-    size = 8
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_double(@buffer[p...p + size])
-  end
-
-  def read_ullong
-    size = 8
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_ullong(@buffer[p...p + size])
-  end
-
-  def read_uint
-    size = 4
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_uint(@buffer[p...p + size])
-  end
-
-  def read_nil
-    size = 1
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_nil(@buffer[p...p + size])
-  end
-end
+require_relative 'type_deserializer'
+require_relative '../../utils/type'
+require_relative '../../utils/command'
+require_relative '../../utils/string_encoding_mode_javonet'
+require_relative '../../utils/command_type'
+require_relative '../../utils/runtime_name_javonet'
+
+class CommandDeserializer
+  def initialize(buffer)
+    @buffer = buffer
+    @buffer_len = buffer.length
+    @command = Command.new(buffer[0], buffer[10], [])
+    @position = 11
+  end
+
+  def is_at_end
+    @position == @buffer_len
+  end
+
+  def deserialize
+    until is_at_end
+      @command = @command.add_arg_to_payload(read_object(@buffer[@position]))
+    end
+    @command
+  end
+
+  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
+    when Type::JAVONET_NULL
+      return self.read_nil
+    else
+      raise Exception.new("Type #{type_num} not supported in command deserializer")
+    end
+  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
+
+    payload = []
+    i = 0
+    while i < number_of_elements_in_payload
+      payload << read_object(@buffer[@position])
+      i += 1
+    end
+    Command.new(runtime, command_type, payload)
+  end
+
+  # old implementation
+  #  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])
+  end
+
+  def read_int
+    size = 4
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_int(@buffer[p...p + size])
+  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])
+  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])
+  end
+
+  def read_double
+    size = 8
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_double(@buffer[p...p + size])
+  end
+
+  def read_ullong
+    size = 8
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_ullong(@buffer[p...p + size])
+  end
+
+  def read_uint
+    size = 4
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_uint(@buffer[p...p + size])
+  end
+
+  def read_nil
+    size = 1
+    @position += 2
+    p = @position
+    @position += size
+    TypeDeserializer.deserialize_nil(@buffer[p...p + size])
+  end
+end

data/lib/javonet-ruby-sdk/core/protocol/command_serializer.rb

@@ -1,36 +1,36 @@
-require_relative 'type_serializer'
-require_relative '../../utils/command'
-require_relative '../../utils/runtime_name_javonet'
-require_relative '../../utils/tcp_connection_data'
-
-class CommandSerializer
-  def serialize(root_command, connection_data = nil, runtime_version = 0)
-    buffer = ''.dup
-    buffer << [root_command.runtime_name, runtime_version].pack('C*')
-
-    if connection_data
-      buffer << connection_data.serialize_connection_data.pack('C*')
-    else
-      buffer << [0, 0, 0, 0, 0, 0, 0].pack('C*')
-    end
-    buffer << [RuntimeNameJavonet::RUBY, root_command.command_type].pack('C*')
-
-    # Payload (recursive)
-    serialize_recursively(root_command, buffer)
-
-    buffer.bytes
-  end
-
-  private
-
-  def serialize_recursively(command, buffer)
-    command.payload.each do |item|
-      if item.is_a?(Command)
-        buffer << TypeSerializer.serialize_command(item).pack('C*')
-        serialize_recursively(item, buffer)
-      else
-        buffer << TypeSerializer.serialize_primitive(item).pack('C*')
-      end
-    end
-  end
-end
+require_relative 'type_serializer'
+require_relative '../../utils/command'
+require_relative '../../utils/runtime_name_javonet'
+require_relative '../../utils/tcp_connection_data'
+
+class CommandSerializer
+  def self.serialize(root_command, connection_data = nil, runtime_version = 0)
+    buffer = ''.dup
+    buffer << [root_command.runtime_name, runtime_version].pack('C*')
+
+    if connection_data
+      buffer << connection_data.serialize_connection_data.pack('C*')
+    else
+      buffer << [0, 0, 0, 0, 0, 0, 0].pack('C*')
+    end
+    buffer << [RuntimeNameJavonet::RUBY, root_command.command_type].pack('C*')
+
+    # Payload (recursive)
+    serialize_recursively(root_command, buffer)
+
+    buffer.bytes
+  end
+
+  private
+
+  def self.serialize_recursively(command, buffer)
+    command.payload.each do |item|
+      if item.is_a?(Command)
+        buffer << TypeSerializer.serialize_command(item).pack('C*')
+        serialize_recursively(item, buffer)
+      else
+        buffer << TypeSerializer.serialize_primitive(item).pack('C*')
+      end
+    end
+  end
+end

data/lib/javonet-ruby-sdk/core/protocol/type_deserializer.rb

@@ -1,65 +1,65 @@
-require_relative '../../utils/string_encoding_mode_javonet'
-
-class TypeDeserializer
-  def self.deserialize_command(command_byte_array)
-    Command.new(RuntimeNameJavonet(command_byte_array[0]),
-                CommandType(command_byte_array[1]),
-                [])
-  end
-
-  def self.deserialize_string(string_encoding_mode, encoded_string)
-    raw = encoded_string.pack('C*')
-    case string_encoding_mode
-    when StringEncodingModeJavonet::ASCII
-      raw.force_encoding('US-ASCII').encode('UTF-8')
-    when StringEncodingModeJavonet::UTF8
-      raw.force_encoding('UTF-8').encode('UTF-8')
-    when StringEncodingModeJavonet::UTF16
-      raw.force_encoding('UTF-16LE').encode('UTF-8')
-    when StringEncodingModeJavonet::UTF32
-      raw.force_encoding('UTF-32').encode('UTF-8')
-    else
-      raise 'Argument out of range in deserialize_string'
-    end
-  end
-
-  def self.deserialize_int(encoded_int)
-    encoded_int.pack('C*').unpack1('l<')     # 32-bit signed LE
-  end
-
-  def self.deserialize_bool(encoded_bool)
-    encoded_bool[0] == 1
-  end
-
-  def self.deserialize_float(encoded_float)
-    encoded_float.pack('C*').unpack1('e')    # 32-bit float LE (IEEE-754)
-  end
-
-  def self.deserialize_byte(encoded_byte)
-    encoded_byte.pack('C*').unpack1('C')     # or simply encoded_byte[0]
-  end
-
-  def self.deserialize_char(encoded_char)
-    encoded_char.pack('C*').unpack1('C')     # returns codepoint 0..255
-  end
-
-  def self.deserialize_longlong(encoded_long)
-    encoded_long.pack('C*').unpack1('q<')    # 64-bit signed LE
-  end
-
-  def self.deserialize_double(encoded_double)
-    encoded_double.pack('C*').unpack1('E')   # 64-bit double LE (IEEE-754)
-  end
-
-  def self.deserialize_ullong(encoded_ullong)
-    encoded_ullong.pack('C*').unpack1('Q<')  # 64-bit unsigned LE
-  end
-
-  def self.deserialize_uint(encoded_uint)
-    encoded_uint.pack('C*').unpack1('L<')    # 32-bit unsigned LE
-  end
-
-  def self.deserialize_nil(_encoded_nil)
-    nil
-  end
-end
+require_relative '../../utils/string_encoding_mode_javonet'
+
+class TypeDeserializer
+  def self.deserialize_command(command_byte_array)
+    Command.new(RuntimeNameJavonet(command_byte_array[0]),
+                CommandType(command_byte_array[1]),
+                [])
+  end
+
+  def self.deserialize_string(string_encoding_mode, encoded_string)
+    raw = encoded_string.pack('C*')
+    case string_encoding_mode
+    when StringEncodingModeJavonet::ASCII
+      raw.force_encoding('US-ASCII').encode('UTF-8')
+    when StringEncodingModeJavonet::UTF8
+      raw.force_encoding('UTF-8').encode('UTF-8')
+    when StringEncodingModeJavonet::UTF16
+      raw.force_encoding('UTF-16LE').encode('UTF-8')
+    when StringEncodingModeJavonet::UTF32
+      raw.force_encoding('UTF-32').encode('UTF-8')
+    else
+      raise 'Argument out of range in deserialize_string'
+    end
+  end
+
+  def self.deserialize_int(encoded_int)
+    encoded_int.pack('C*').unpack1('l<')     # 32-bit signed LE
+  end
+
+  def self.deserialize_bool(encoded_bool)
+    encoded_bool[0] == 1
+  end
+
+  def self.deserialize_float(encoded_float)
+    encoded_float.pack('C*').unpack1('e')    # 32-bit float LE (IEEE-754)
+  end
+
+  def self.deserialize_byte(encoded_byte)
+    encoded_byte.pack('C*').unpack1('C')     # or simply encoded_byte[0]
+  end
+
+  def self.deserialize_char(encoded_char)
+    encoded_char.pack('C*').unpack1('C')     # returns codepoint 0..255
+  end
+
+  def self.deserialize_longlong(encoded_long)
+    encoded_long.pack('C*').unpack1('q<')    # 64-bit signed LE
+  end
+
+  def self.deserialize_double(encoded_double)
+    encoded_double.pack('C*').unpack1('E')   # 64-bit double LE (IEEE-754)
+  end
+
+  def self.deserialize_ullong(encoded_ullong)
+    encoded_ullong.pack('C*').unpack1('Q<')  # 64-bit unsigned LE
+  end
+
+  def self.deserialize_uint(encoded_uint)
+    encoded_uint.pack('C*').unpack1('L<')    # 32-bit unsigned LE
+  end
+
+  def self.deserialize_nil(_encoded_nil)
+    nil
+  end
+end