javonet-ruby-sdk 2.6.11 → 2.6.12

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/protocol/CommandDeserializer.py

@@ -7,213 +7,151 @@ from javonet.core.protocol.TypeDeserializer import TypeDeserializer
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
 from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.StringEncodingMode import StringEncodingMode
 from javonet.utils.Type import Type
-
-
-class _DeserializerState(object):
-    """Internal state holder for deserialization."""
-    def __init__(self, buffer):
-        self.buffer = buffer
-        self.buffer_len = len(buffer)
-        self.position = 0
+from javonet.utils.StringEncodingMode import StringEncodingMode
 
 
 class CommandDeserializer(object):
     """
-    Class responsible for command deserialization.
+    Static class for deserializing commands from byte arrays.
     """
 
     @staticmethod
     def deserialize(buffer):
         """
-        Deserializes a command from a buffer.
-
-        :param buffer: Buffer with data to deserialize
-        :return: Deserialized command
-        """
-        if len(buffer) < 11:
-            raise ValueError("Buffer too small to contain a command header.")
-        
-        state = _DeserializerState(buffer)
-        command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
-        state.position = 11
-        
-        while not CommandDeserializer._is_at_end(state):
-            command = command.add_arg_to_payload(CommandDeserializer._read_object(state))
-        
-        return command
-
-    @staticmethod
-    def _is_at_end(state):
-        """
-        Checks if the end of buffer has been reached.
-
-        :param state: Deserializer state
-        :return: True if end of buffer is reached, False otherwise
-        """
-        return state.position >= state.buffer_len
-
-    @staticmethod
-    def _check_buffer(state, required_size):
-        """Checks if there are enough bytes left in the buffer."""
-        if state.position + required_size > state.buffer_len:
-            raise IndexError("Not enough data in buffer to read next value.")
-
-    @staticmethod
-    def _read_object(state):
-        """
-        Reads an object from the buffer based on its type.
-
-        :param state: Deserializer state
-        :return: Read object
-        """
-        type_num = state.buffer[state.position]
-        type_value = Type(type_num)
-        switch = {
-            Type.Command: CommandDeserializer._read_command,
-            Type.JavonetString: CommandDeserializer._read_string,
-            Type.JavonetInteger: CommandDeserializer._read_int,
-            Type.JavonetBoolean: CommandDeserializer._read_bool,
-            Type.JavonetFloat: CommandDeserializer._read_float,
-            Type.JavonetByte: CommandDeserializer._read_byte,
-            Type.JavonetChar: CommandDeserializer._read_char,
-            Type.JavonetLongLong: CommandDeserializer._read_longlong,
-            Type.JavonetDouble: CommandDeserializer._read_double,
-            Type.JavonetUnsignedLongLong: CommandDeserializer._read_ullong,
-            Type.JavonetUnsignedInteger: CommandDeserializer._read_uint,
-            Type.JavonetNoneType: CommandDeserializer._read_none
-        }
-        func = switch.get(type_value)
-        if func is None:
-            raise ValueError("Type not supported: " + str(type_num))
-        return func(state)
-
-    @staticmethod
-    def _read_command(state):
-        """
-        Reads a command from the buffer.
-
-        :param state: Deserializer state
-        :return: Read command
-        """
-        CommandDeserializer._check_buffer(state, 7)
-        p = state.position
-        number_of_elements_in_payload = TypeDeserializer.deserialize_int(state.buffer[p + 1: p + 5])
-        runtime = state.buffer[p + 5]
-        command_type = state.buffer[p + 6]
-        state.position += 7
+        Deserialize a command from a byte array.
 
-        payload = []
-        for _ in xrange(number_of_elements_in_payload):
-            payload.append(CommandDeserializer._read_object(state))
+        Args:
+            buffer: The byte array containing the serialized command.
 
-        return Command(RuntimeName(runtime), CommandType(command_type), payload)
-
-    @staticmethod
-    def _read_string(state):
-        """
-        Reads a string from the buffer.
-
-        :param state: Deserializer state
-        :return: Read string
+        Returns:
+            Command: The deserialized command.
         """
-        CommandDeserializer._check_buffer(state, 6)
-        p = state.position
-        string_encoding_mode = StringEncodingMode(state.buffer[p + 1])
-        size = TypeDeserializer.deserialize_int(state.buffer[p + 2:p + 6])
-        state.position += 6
-        CommandDeserializer._check_buffer(state, size)
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_string(string_encoding_mode, state.buffer[p:p + size])
-
-    @staticmethod
-    def _read_int(state):
-        size = 4
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_int(state.buffer[p:p + size])
-
-    @staticmethod
-    def _read_bool(state):
-        size = 1
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_bool(state.buffer[p:p + size])
-
-    @staticmethod
-    def _read_float(state):
-        size = 4
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_float(state.buffer[p:p + size])
-
-    @staticmethod
-    def _read_byte(state):
-        size = 1
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_byte(state.buffer[p:p + size])
-
-    @staticmethod
-    def _read_char(state):
-        size = 1
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_char(state.buffer[p:p + size])
-
-    @staticmethod
-    def _read_longlong(state):
-        size = 8
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_longlong(state.buffer[p:p + size])
-
-    @staticmethod
-    def _read_double(state):
-        size = 8
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_double(state.buffer[p:p + size])
-
-    @staticmethod
-    def _read_ullong(state):
-        size = 8
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_ullong(state.buffer[p:p + size])
-
-    @staticmethod
-    def _read_uint(state):
-        size = 4
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_uint(state.buffer[p:p + size])
+        buffer_len = len(buffer)
+        command = Command(RuntimeName(buffer[0]), CommandType(buffer[10]), [])
+        position = 11
+
+        # Use a list to hold position (mutable reference for nested functions)
+        pos_ref = [position]
+
+        def is_at_end():
+            return pos_ref[0] == buffer_len
+
+        def read_object(type_num):
+            type_value = Type(type_num)
+            switch = {
+                Type.Command: read_command,
+                Type.JavonetString: read_string,
+                Type.JavonetInteger: read_int,
+                Type.JavonetBoolean: read_bool,
+                Type.JavonetFloat: read_float,
+                Type.JavonetByte: read_byte,
+                Type.JavonetChar: read_char,
+                Type.JavonetLongLong: read_longlong,
+                Type.JavonetDouble: read_double,
+                Type.JavonetUnsignedLongLong: read_ullong,
+                Type.JavonetUnsignedInteger: read_uint,
+                Type.JavonetNoneType: read_none
+            }
+            func = switch.get(type_value)
+            if func is None:
+                raise Exception("Type not supported")
+            return func()
+
+        def read_command():
+            p = pos_ref[0]
+            number_of_elements_in_payload = TypeDeserializer.deserialize_int(buffer[p + 1: p + 5])
+            runtime = buffer[p + 5]
+            command_type = buffer[p + 6]
+            pos_ref[0] += 7
+
+            payload = [
+                read_object(buffer[pos_ref[0]])
+                for _ in range(number_of_elements_in_payload)
+            ]
+            return Command(RuntimeName(runtime), CommandType(command_type), payload)
+
+        def read_string():
+            p = pos_ref[0]
+            string_encoding_mode = StringEncodingMode(buffer[p + 1])
+            size = TypeDeserializer.deserialize_int(buffer[p + 2:p + 6])
+            pos_ref[0] += 6
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_string(string_encoding_mode, buffer[p:p + size])
+
+        def read_int():
+            size = 4
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_int(buffer[p:p + size])
+
+        def read_bool():
+            size = 1
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_bool(buffer[p:p + size])
+
+        def read_float():
+            size = 4
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_float(buffer[p:p + size])
+
+        def read_byte():
+            size = 1
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_byte(buffer[p:p + size])
+
+        def read_char():
+            size = 1
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_char(buffer[p:p + size])
+
+        def read_longlong():
+            size = 8
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_longlong(buffer[p:p + size])
+
+        def read_double():
+            size = 8
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_double(buffer[p:p + size])
+
+        def read_ullong():
+            size = 8
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_ullong(buffer[p:p + size])
+
+        def read_uint():
+            size = 4
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_uint(buffer[p:p + size])
+
+        def read_none():
+            size = 1
+            pos_ref[0] += 2
+            p = pos_ref[0]
+            pos_ref[0] += size
+            return TypeDeserializer.deserialize_none(buffer[p:p + size])
+
+        # Main deserialization loop
+        while not is_at_end():
+            command = command.add_arg_to_payload(read_object(buffer[pos_ref[0]]))
 
-    @staticmethod
-    def _read_none(state):
-        size = 1
-        CommandDeserializer._check_buffer(state, size + 2)
-        state.position += 2
-        p = state.position
-        state.position += size
-        return TypeDeserializer.deserialize_none(state.buffer[p:p + size])
+        return command

data/lib/javonet-ruby-sdk/Binaries/Python2/javonet/core/protocol/CommandSerializer.py

@@ -3,13 +3,16 @@
 The CommandSerializer module implements command serialization.
 """
 
+import io
+
 from javonet.core.protocol.TypeSerializer import TypeSerializer
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
 from javonet.utils.Command import Command
 from javonet.utils.CommandType import CommandType
 from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.connectionData.IConnectionData import IConnectionData
 from javonet.utils.TypesHandler import TypesHandler
-from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
 
 class CommandSerializer(object):
     """
@@ -24,42 +27,39 @@ class CommandSerializer(object):
         :param root_command: Command to serialize
         :param connection_data: Connection data
         :param runtime_version: Runtime version
-        :return: Serialized command
+        :return: Serialized command as bytearray
         """
-        buffer = []  # Reset buffer for each serialization
-        CommandSerializer._insert_into_buffer(buffer, [root_command.runtime_name.value, runtime_version])
-        CommandSerializer._insert_into_buffer(buffer, connection_data.serialize_connection_data())
-        CommandSerializer._insert_into_buffer(buffer, [RuntimeName.python27.value, root_command.command_type.value])
-        CommandSerializer._serialize_recursively(buffer, root_command)
-        return buffer
+        ms = io.BytesIO()
+
+        ms.write(bytearray([root_command.runtime_name.value, runtime_version]))
+
+        if connection_data is not None:
+            ms.write(bytearray(connection_data.serialize_connection_data()))
+        else:
+            ms.write(bytearray([0, 0, 0, 0, 0, 0, 0]))
+
+        ms.write(bytearray([RuntimeName.python27.value, root_command.command_type.value]))
+
+        CommandSerializer.serialize_recursively(root_command, ms)
+
+        return list(bytearray(ms.getvalue()))
 
     @staticmethod
-    def _serialize_recursively(buffer, command):
+    def serialize_recursively(command, ms):
         """
         Serializes a command recursively.
 
-        :param buffer: Buffer to serialize into
         :param command: Command to serialize
+        :param ms: BytesIO buffer to write to
         """
-        for item in command.payload:
+        for item in command.get_payload():
             if isinstance(item, Command):
-                CommandSerializer._insert_into_buffer(buffer, TypeSerializer.serialize_command(item))
-                CommandSerializer._serialize_recursively(buffer, item)
+                ms.write(bytearray(TypeSerializer.serialize_command(item)))
+                CommandSerializer.serialize_recursively(item, ms)
             elif TypesHandler.is_primitive_or_none(item):
-                CommandSerializer._insert_into_buffer(buffer, TypeSerializer.serialize_primitive(item))
+                ms.write(bytearray(TypeSerializer.serialize_primitive(item)))
             else:
                 cached_reference = ReferencesCache().cache_reference(item)
-                ref_command = Command(RuntimeName.python, CommandType.Reference, cached_reference)
-                CommandSerializer._serialize_recursively(buffer, ref_command)
-
-        return
-
-    @staticmethod
-    def _insert_into_buffer(buffer, arguments):
-        """
-        Inserts arguments into the buffer.
-
-        :param buffer: Buffer to insert into
-        :type arguments: list
-        """
-        buffer.extend(arguments) 
+                ref_command = Command(RuntimeName.python27, CommandType.Reference, cached_reference)
+                ms.write(bytearray(TypeSerializer.serialize_command(ref_command)))
+                CommandSerializer.serialize_recursively(ref_command, ms)

data/lib/javonet-ruby-sdk/Binaries/version.txt

@@ -1 +1 @@
-2.6.11
+2.6.12

data/lib/javonet-ruby-sdk/sdk/invocation_context.rb

@@ -38,22 +38,14 @@ class InvocationContext < AbstractInvocationContext
     end
   end
 
-  def [](i)
-    if not [CommandType::REFERENCE, CommandType::ARRAY_GET_ITEM].include? @current_command.command_type
-      raise "Object is not iterable"
-    else
-      invocation_context_iterator = InvocationContextIterator.new(self)
-      invocation_context_iterator[i]
-    end
+
+  def[](*i)
+    get_index(*i).execute
   end
 
-  def []=(i, value)
-    if not [CommandType::REFERENCE, CommandType::ARRAY_SET_ITEM, CommandType::ARRAY_GET_ITEM].include? @current_command.command_type
-      raise "Object is not iterable"
-    else
-      invocation_context_iterator = InvocationContextIterator.new(self)
-      invocation_context_iterator[i] = value
-    end
+  def []=(*indexes_and_value)
+    value = indexes_and_value.pop
+    set_index(indexes_and_value, value).execute
   end
 
   # Executes the current command.
@@ -269,8 +261,12 @@ class InvocationContext < AbstractInvocationContext
   def retrieve_array
     local_command = Command.new(@runtime_name, CommandType::RETRIEVE_ARRAY, [])
     local_inv_ctx = InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
-    local_inv_ctx.execute
-    local_inv_ctx.response_command.payload
+    array_inv_ctx = local_inv_ctx.execute
+    response_array = []
+    if array_inv_ctx.current_command.payload.length > 0
+      response_array = array_inv_ctx.current_command.payload
+    end
+    response_array
   end
 
   # Retrieves the value of the current command from the target runtime.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: javonet-ruby-sdk
 version: !ruby/object:Gem::Version
-  version: 2.6.11
+  version: 2.6.12
 platform: ruby
 authors:
 - SdNCenter Sp. z o. o.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-06 00:00:00.000000000 Z
+date: 2025-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi