javonet-ruby-sdk 2.0.1 → 2.1.0

data/lib/javonet-ruby-sdk/core/handler/command_handler/invoke_static_method_handler.rb

@@ -1,26 +1,23 @@
-require_relative '../../../sdk/core/runtime_lib'
-require_relative '../../../sdk/core/ruby_command_type'
-require_relative '../../../sdk/core/ruby_command'
 require_relative 'abstract_command_handler'
 
 class InvokeStaticMethodHandler < AbstractCommandHandler
   def initialize
     @required_parameters_count = 2
   end
-  def process(ruby_command)
-    return invoke_static_method(ruby_command)
+  def process(command)
+    invoke_static_method(command)
   end
 
-  def invoke_static_method(ruby_command)
+  def invoke_static_method(command)
     begin
-    if ruby_command.payload.length < @required_parameters_count
+    if command.payload.length < @required_parameters_count
       raise "Static method parameters mismatch"
     end
-    if ruby_command.payload.length > @required_parameters_count
-      args = ruby_command.payload[2..]
-      ruby_command.payload[0].send(ruby_command.payload[1],*args)
+    if command.payload.length > @required_parameters_count
+      args = command.payload[2..]
+      command.payload[0].send(command.payload[1],*args)
     else
-      ruby_command.payload[0].send(ruby_command.payload[1])
+      command.payload[0].send(command.payload[1])
     end
     rescue Exception => e
       return e

data/lib/javonet-ruby-sdk/core/handler/command_handler/load_library_handler.rb

@@ -1,6 +1,3 @@
-require_relative '../../../sdk/core/ruby_command'
-require_relative '../../../sdk/core/runtime_lib'
-require_relative '../../../sdk/core/ruby_command_type'
 require_relative 'abstract_command_handler'
 
 class LoadLibraryHandler < AbstractCommandHandler
@@ -8,22 +5,22 @@ class LoadLibraryHandler < AbstractCommandHandler
     @required_parameters_count = 1
   end
 
-  def process(ruby_command)
+  def process(command)
     begin
-      if ruby_command.payload.length < @required_parameters_count
+      if command.payload.length < @required_parameters_count
         raise Exception.new "Load library method parameters mismatch"
       end
-      if ruby_command.payload.length > @required_parameters_count
-        assembly_name = ruby_command.payload[1]
+      if command.payload.length > @required_parameters_count
+        assembly_name = command.payload[1]
       else
-        assembly_name = ruby_command.payload[0]
+        assembly_name = command.payload[0]
       end
       #noinspection RubyResolve
       require(assembly_name)
-      return "Load library success"
+      return 0
 
     rescue Exception => e
-      return "Exception during loading library..." + e.to_s
+      return e
     end
   end
 end

data/lib/javonet-ruby-sdk/core/handler/command_handler/resolve_instance_handler.rb

@@ -1,6 +1,3 @@
-require_relative '../../../sdk/core/runtime_lib'
-require_relative '../../../sdk/core/ruby_command_type'
-require_relative '../../../sdk/core/ruby_command'
 require_relative '../references_cache'
 require_relative 'abstract_command_handler'
 
@@ -8,17 +5,17 @@ class ResolveInstanceHandler < AbstractCommandHandler
   def initialize
     @required_parameters_count = 1
   end
-  def process(ruby_command)
-    return resolve_reference(ruby_command)
+  def process(command)
+    return resolve_reference(command)
   end
 
-  def resolve_reference(ruby_command)
-    if ruby_command.payload.length != @required_parameters_count
+  def resolve_reference(command)
+    if command.payload.length != @required_parameters_count
       raise "Resolve Instance parameters mismatch"
     end
     begin
       references_cache = ReferencesCache.instance
-      return references_cache.resolve_reference(ruby_command.payload[0])
+      return references_cache.resolve_reference(command.payload[0])
     rescue Exception => ex
       return ex
     end

data/lib/javonet-ruby-sdk/core/handler/command_handler/set_static_field_handler.rb

@@ -1,6 +1,3 @@
-require_relative '../../../sdk/core/runtime_lib'
-require_relative '../../../sdk/core/ruby_command_type'
-require_relative '../../../sdk/core/ruby_command'
 require_relative 'abstract_command_handler'
 
 class  SetStaticFieldHandler < AbstractCommandHandler
@@ -8,18 +5,18 @@ class  SetStaticFieldHandler < AbstractCommandHandler
     @required_parameters_count = 3
   end
 
-  def process(ruby_command)
-    RubyCommand.new(RuntimeLib::RUBY, RubyCommandType::RESPONSE, [set_static_field(ruby_command)])
+  def process(command)
+    Command.new(RuntimeName::RUBY, CommandType::VALUE, [set_static_field(command)])
   end
 
-  def set_static_field(ruby_command)
+  def set_static_field(command)
     begin
-    if ruby_command.payload.length != @required_parameters_count
+    if command.payload.length != @required_parameters_count
       raise "Set static field parameters mismatch"
     end
 
-    merged_value = '@@' + ruby_command.payload[1]
-    ruby_command.payload[0].class_variable_set(merged_value, ruby_command.payload[2])
+    merged_value = '@@' + command.payload[1]
+    command.payload[0].class_variable_set(merged_value, command.payload[2])
     rescue Exception => e
       return e
     end

data/lib/javonet-ruby-sdk/core/handler/command_handler/value_handler.rb

@@ -0,0 +1,7 @@
+require_relative 'abstract_command_handler'
+
+class ValueHandler < AbstractCommandHandler
+  def process(command)
+    command.payload[0]
+  end
+end

data/lib/javonet-ruby-sdk/core/handler/handler.rb

@@ -0,0 +1,89 @@
+require_relative '../../utils/runtime_name'
+require_relative '../../utils/command_type'
+require_relative '../../core/handler/abstract_handler'
+require_relative '../../core/handler/command_handler/value_handler'
+require_relative '../../core/handler/command_handler/load_library_handler'
+require_relative '../../core/handler/command_handler/invoke_static_method_handler'
+require_relative '../../core/handler/command_handler/get_static_field_handler'
+require_relative '../../core/handler/command_handler/get_instance_field_handler'
+require_relative '../../core/handler/command_handler/create_class_instance_handler'
+require_relative '../../core/handler/command_handler/set_static_field_handler'
+require_relative '../../core/handler/command_handler/get_type_handler'
+require_relative '../../core/handler/command_handler/invoke_instance_method_handler'
+require_relative '../../core/handler/command_handler/resolve_instance_handler'
+require_relative '../../core/handler/command_handler/casting_handler'
+require_relative '../../core/handler/command_handler/destruct_reference_handler'
+require_relative '../../core/handler/command_handler/array_get_item_handler'
+require_relative '../../core/handler/command_handler/array_get_size_handler'
+require_relative '../../core/handler/command_handler/array_get_rank_handler'
+require_relative '../../core/handler/command_handler/array_set_item_handler'
+require_relative '../../core/handler/references_cache'
+require_relative '../../core/handler/handler_dictionary'
+require_relative '../../core/exceptions/exception_serializer'
+
+
+class Handler < AbstractHandler
+
+  def initialize
+    super
+    value_handler = ValueHandler.new
+    load_library_handler = LoadLibraryHandler.new
+    invoke_static_method_handler = InvokeStaticMethodHandler.new
+    get_static_field_handler = GetStaticFieldHandler.new
+    get_class_instance_handler = CreateClassInstanceHandler.new
+    set_static_field_handler = SetStaticFieldHandler.new
+    get_type_handler = GetTypeHandler.new
+    invoke_instance_method_handler = InvokeInstanceMethodHandler.new
+    resolve_instance_handler = ResolveInstanceHandler.new
+    casting_handler = CastingHandler.new
+    get_instance_field_handler = GetInstanceFieldHandler.new
+    destruct_reference_handler = DestructReferenceHandler.new
+    array_get_item_handler = ArrayGetItemHandler.new
+    array_get_size_handler = ArrayGetSizeHandler.new
+    array_get_rank_handler = ArrayGetRankHandler.new
+    array_set_item_handler = ArraySetItemHandler.new
+
+
+    $handler_dict[CommandType::VALUE] = value_handler
+    $handler_dict[CommandType::LOAD_LIBRARY] = load_library_handler
+    $handler_dict[CommandType::INVOKE_STATIC_METHOD] = invoke_static_method_handler
+    $handler_dict[CommandType::GET_STATIC_FIELD] = get_static_field_handler
+    $handler_dict[CommandType::CREATE_CLASS_INSTANCE] = get_class_instance_handler
+    $handler_dict[CommandType::SET_STATIC_FIELD] = set_static_field_handler
+    $handler_dict[CommandType::GET_TYPE] = get_type_handler
+    $handler_dict[CommandType::INVOKE_INSTANCE_METHOD] = invoke_instance_method_handler
+    $handler_dict[CommandType::REFERENCE] = resolve_instance_handler
+    $handler_dict[CommandType::CAST] = casting_handler
+    $handler_dict[CommandType::GET_INSTANCE_FIELD] = get_instance_field_handler
+    $handler_dict[CommandType::DESTRUCT_REFERENCE] = destruct_reference_handler
+    $handler_dict[CommandType::ARRAY_GET_ITEM] = array_get_item_handler
+    $handler_dict[CommandType::ARRAY_GET_SIZE] = array_get_size_handler
+    $handler_dict[CommandType::ARRAY_GET_RANK] = array_get_rank_handler
+    $handler_dict[CommandType::ARRAY_SET_ITEM] = array_set_item_handler
+
+  end
+
+
+  def handle_command(command)
+    response = $handler_dict[command.command_type].handle_command(command)
+      if is_response_simple_type(response)
+        return command.create_response(response)
+      elsif response.is_a? Exception
+        return ExceptionSerializer.serialize_exception(response, command)
+      else
+        reference_cache = ReferencesCache.instance
+        guid = reference_cache.cache_reference(response)
+        return command.create_reference(guid)
+      end
+  end
+
+  def is_response_simple_type(response)
+    return (response.is_a? String or response.is_a? Float or response.is_a? Integer or response.is_a? TrueClass or response.is_a? FalseClass)
+  end
+
+  def is_response_array(response)
+    return response.is_a? Array
+  end
+
+
+end

data/lib/javonet-ruby-sdk/core/interpreter/interpreter.rb

@@ -0,0 +1,30 @@
+require_relative '../protocol/command_serializer'
+require_relative '../protocol/command_deserializer'
+require_relative '../handler/handler'
+
+class Interpreter
+  def execute(command, connection_type, tcp_address)
+
+    command_serializer = CommandSerializer.new
+    message_byte_array = command_serializer.encode(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)
+    else
+      require_relative '../transmitter/transmitter'
+      response_byte_array = Transmitter.send_command(message_byte_array, message_byte_array.length)
+    end
+
+    command_deserializer = CommandDeserializer.new(response_byte_array,response_byte_array.length)
+    encoded_response = command_deserializer.decode
+    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
+    handler = Handler.new
+    command_serializer = CommandSerializer.new
+    return command_serializer.encode(handler.handle_command(received_command), 0, "0.0.0.0:0")
+  end
+end

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

@@ -1,7 +1,7 @@
 require_relative 'type_deserializer'
-require_relative '../../sdk/core/type'
-require_relative '../../sdk/core/ruby_command'
-require_relative '../../sdk/core/string_encoding_mode'
+require_relative '../../utils/type'
+require_relative '../../utils/command'
+require_relative '../../utils/string_encoding_mode'
 
 class CommandDeserializer
 
@@ -9,7 +9,7 @@ class CommandDeserializer
     def initialize(buffer,byte_array_len)
         @buffer = buffer
         @byte_array_len = byte_array_len
-        @command = RubyCommand.new(buffer[0], buffer[10], [])
+        @command = Command.new(buffer[0], buffer[10], [])
         @position = 11
     end
 
@@ -58,7 +58,7 @@ class CommandDeserializer
         command_type = @buffer[p + 6]
 
         @position += 7
-        return_command = RubyCommand.new(runtime, command_type, [])
+        return_command = Command.new(runtime, command_type, [])
         return read_command_recursively(number_of_elements_in_payload, return_command)
     end
 
@@ -67,7 +67,6 @@ class CommandDeserializer
             return cmd
         else
             p = @position
-            arg_size = TypeDeserializer.deserialize_int(@buffer[p+1..p+4])
             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

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

@@ -1,6 +1,6 @@
 require_relative 'type_serializer'
-require_relative '../../sdk/internal/connection_type'
-require_relative '../../sdk/core/runtime_lib'
+require_relative '../../utils/connection_type'
+require_relative '../../utils/runtime_name'
 
 class CommandSerializer
 
@@ -9,10 +9,10 @@ class CommandSerializer
   end
 
 
-  def encode(root_command, connection_type, tcp_address = nil, runtimeVersion = 0)
+  def encode(root_command, connection_type = ConnectionType::IN_MEMORY, tcp_address = nil, runtimeVersion = 0)
     queue = []
     queue.unshift(root_command)
-    self.insert_into_buffer([root_command.runtime_lib, runtimeVersion])
+    self.insert_into_buffer([root_command.runtime_name, runtimeVersion])
     if connection_type == ConnectionType::TCP
       self.insert_into_buffer([ConnectionType::TCP])
       self.insert_into_buffer(self.serialize_tcp(tcp_address))
@@ -21,7 +21,7 @@ class CommandSerializer
       self.insert_into_buffer([ConnectionType::IN_MEMORY])
       self.insert_into_buffer([0, 0, 0, 0, 0, 0])
     end
-    self.insert_into_buffer([RuntimeLib::RUBY, root_command.command_type])
+    self.insert_into_buffer([RuntimeName::RUBY, root_command.command_type])
     return self.serialize_recursively(queue)
   end
 
@@ -58,7 +58,7 @@ class CommandSerializer
       serialized_bool = TypeSerializer.serialize_bool(payload_item)
       return serialized_bool
     else
-      return None
+      return nil
     end
   end
 
@@ -75,7 +75,7 @@ class CommandSerializer
     command = queue.shift
     queue.unshift(command.drop_first_payload_argument)
     if command.payload.length > 0
-      if command.payload[0].is_a? RubyCommand
+      if command.payload[0].is_a? Command
         inner_command = command.payload[0]
         self.insert_into_buffer(TypeSerializer.serialize_command(inner_command))
         queue.unshift(inner_command)

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

@@ -1,4 +1,4 @@
-require_relative '../../sdk/core/string_encoding_mode'
+require_relative '../../utils/string_encoding_mode'
 
 class TypeDeserializer
 
@@ -67,7 +67,7 @@ class TypeDeserializer
   # end
 
   def self.deserialize_command(command_byte_array)
-    python_command = RubyCommand.new(RuntimeLib(command_byte_array[0]), RubyCommandType(command_byte_array[1]), [])
+    python_command = Command.new(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
     return python_command
   end
 

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

@@ -1,5 +1,5 @@
-require_relative '../../sdk/core/type'
-require_relative '../../sdk/core/string_encoding_mode'
+require_relative '../../utils/type'
+require_relative '../../utils/string_encoding_mode'
 
 class TypeSerializer
 
@@ -62,7 +62,7 @@ class TypeSerializer
 
   def self.serialize_command(command)
       length = [command.payload.length()].pack("i").bytes
-      return [Type::COMMAND] + length + [command.runtime_lib, command.command_type]
+      return [Type::COMMAND] + length + [command.runtime_name, command.command_type]
   end
 
 end

data/lib/javonet-ruby-sdk/core/receiver/receiver.rb

@@ -1,16 +1,16 @@
-require_relative '../interpreter/ruby_interpreter'
+require_relative '../interpreter/interpreter'
 
 class Receiver
   
   def initialize
-    @@ruby_interpreter = RubyInterpreter.new
+    @@interpreter = Interpreter.new
   end
 
   def send_command(message_array, message_array_len)
-    return @@ruby_interpreter.process(message_array, message_array_len)
+    @@interpreter.process(message_array, message_array_len)
   end
   
   def heart_beat(message_array, message_array_len)
-    response_array = [49,48]
+    [49,48]
   end
 end

data/lib/javonet-ruby-sdk/core/transmitter/{ruby_transmitter.rb → transmitter.rb}

@@ -1,16 +1,16 @@
 require 'ffi'
 require 'os'
-require_relative 'ruby_transmitter_wrapper'
+require_relative 'transmitter_wrapper'
 
-class RubyTransmitter
+class Transmitter
 
   def self.send_command(messageArray, messageArrayLen)
     message = FFI::MemoryPointer.new(:uchar, messageArrayLen, true)
     message.put_array_of_uchar(0, messageArray)
-    responseArrayLen = RubyTransmitterWrapper.SendCommand(message, messageArrayLen)
+    responseArrayLen = TransmitterWrapper.SendCommand(message, messageArrayLen)
     if responseArrayLen >0
       response = FFI::MemoryPointer.new(:uchar, responseArrayLen, true)
-      RubyTransmitterWrapper.ReadResponse(response, responseArrayLen)
+      TransmitterWrapper.ReadResponse(response, responseArrayLen)
       responseArray = response.get_array_of_uchar(0, responseArrayLen)
       return responseArray
     else
@@ -31,7 +31,7 @@ class RubyTransmitter
   end
 
   private_class_method def self.activate(email="", licenceKey="", proxyHost="", proxyUserName="", proxyUserPassword="")
-    return RubyTransmitterWrapper.Activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
+    return TransmitterWrapper.Activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
   end
 
 end

data/lib/javonet-ruby-sdk/core/transmitter/{ruby_transmitter_wrapper.rb → transmitter_wrapper.rb}

@@ -1,4 +1,4 @@
-module RubyTransmitterWrapper
+module TransmitterWrapper
   extend FFI::Library
     if OS.linux?
       ffi_lib File.expand_path('../../../Binaries/Native/Linux/X64/libJavonetRubyRuntimeNative.so', __FILE__)

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

@@ -1,100 +1,122 @@
 require_relative 'abstract/abstract_invocation_context'
-require_relative '../../core/interpreter/ruby_interpreter'
+require_relative '../../core/interpreter/interpreter'
+require_relative '../../core/exceptions/exception_thrower'
 
 class InvocationContext < AbstractInvocationContext
-  def initialize(runtime_lib, connection_type, tcp_ip_address, command, is_executed = false)
+  def initialize(runtime_name, connection_type, tcp_ip_address, command, is_executed = false)
     @is_executed = is_executed
-    @runtime_lib = runtime_lib
+    @runtime_name = runtime_name
     @connection_type = connection_type
     @tcp_ip_address = tcp_ip_address
     @current_command = command
     @response_command = nil
-    @ruby_interpreter = nil
-    @ruby_handler = nil
-    ObjectSpace.define_finalizer(self, self.finalize(@current_command, @is_executed, @ruby_interpreter, @connection_type, @tcp_ip_address))
+    @interpreter = Interpreter.new
+    @handler = nil
+    ObjectSpace.define_finalizer(self, self.finalize(@current_command, @is_executed, @interpreter, @connection_type, @tcp_ip_address))
   end
 
-  def finalize(command, is_executed, ruby_interpreter, connection_type, tcp_ip_address)
+  def finalize(command, is_executed, interpreter, connection_type, tcp_ip_address)
     proc do
-      if command.command_type == RubyCommandType::REFERENCE && is_executed == true
-        destructCommand = RubyCommand.new(@runtime_lib, RubyCommandType::DESTRUCT_REFERENCE, command.payload)
-        if @runtime_lib == RuntimeLib::RUBY
-          ruby_handler = RubyHandler.new
-          ruby_handler.handle_command(destructCommand)
+      if command.command_type == CommandType::REFERENCE && is_executed == true
+        destructCommand = Command.new(@runtime_name, CommandType::DESTRUCT_REFERENCE, command.payload)
+        if @runtime_name == RuntimeName::RUBY
+          handler = Handler.new
+          handler.handle_command(destructCommand)
         else
-          ruby_interpreter.execute(destructCommand, connection_type, tcp_ip_address)
+          interpreter.execute(destructCommand, connection_type, tcp_ip_address)
         end
       end
     end
   end
 
   def execute
-    if @runtime_lib == RuntimeLib::RUBY
-      @ruby_handler = RubyHandler.new
-      @response_command = @ruby_handler.handle_command(@current_command)
-    else
-      @ruby_interpreter = RubyInterpreter.new
-      @response_command = @ruby_interpreter.execute(@current_command, @connection_type, @tcp_ip_address)
-    end
+    @response_command = @interpreter.execute(@current_command, @connection_type, @tcp_ip_address)
 
-    if @response_command.command_type == RubyCommandType::EXCEPTION
-      raise @response_command.payload[0]
+    if @response_command.command_type == CommandType::EXCEPTION
+      ExceptionThrower.throw_exception(@response_command)
     end
 
-    if @response_command.command_type == RubyCommandType::CREATE_CLASS_INSTANCE
+    if @response_command.command_type == CommandType::CREATE_CLASS_INSTANCE
       @current_command = @response_command
       @is_executed = true
       return self
     end
 
-    return InvocationContext.new(@runtime_lib, @connection_type, @tcp_ip_address, @response_command, true)
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, @response_command, true)
   end
 
-  def get_value
-    return @current_command.payload[0]
+  def invoke_instance_method(*args)
+    local_command = Command.new(@runtime_name, CommandType::INVOKE_INSTANCE_METHOD, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
+  end
+
+  def create_instance(*args)
+    local_command = Command.new(@runtime_name, CommandType::CREATE_CLASS_INSTANCE, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
+  end
+
+  def get_static_field(*args)
+    local_command = Command.new(@runtime_name, CommandType::GET_STATIC_FIELD, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
+  end
+
+  def set_static_field(*args)
+    local_command = Command.new(@runtime_name, CommandType::SET_STATIC_FIELD, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
+  end
+
+  def get_instance_field(*args)
+    local_command = Command.new(@runtime_name, CommandType::GET_INSTANCE_FIELD, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
   end
 
-  def invoke_instance_method(*constructor_args)
-    local_command = RubyCommand.new(@runtime_lib, RubyCommandType::INVOKE_INSTANCE_METHOD, [*constructor_args])
-    return InvocationContext.new(@runtime_lib, @connection_type, @tcp_ip_address, build_command(local_command))
+  def invoke_static_method(*args)
+    local_command = Command.new(@runtime_name, CommandType::INVOKE_STATIC_METHOD, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
   end
 
-  def create_instance(*constructor_args)
-    local_command = RubyCommand.new(@runtime_lib, RubyCommandType::CREATE_CLASS_INSTANCE, [*constructor_args])
-    return InvocationContext.new(@runtime_lib, @connection_type, @tcp_ip_address, build_command(local_command))
+  def get_index(*args)
+    local_command = Command.new(@runtime_name, CommandType::ARRAY_GET_ITEM, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
   end
 
-  def get_static_field(*constructor_args)
-    local_command = RubyCommand.new(@runtime_lib, RubyCommandType::GET_STATIC_FIELD, [*constructor_args])
-    return InvocationContext.new(@runtime_lib, @connection_type, @tcp_ip_address, build_command(local_command))
+  def get_size(*args)
+    local_command = Command.new(@runtime_name, CommandType::ARRAY_GET_SIZE, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
   end
 
-  def set_static_field(*constructor_args)
-    local_command = RubyCommand.new(@runtime_lib, RubyCommandType::SET_STATIC_FIELD, [*constructor_args])
-    return InvocationContext.new(@runtime_lib, @connection_type, @tcp_ip_address, build_command(local_command))
+  def get_rank(*args)
+    local_command = Command.new(@runtime_name, CommandType::ARRAY_GET_RANK, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
   end
 
-  def get_instance_field(*constructor_args)
-    local_command = RubyCommand.new(@runtime_lib, RubyCommandType::GET_INSTANCE_FIELD, [*constructor_args])
-    return InvocationContext.new(@runtime_lib, @connection_type, @tcp_ip_address, build_command(local_command))
+  def set_index(*args)
+    local_command = Command.new(@runtime_name, CommandType::ARRAY_SET_ITEM, [*args])
+    return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command))
   end
 
-  def invoke_static_method(*constructor_args)
-    local_command = RubyCommand.new(@runtime_lib, RubyCommandType::INVOKE_STATIC_METHOD, [*constructor_args])
-    return InvocationContext.new(@runtime_lib, @connection_type, @tcp_ip_address, build_command(local_command))
+  def get_value
+    return @current_command.payload[0]
   end
 
   def build_command(command)
-    (0..command.payload.length).step(1) do |i|
-      if command.payload[i].is_a? InvocationContext
-        command.payload[i] = (command.payload[i]).current_command
-      end
-    end
+    command.payload.each_index { |i|
+      command.payload[i] = iterate(command.payload[i])
+    }
+    return command.add_arg_to_payload_on_beginning(@current_command)
+  end
 
-    if @current_command.nil?
-      return command
+  def iterate(payload_item)
+    if payload_item.is_a? InvocationContext
+      Command.new(@runtime_name, CommandType::VALUE, [*payload_item.current_command])
+    elsif payload_item.is_a? Array
+      payload_item.each_index { |i|
+        payload_item[i] = iterate(payload_item)
+      }
+      return Command.new(@runtime_name, CommandType::ARRAY, [*payload_item])
     else
-      return command.add_arg_to_payload_on_beginning(@current_command)
+
+      return Command.new(@runtime_name, CommandType::VALUE, [*payload_item])
     end
   end