javonet-ruby-sdk 2.1.11 → 2.1.13

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/TypeDeserializer.py

@@ -7,70 +7,54 @@ from javonet.utils.StringEncodingMode import StringEncodingMode
 class TypeDeserializer:
 
     @staticmethod
-    def deserialize_int(encoded_int):
-        int_value = struct.unpack("<i", bytearray(encoded_int))[0]
-        return int_value
-
-    @staticmethod
-    def deserialize_unsigned_int(encoded_unsigned_int):
-        unsigned_int_value = struct.unpack("<I", bytearray(encoded_unsigned_int))[0]
-        return unsigned_int_value
-
-    @staticmethod
-    def deserialize_longlong(encoded_longlong):
-        longlong_value = struct.unpack("<q", bytearray(encoded_longlong))[0]
-        return longlong_value
-
-    @staticmethod
-    def deserialize_unsignedlonglong(encoded_unsigned_longlong):
-        unsigned_longlong_value = struct.unpack("<Q", bytearray(encoded_unsigned_longlong[2:]))[0]
-        return unsigned_longlong_value
-
-    @staticmethod
-    def deserialize_double(encoded_double):
-        double_value = struct.unpack("<d", bytearray(encoded_double))[0]
-        return double_value
+    def deserialize_command(encoded_command ):
+        return Command(RuntimeName(encoded_command[0]), CommandType(encoded_command[1]), [])
 
     @staticmethod
     def deserialize_string(string_encoding_mode, encoded_string):
-
         if string_encoding_mode == StringEncodingMode.ASCII:
-            string_value = bytearray(encoded_string).decode('ascii')
-            return string_value
+            return bytearray(encoded_string).decode('ascii')
         if string_encoding_mode == StringEncodingMode.UTF8:
-            string_value = bytearray(encoded_string).decode('utf-8')
-            return string_value
+            return bytearray(encoded_string).decode('utf-8')
         if string_encoding_mode == StringEncodingMode.UTF16:
-            string_value = bytearray(encoded_string).decode('utf-16')
-            return string_value
+            return bytearray(encoded_string).decode('utf-16')
         if string_encoding_mode == StringEncodingMode.UTF32:
-            string_value = bytearray(encoded_string).decode('utf-32')
-            return string_value
+            return bytearray(encoded_string).decode('utf-32')
 
         raise IndexError("String encoding mode out of range")
 
-
     @staticmethod
-    def deserialize_float(encoded_float):
-        float_value = struct.unpack("<f", bytearray(encoded_float))[0]
-        return float_value
-
+    def deserialize_int(encoded_int):
+        return struct.unpack("<i", bytearray(encoded_int))[0]
+    
     @staticmethod
     def deserialize_bool(encoded_bool):
-        bool_value = struct.unpack("?", bytearray(encoded_bool))[0]
-        return bool_value
+        return struct.unpack("<?", bytearray(encoded_bool))[0]
+    
+    @staticmethod
+    def deserialize_float(encoded_float):
+        return struct.unpack("<f", bytearray(encoded_float))[0]
 
+    @staticmethod
+    def deserialize_byte(encoded_byte):
+        return struct.unpack("<B", bytearray(encoded_byte))[0]
+    
     @staticmethod
     def deserialize_char(encoded_char):
-        char_value = struct.unpack("<c", bytearray(encoded_char))[0]
-        return char_value
+        return struct.unpack("<b", bytearray(encoded_char))[0]
+
+    @staticmethod
+    def deserialize_longlong(encoded_longlong):
+        return struct.unpack("<q", bytearray(encoded_longlong))[0]
+
+    @staticmethod
+    def deserialize_double(encoded_double):
+        return struct.unpack("<d", bytearray(encoded_double))[0]
 
     @staticmethod
-    def deserialize_bytes(encoded_bytes):
-        bytes_value = struct.unpack("<c", bytearray(encoded_bytes))[0]
-        return bytes_value
+    def deserialize_ullong(encoded_unsigned_longlong):
+        return struct.unpack("<Q", bytearray(encoded_unsigned_longlong))[0]
 
     @staticmethod
-    def deserialize_command(command_byte_array):
-        command = Command(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
-        return command
+    def deserialize_uint(encoded_unsigned_int):
+        return struct.unpack("<I", bytearray(encoded_unsigned_int))[0]

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/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/Linux/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/Linux/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/Python/MacOs/X64/javonet/core/generator/handler/shared/SharedTypeHandler.py

@@ -16,7 +16,7 @@ class SharedTypeHandler(AbstractGeneratorHandler):
         if analyzed_object == "float":
             return Type.JavonetFloat.value
         if analyzed_object == "bytes":
-            return Type.JavonetBytes.value
+            return Type.JavonetByte.value
         if analyzed_object == "double":
             return Type.JavonetDouble.value
         if analyzed_object == "char":
@@ -36,7 +36,7 @@ class SharedTypeHandler(AbstractGeneratorHandler):
             existing_string_builder.append("bool")
         if used_object is Type.JavonetFloat.value:
             existing_string_builder.append("float")
-        if used_object is Type.JavonetBytes.value:
+        if used_object is Type.JavonetByte.value:
             existing_string_builder.append("bytes")
         if used_object is Type.JavonetChar.value:
             existing_string_builder.append("int")

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/ArraySetItemHandler.py

@@ -11,11 +11,15 @@ class ArraySetItemHandler(AbstractCommandHandler):
                 raise Exception("ArraySetItemHandler parameters mismatch!")
 
             array = command.payload[0]
-            value = command.payload[1]
-            if isinstance(command.payload[2], list):
-                indexes = command.payload[2]
+
+            value = command.payload[2]
+            if isinstance(command.payload[1], list):
+                indexes = command.payload[1]
             else:
-                indexes = command.payload[2:]
+                indexes = [command.payload[1]]
+
+            if isinstance(command.payload[0], dict):
+                array[indexes[0]] = value
 
             # one-dimensional array
             if len(indexes) == 1:

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/CommandHandler/CreateClassInstanceHandler.py

@@ -9,7 +9,6 @@ class CreateClassInstanceHandler(AbstractCommandHandler):
 
     def process(self, command):
         try:
-
             if len(command.payload) < self._required_parameters_count:
                 raise Exception("CreateClassInstanceHandler parameters mismatch!")
             clazz = command.payload[0]

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/interpreter/Interpreter.py

@@ -5,12 +5,11 @@ from javonet.utils.RuntimeName import RuntimeName
 
 
 class Interpreter:
-
     response = None
 
     def execute(self, command, connection_type, tcp_address):
         command_serializer = CommandSerializer()
-        serialized_command = command_serializer.encode(command, connection_type, tcp_address)
+        serialized_command = command_serializer.serialize(command, connection_type, tcp_address)
         if command.runtime_name == RuntimeName.python:
             from javonet.core.receiver.Receiver import Receiver
             response = Receiver().SendCommand(serialized_command, len(serialized_command))
@@ -19,13 +18,13 @@ class Interpreter:
             response = PythonTransmitter.send_command(serialized_command)
         command_deserializer = CommandDeserializer(response, len(response))
 
-        return command_deserializer.decode()
+        return command_deserializer.deserialize()
 
     def process(self, byte_array, byte_array_len):
         command_deserializer = CommandDeserializer(byte_array, byte_array_len)
-        received_command = command_deserializer.decode()
+        received_command = command_deserializer.deserialize()
         python_handler = Handler()
         command_serializer = CommandSerializer()
         response_command = python_handler.handle_command(received_command)
-        encoded_response = command_serializer.encode(response_command, 0, "0.0.0.0:0")
+        encoded_response = command_serializer.serialize(response_command, 0, "0.0.0.0:0")
         return encoded_response

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/protocol/CommandDeserializer.py

@@ -21,41 +21,38 @@ class CommandDeserializer:
     def is_at_end(self):
         return self.position == self.buffer_len
 
-    def decode(self):
+    def deserialize(self):
         while not self.is_at_end():
             self.command = self.command.add_arg_to_payload(self.read_object(self.buffer[self.position]))
         return self.command
 
     # 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]
-    #
-    #
+    #     new_byte_array = bytes_to_copy[size:]
     #     return new_byte_array
 
     def read_object(self, type_num):
         type_value = Type(type_num)
-        if type_value == Type.Command:
-            return self.read_command()
-        elif type_value == Type.JavonetInteger:
-            return self.read_int()
-        elif type_value == Type.JavonetString:
-            return self.read_string()
-        elif type_value == Type.JavonetBoolean:
-            return self.read_bool()
-        elif type_value == Type.JavonetFloat:
-            return self.read_float()
-        elif type_value == Type.JavonetDouble:
-            return self.read_double()
-        else:
-            Exception("Type not supported")
+        switch = {
+            Type.Command: self.read_command,
+            Type.JavonetString: self.read_string,
+            Type.JavonetInteger: self.read_int,
+            Type.JavonetBoolean: self.read_bool,
+            Type.JavonetFloat: self.read_float,
+            Type.JavonetByte: self.read_byte,
+            Type.JavonetChar: self.read_char,
+            Type.JavonetLongLong: self.read_longlong,
+            Type.JavonetDouble: self.read_double,
+            Type.JavonetUnsignedLongLong: self.read_ullong,
+            Type.JavonetUnsignedInteger: self.read_uint,
+        }
+        return switch.get(type_value, lambda: Exception("Type not supported"))()
 
     def read_command(self):
         p = self.position
         number_of_elements_in_payload = TypeDeserializer.deserialize_int(self.buffer[p + 1: p + 5])
         runtime = self.buffer[p + 5]
         command_type = self.buffer[p + 6]
-
         self.position += 7
         return_command = Command(RuntimeName(runtime), CommandType(command_type), [])
         return self.read_command_recursively(number_of_elements_in_payload, return_command)
@@ -68,45 +65,75 @@ class CommandDeserializer:
             cmd = cmd.add_arg_to_payload(self.read_object(self.buffer[p]))
             return self.read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
 
-    def read_int(self):
-        self.position += 2
-        p = self.position
-        self.position += 4
-        return TypeDeserializer.deserialize_int(self.buffer[p:p + 4])
-
     def read_string(self):
         p = self.position
         string_encoding_mode = StringEncodingMode(self.buffer[p+1])
         size = TypeDeserializer.deserialize_int(self.buffer[p + 2:p + 6])
         self.position += 6
         p = self.position
-        decoded_string = TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
         self.position += size
-        return decoded_string
+        return TypeDeserializer.deserialize_string(string_encoding_mode, self.buffer[p:p + size])
 
-    def read_bool(self):
+    def read_int(self):
+        size = 4
+        self.position += 2
         p = self.position
-        size = self.buffer[p + 1]
+        self.position += size
+        return TypeDeserializer.deserialize_int(self.buffer[p:p + size])
+
+    def read_bool(self):
+        size = 1
         self.position += 2
         p = self.position
-        decoded_bool = TypeDeserializer.deserialize_bool(self.buffer[p:p + size])
         self.position += size
-        return decoded_bool
+        return TypeDeserializer.deserialize_bool(self.buffer[p:p+size])
 
     def read_float(self):
+        size = 4
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_float(self.buffer[p:p + size])
+    
+    def read_byte(self):
+        size = 1
+        self.position += 2
         p = self.position
-        size = self.buffer[p + 1]
+        self.position += size
+        return TypeDeserializer.deserialize_byte(self.buffer[p:p+size])
+    
+    def read_char(self):
+        size = 1
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_char(self.buffer[p:p+size])
+
+    def read_longlong(self):
+        size = 8
         self.position += 2
         p = self.position
-        decoded_float = TypeDeserializer.deserialize_float(self.buffer[p:p + size])
         self.position += size
-        return decoded_float
+        return TypeDeserializer.deserialize_longlong(self.buffer[p:p + size])
 
     def read_double(self):
+        size = 8
+        self.position += 2
         p = self.position
-        size = self.buffer[p + 1]
+        self.position += size
+        return TypeDeserializer.deserialize_double(self.buffer[p:p + size])
+
+    def read_ullong(self):
+        size = 8
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_ullong(self.buffer[p:p + size])
+
+    def read_uint(self):
+        size = 4
         self.position += 2
         p = self.position
-        decoded_double = TypeDeserializer.deserialize_double(self.buffer[p:p + size])
         self.position += size
-        return decoded_double
+        return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
+    

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/protocol/CommandSerializer.py

@@ -11,7 +11,7 @@ from javonet.utils.RuntimeName import RuntimeName
 class CommandSerializer:
     byte_buffer = []
 
-    def encode(self, root_command, connection_type, tcp_address=None, runtime_version=0):
+    def serialize(self, root_command, connection_type, tcp_address=None, runtime_version=0):
         queue: Deque[Command] = deque()
         queue.append(root_command)
         self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
@@ -41,19 +41,23 @@ class CommandSerializer:
     @staticmethod
     def serialize_primitive(payload_item):
         if isinstance(payload_item, bool):
-            serialized_bool = TypeSerializer.serialize_bool(payload_item)
-            return serialized_bool
+            return TypeSerializer.serialize_bool(payload_item)
+
         elif isinstance(payload_item, int):
-            serialized_int = TypeSerializer.serialize_int(payload_item)
-            return serialized_int
+            if payload_item in range(-2 ** 31, 2 ** 31):
+                return TypeSerializer.serialize_int(payload_item)
+            elif payload_item in range(-2 ** 63, 2 ** 63):
+                return TypeSerializer.serialize_longlong(payload_item)
+            else:
+                return TypeSerializer.serialize_ullong(payload_item)
+
         elif isinstance(payload_item, float):
-            serialized_float = TypeSerializer.serialize_float(payload_item)
-            return serialized_float
+            return TypeSerializer.serialize_double(payload_item)
+
         elif isinstance(payload_item, str):
-            serialized_string = TypeSerializer.serialize_string(payload_item)
-            return serialized_string
+            return TypeSerializer.serialize_string(payload_item)
         else:
-            return None
+            raise Exception("Python: Type serialization not supported for type: " + payload_item)
 
     def insert_into_buffer(self, arguments):
         self.byte_buffer = self.byte_buffer + arguments

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/protocol/TypeDeserializer.py

@@ -7,70 +7,54 @@ from javonet.utils.StringEncodingMode import StringEncodingMode
 class TypeDeserializer:
 
     @staticmethod
-    def deserialize_int(encoded_int):
-        int_value = struct.unpack("<i", bytearray(encoded_int))[0]
-        return int_value
-
-    @staticmethod
-    def deserialize_unsigned_int(encoded_unsigned_int):
-        unsigned_int_value = struct.unpack("<I", bytearray(encoded_unsigned_int))[0]
-        return unsigned_int_value
-
-    @staticmethod
-    def deserialize_longlong(encoded_longlong):
-        longlong_value = struct.unpack("<q", bytearray(encoded_longlong))[0]
-        return longlong_value
-
-    @staticmethod
-    def deserialize_unsignedlonglong(encoded_unsigned_longlong):
-        unsigned_longlong_value = struct.unpack("<Q", bytearray(encoded_unsigned_longlong[2:]))[0]
-        return unsigned_longlong_value
-
-    @staticmethod
-    def deserialize_double(encoded_double):
-        double_value = struct.unpack("<d", bytearray(encoded_double))[0]
-        return double_value
+    def deserialize_command(encoded_command ):
+        return Command(RuntimeName(encoded_command[0]), CommandType(encoded_command[1]), [])
 
     @staticmethod
     def deserialize_string(string_encoding_mode, encoded_string):
-
         if string_encoding_mode == StringEncodingMode.ASCII:
-            string_value = bytearray(encoded_string).decode('ascii')
-            return string_value
+            return bytearray(encoded_string).decode('ascii')
         if string_encoding_mode == StringEncodingMode.UTF8:
-            string_value = bytearray(encoded_string).decode('utf-8')
-            return string_value
+            return bytearray(encoded_string).decode('utf-8')
         if string_encoding_mode == StringEncodingMode.UTF16:
-            string_value = bytearray(encoded_string).decode('utf-16')
-            return string_value
+            return bytearray(encoded_string).decode('utf-16')
         if string_encoding_mode == StringEncodingMode.UTF32:
-            string_value = bytearray(encoded_string).decode('utf-32')
-            return string_value
+            return bytearray(encoded_string).decode('utf-32')
 
         raise IndexError("String encoding mode out of range")
 
-
     @staticmethod
-    def deserialize_float(encoded_float):
-        float_value = struct.unpack("<f", bytearray(encoded_float))[0]
-        return float_value
-
+    def deserialize_int(encoded_int):
+        return struct.unpack("<i", bytearray(encoded_int))[0]
+    
     @staticmethod
     def deserialize_bool(encoded_bool):
-        bool_value = struct.unpack("?", bytearray(encoded_bool))[0]
-        return bool_value
+        return struct.unpack("<?", bytearray(encoded_bool))[0]
+    
+    @staticmethod
+    def deserialize_float(encoded_float):
+        return struct.unpack("<f", bytearray(encoded_float))[0]
 
+    @staticmethod
+    def deserialize_byte(encoded_byte):
+        return struct.unpack("<B", bytearray(encoded_byte))[0]
+    
     @staticmethod
     def deserialize_char(encoded_char):
-        char_value = struct.unpack("<c", bytearray(encoded_char))[0]
-        return char_value
+        return struct.unpack("<b", bytearray(encoded_char))[0]
+
+    @staticmethod
+    def deserialize_longlong(encoded_longlong):
+        return struct.unpack("<q", bytearray(encoded_longlong))[0]
+
+    @staticmethod
+    def deserialize_double(encoded_double):
+        return struct.unpack("<d", bytearray(encoded_double))[0]
 
     @staticmethod
-    def deserialize_bytes(encoded_bytes):
-        bytes_value = struct.unpack("<c", bytearray(encoded_bytes))[0]
-        return bytes_value
+    def deserialize_ullong(encoded_unsigned_longlong):
+        return struct.unpack("<Q", bytearray(encoded_unsigned_longlong))[0]
 
     @staticmethod
-    def deserialize_command(command_byte_array):
-        command = Command(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
-        return command
+    def deserialize_uint(encoded_unsigned_int):
+        return struct.unpack("<I", bytearray(encoded_unsigned_int))[0]