grm: add support for converting args

Before:

    args = GRM.args_new
    GRM.args_push(args, 'kind', 's', :const_string, 'plot3')
    GRM.args_push(args, 'x', 'nD', :int, n, :voidp, x.pack('d*'))
    GRM.args_push(args, 'y', 'nD', :int, n, :voidp, y.pack('d*'))
    GRM.args_push(args, 'z', 'nD', :int, n, :voidp, z.pack('d*'))
    GRM.plot(args)
    gets
    GRM.args_delete(args)

After:

    GRM.plot(kind: "plot3",
             x: x,
             y: y,
             z: z)
    gets

examples/grm.rb

@@ -11,14 +11,8 @@
 y = n.times.map { |i| Math.cos(x[i]) * x[i] }
 z = n.times.map { |i| Math.sin(x[i]) * x[i] }
 
-args = GRM.args_new
-GRM.args_push(args, 'kind', 's', :const_string, 'plot3')
-GRM.args_push(args, 'x', 'nD', :int, n, :voidp, x.pack('d*'))
-GRM.args_push(args, 'y', 'nD', :int, n, :voidp, y.pack('d*'))
-GRM.args_push(args, 'z', 'nD', :int, n, :voidp, z.pack('d*'))
-
-GRM.plot(args)
-
+GRM.plot(kind: "plot3",
+         x: x,
+         y: y,
+         z: z)
 gets
-
-GRM.args_delete(args)

lib/gr_commons/define_methods.rb

@@ -20,7 +20,11 @@ def define_ffi_methods(ffi_module, prefix: '', default_type: :double)
             when ->(x) { defined?(Numo::NArray) && x.is_a?(Numo::NArray) }
               GRCommonUtils.public_send(default_type, arg)
             else
-              arg
+              if arg.respond_to?(:to_gr)
+                arg.to_gr
+              else
+                arg
+              end
             end
           end
           ffi_module.public_send(method, *args)

lib/grm.rb

@@ -61,6 +61,112 @@ class << self
   # a Fiddley::MemoryPointer in the GRBase class.
   extend GRMBase
 
+  class Args
+    class << self
+      def try_convert(value)
+        case value
+        when Hash
+          new(**value)
+        else
+          nil
+        end
+      end
+    end
+
+    def initialize(**args)
+      @args = GRM.args_new
+      @args.free = FFI["grm_args_delete"]
+      @references = []
+      args.each do |key, value|
+        push(key, value)
+      end
+    end
+
+    def push(key, value)
+      key = key.to_s if key.is_a?(Symbol)
+      case value
+      when String
+        GRM.args_push(@args, key, "s", :const_string, value)
+      when Integer
+        GRM.args_push(@args, key, "i", :int, value)
+      when Float
+        GRM.args_push(@args, key, "d", :double, value)
+      when Args
+        GRM.args_push(@args, key, "a", :voidp, value.address)
+        value.to_gr.free = nil
+      when Array
+        case value[0]
+        when String
+          addresses = value.collect {|v| Fiddle::Pointer[v].to_i}
+          GRM.args_push(@args, key, "nS",
+                        :int, value.size,
+                        :voidp, addresses.pack("J*"))
+        when Integer
+          GRM.args_push(@args, key, "nI",
+                        :int, value.size,
+                        :voidp, value.pack("i*"))
+        when Float
+          GRM.args_push(@args, key, "nD",
+                        :int, value.size,
+                        :voidp, value.pack("d*"))
+        when Args
+          GRM.args_push(@args, key, "nA",
+                        :int, value.size,
+                        :voidp, value.collect(&:address).pack("J*"))
+          value.each do |v|
+            v.to_gr.free = nil
+          end
+        else
+          vs = value.collect {|v| Args.new(v)}
+          @references.concat(vs)
+          GRM.args_push(@args, key, "nA",
+                        :int, value.size,
+                        :voidp, vs.collect(&:address).pack("J*"))
+          vs.each do |v|
+            v.to_gr.free = nil
+          end
+        end
+      else
+        v = Args.new(value)
+        @references << v
+        GRM.args_push(@args, key, "a", :voidp, v.address)
+        value.to_gr.free = nil
+      end
+    end
+
+    def clear
+      GRM.args_clear(@args)
+      @references.clear
+    end
+
+    def address
+      @args.to_i
+    end
+
+    def to_gr
+      @args
+    end
+  end
+
   class << self
+    def merge(args=nil)
+      super(Args.try_convert(args) || args)
+    end
+
+    def merge_extended(args=nil, hold=0, identifiator=nil)
+      super(Args.try_convert(args) || args, hold, identificator)
+    end
+
+    def merge_hold(args=nil)
+      super(Args.try_convert(args) || args)
+    end
+
+    def merge_named(args=nil, identifiator=nil)
+      super(Args.try_convert(args) || args, identificator)
+    end
+
+    def plot(args=nil)
+      super(Args.try_convert(args) || args)
+    end
   end
 end

test/grm_test.rb

@@ -26,4 +26,87 @@ def test_grm_ffi_lib
   def test_version
     assert_kind_of(String, GRM::VERSION)
   end
+
+  class ArgsTest < self
+    def test_empty
+      GRM::Args.new
+    end
+
+    def test_string
+      args = GRM::Args.new(x: "hello")
+      Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE) do |output|
+        GRM.args_values(args, "x", "s", :voidp, output)
+        assert_equal("hello", Fiddle::Pointer.read(output[0, output.size].unpack("J")[0], 5))
+      end
+    end
+
+    def test_integer
+      args = GRM::Args.new(x: 29)
+      Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT, Fiddle::RUBY_FREE) do |output|
+        GRM.args_values(args, "x", "i", :voidp, output)
+        assert_equal([29], output[0, output.size].unpack("i"))
+      end
+    end
+
+    def test_float
+      args = GRM::Args.new(x: 2.9)
+      Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE, Fiddle::RUBY_FREE) do |output|
+        GRM.args_values(args, "x", "d", :voidp, output)
+        assert_equal([2.9], output[0, output.size].unpack("d"))
+      end
+    end
+
+    def test_args
+      sub_args = GRM::Args.new
+      args = GRM::Args.new(x: sub_args)
+      Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE) do |output|
+        GRM.args_values(args, "x", "a", :voidp, output)
+        assert_equal(sub_args.address, output[0, output.size].unpack("J")[0])
+      end
+    end
+
+    def test_array_string
+      args = GRM::Args.new(x: ["hello", "world"])
+      Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE) do |output|
+        GRM.args_values(args, "x", "S", :voidp, output)
+        address = output[0, output.size].unpack("J")[0]
+        value_addresses = Fiddle::Pointer.read(address, Fiddle::SIZEOF_VOIDP * 2).unpack("J*")
+        values = value_addresses.collect do |value_address|
+          Fiddle::Pointer.read(value_address, 5)
+        end
+        assert_equal(["hello", "world"], values)
+      end
+    end
+
+    def test_array_integer
+      args = GRM::Args.new(x: [2, 9])
+      Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE) do |output|
+        GRM.args_values(args, "x", "I", :voidp, output)
+        address = output[0, output.size].unpack("J")[0]
+        assert_equal([2, 9], Fiddle::Pointer.read(address, Fiddle::SIZEOF_INT * 2).unpack("i*"))
+      end
+    end
+
+    def test_array_float
+      args = GRM::Args.new(x: [2.9, -9.2])
+      Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE) do |output|
+        GRM.args_values(args, "x", "D", :voidp, output)
+        address = output[0, output.size].unpack("J")[0]
+        assert_equal([2.9, -9.2],
+                     Fiddle::Pointer.read(address, Fiddle::SIZEOF_DOUBLE * 2).unpack("d*"))
+      end
+    end
+
+    def test_array_args
+      sub_args1 = GRM::Args.new
+      sub_args2 = GRM::Args.new
+      args = GRM::Args.new(x: [sub_args1, sub_args2])
+      Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE) do |output|
+        GRM.args_values(args, "x", "A", :voidp, output)
+        address = output[0, output.size].unpack("J")[0]
+        assert_equal([sub_args1.address, sub_args2.address],
+                     Fiddle::Pointer.read(address, Fiddle::SIZEOF_VOIDP * 2).unpack("J*"))
+      end
+    end
+  end
 end