rice 4.5.0 → 4.6.0

data/test/test_From_Ruby.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
@@ -13,6 +13,7 @@ TESTSUITE(FromRuby);
 SETUP(FromRuby)
 {
   embed_ruby();
+  define_fundamental_buffer_types();
 }
 
 TEARDOWN(FromRuby)
@@ -23,7 +24,7 @@ TEARDOWN(FromRuby)
 namespace
 {
   template<typename T>
-  std::string toString(T* buffer, int size)
+  std::string arrayToString(T* buffer, int size)
   {
     std::ostringstream result;
     result << "[";
@@ -44,7 +45,38 @@ namespace
   template<typename T>
   std::string voidToString(void* buffer, int size)
   {
-    return toString<T>((T*)buffer, size/sizeof(T));
+    return arrayToString<T>((T*)buffer, size/sizeof(T));
+  }
+
+  template<typename T>
+  std::string arrayofArraysToString(T** buffer, int outerSize, int innerSize)
+  {
+    std::ostringstream result;
+    result << "[";
+
+    for (int i = 0; i < outerSize; i++)
+    {
+      T* outer = buffer[i];
+
+      result << "[";
+      for (int j = 0; j < innerSize; j++)
+      {
+        T item = outer[j];
+        result << item;
+        if (j < innerSize - 1)
+        {
+          result << ", ";
+        }
+      }
+      result << "]";
+      if (i < outerSize - 1)
+      {
+        result << ", ";
+      }
+    }
+
+    result << "]";
+    return result.str();
   }
 }
 
@@ -103,43 +135,32 @@ TESTCASE(char_pointer)
   detail::From_Ruby<char*> fromRuby;
 
   char* expected = nullptr;
-  char* result = fromRuby.convert(Qnil);
-  ASSERT_EQUAL(expected, result);
-
-  const char* expected2 = "my string";
-  result = fromRuby.convert(rb_str_new2(expected2));
-  ASSERT_EQUAL(*expected2, *result);
-
-  std::string code = R"(arr = [0, 127, 128, 255, 256, -128, -129, -255])";
-  Array array = m.instance_eval(code);
-  result = fromRuby.convert(array.value());
-
-  ASSERT_EQUAL(result[0], 0);
-  ASSERT_EQUAL(result[1], 127);
-  ASSERT_EQUAL(result[2], -128);
-  ASSERT_EQUAL(result[3], -1);
-  ASSERT_EQUAL(result[4], 0);
-  ASSERT_EQUAL(result[5], -128);
-  ASSERT_EQUAL(result[6], 127);
-  ASSERT_EQUAL(result[7], 1);
-
-  std::string format = CHAR_MIN < 0 ? "c*" : "C*";
-  String packed = array.call("pack", format);
-  result = fromRuby.convert(packed.value());
-
-  ASSERT_EQUAL(result[0], 0);
-  ASSERT_EQUAL(result[1], 127);
-  ASSERT_EQUAL(result[2], -128);
-  ASSERT_EQUAL(result[3], -1);
-  ASSERT_EQUAL(result[4], 0);
-  ASSERT_EQUAL(result[5], -128);
-  ASSERT_EQUAL(result[6], 127);
-  ASSERT_EQUAL(result[7], 1);
+  char* data = fromRuby.convert(Qnil);
+  ASSERT_EQUAL(expected, data);
+
+  std::string code = R"(Rice::Buffer≺char≻.new("my string"))";
+  Object result = m.instance_eval(code);
+  data = fromRuby.convert(result.value());
+  //expected = "my string";
+ // ASSERT_EQUAL(*expected, *data);
+
+  code = R"(Rice::Buffer≺char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
+  result = m.instance_eval(code);
+  data = fromRuby.convert(result.value());
+
+  ASSERT_EQUAL(data[0], 0);
+  ASSERT_EQUAL(data[1], 127);
+  ASSERT_EQUAL(data[2], -128);
+  ASSERT_EQUAL(data[3], -1);
+  ASSERT_EQUAL(data[4], 0);
+  ASSERT_EQUAL(data[5], -128);
+  ASSERT_EQUAL(data[6], 127);
+  ASSERT_EQUAL(data[7], 1);
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
     fromRuby.convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("wrong argument type Float (expected char*)", ex.what())
+    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char≻)", ex.what())
   );
 }
 
@@ -149,56 +170,55 @@ TESTCASE(signed_char_pointer)
   detail::From_Ruby<signed char*> fromRuby;
 
   signed char* expected = nullptr;
-  signed char* result = fromRuby.convert(Qnil);
-  ASSERT_EQUAL(expected, result);
+  signed char* data = fromRuby.convert(Qnil);
+  ASSERT_EQUAL(expected, data);
 
+  std::string code = R"(Rice::Buffer≺signed char≻.new("my string"))";
+  Object result = m.instance_eval(code);
+  data = fromRuby.convert(result.value());
   expected = (signed char*)"my string";
-  result = fromRuby.convert(rb_str_new2("my string"));
-  ASSERT_EQUAL(*expected, *result);
-
-  std::string code = R"(arr = [0, 127, 128, 255, 256, -128, -129, -255])";
-  Array array = m.instance_eval(code);
-  result = fromRuby.convert(array.value());
-
-  ASSERT_EQUAL(result[0], 0);
-  ASSERT_EQUAL(result[1], 127);
-  ASSERT_EQUAL(result[2], -128);
-  ASSERT_EQUAL(result[3], -1);
-  ASSERT_EQUAL(result[4], 0);
-  ASSERT_EQUAL(result[5], -128);
-  ASSERT_EQUAL(result[6], 127);
-  ASSERT_EQUAL(result[7], 1);
-
-  std::string format = CHAR_MIN < 0 ? "c*" : "C*";
-  String packed = array.call("pack", format);
-  result = fromRuby.convert(packed.value());
-
-  ASSERT_EQUAL(result[0], 0);
-  ASSERT_EQUAL(result[1], 127);
-  ASSERT_EQUAL(result[2], -128);
-  ASSERT_EQUAL(result[3], -1);
-  ASSERT_EQUAL(result[4], 0);
-  ASSERT_EQUAL(result[5], -128);
-  ASSERT_EQUAL(result[6], 127);
-  ASSERT_EQUAL(result[7], 1);
+  ASSERT_EQUAL(*expected, *data);
+
+  code = R"(Rice::Buffer≺signed char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
+  result = m.instance_eval(code);
+  data = fromRuby.convert(result.value());
+
+  ASSERT_EQUAL(data[0], 0);
+  ASSERT_EQUAL(data[1], 127);
+  ASSERT_EQUAL(data[2], -128);
+  ASSERT_EQUAL(data[3], -1);
+  ASSERT_EQUAL(data[4], 0);
+  ASSERT_EQUAL(data[5], -128);
+  ASSERT_EQUAL(data[6], 127);
+  ASSERT_EQUAL(data[7], 1);
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
     fromRuby.convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("wrong argument type Float (expected signed char*)", ex.what())
+    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺signed char≻)", ex.what())
   );
 }
 
 TESTCASE(char_pointer_const)
 {
-  char const* foo = "foo";
-  ASSERT_EQUAL(foo, detail::From_Ruby<char const*>().convert(rb_str_new2("foo")));
-  ASSERT_EQUAL("", detail::From_Ruby<char const*>().convert(rb_str_new2("")));
+  Module m = define_module("Testing");
+
+  std::string code = R"(Rice::Buffer≺char≻.new("my string"))";
+  Object result = m.instance_eval(code);
+  const char* expected = "my string";
+  const char* data = detail::From_Ruby<const char*>().convert(result.value());
+  ASSERT_EQUAL(expected, data);
+
+  code = R"(Rice::Buffer≺char≻.new(""))";
+  result = m.instance_eval(code);
+  expected = "";
+  data = detail::From_Ruby<const char*>().convert(result.value());
+  ASSERT_EQUAL(expected, data);
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
     detail::From_Ruby<char const*>().convert(rb_float_new(32.3)),
-    ASSERT_EQUAL("wrong argument type Float (expected char*)", ex.what())
+    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char≻)", ex.what())
   );
 }
 
@@ -218,38 +238,41 @@ TESTCASE(unsigned_char_pointer)
   detail::From_Ruby<unsigned char*> fromRuby;
 
   unsigned char* expected = nullptr;
-  unsigned char* result = fromRuby.convert(Qnil);
-  ASSERT_EQUAL(expected, result);
-
-  std::string code = R"(arr = [0, 127, 128, 255, 256, -128, -129, -255])";
-  Array array = m.instance_eval(code);
-  result = fromRuby.convert(array.value());
-
-  ASSERT_EQUAL(result[0], 0x0);
-  ASSERT_EQUAL(result[1], 0x7F);
-  ASSERT_EQUAL(result[2], 0x80);
-  ASSERT_EQUAL(result[3], 0xFF);
-  ASSERT_EQUAL(result[4], 0x00);
-  ASSERT_EQUAL(result[5], 0x80);
-  ASSERT_EQUAL(result[6], 0x7F);
-  ASSERT_EQUAL(result[7], 0x01);
-
-  String packed = array.call("pack", "C*");
-  result = fromRuby.convert(packed.value());
-
-  ASSERT_EQUAL(result[0], 0x0);
-  ASSERT_EQUAL(result[1], 0x7F);
-  ASSERT_EQUAL(result[2], 0x80);
-  ASSERT_EQUAL(result[3], 0xFF);
-  ASSERT_EQUAL(result[4], 0x00);
-  ASSERT_EQUAL(result[5], 0x80);
-  ASSERT_EQUAL(result[6], 0x7F);
-  ASSERT_EQUAL(result[7], 0x01);
+  unsigned char* data = fromRuby.convert(Qnil);
+  ASSERT_EQUAL(expected, data);
+
+  std::string code = R"(Rice::Buffer≺unsigned char≻.new([0, 127, 128, 255, 256, -128, -129, -255]))";
+  Object result = m.instance_eval(code);
+  data = fromRuby.convert(result.value());
+
+  ASSERT_EQUAL(data[0], 0x0);
+  ASSERT_EQUAL(data[1], 0x7F);
+  ASSERT_EQUAL(data[2], 0x80);
+  ASSERT_EQUAL(data[3], 0xFF);
+  ASSERT_EQUAL(data[4], 0x00);
+  ASSERT_EQUAL(data[5], 0x80);
+  ASSERT_EQUAL(data[6], 0x7F);
+  ASSERT_EQUAL(data[7], 0x01);
+
+  code = R"(array = [0, 127, 128, 255, 256, -128, -129, -255]
+              packed = array.pack("C*")
+              Rice::Buffer≺unsigned char≻.new(packed))";
+  result = m.instance_eval(code);
+  data = fromRuby.convert(result.value());
+
+  ASSERT_EQUAL(data[0], 0x0);
+  ASSERT_EQUAL(data[1], 0x7F);
+  ASSERT_EQUAL(data[2], 0x80);
+  ASSERT_EQUAL(data[3], 0xFF);
+  ASSERT_EQUAL(data[4], 0x00);
+  ASSERT_EQUAL(data[5], 0x80);
+  ASSERT_EQUAL(data[6], 0x7F);
+  ASSERT_EQUAL(data[7], 0x01);
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
     detail::From_Ruby<const char*>().convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("wrong argument type Float (expected char*)", ex.what())
+    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char≻)", ex.what())
   );
 }
 
@@ -257,10 +280,11 @@ TESTCASE(unsigned_char_pointer_array)
 {
   Module m = define_module("Testing");
 
-  m.define_singleton_function("unsigned_char_pointer", &toString<unsigned char>);
+  m.define_singleton_function("unsigned_char_pointer", &arrayToString<unsigned char>);
 
   std::string code = R"(arr = ["A", "B"]
-                        unsigned_char_pointer(arr, arr.size))";
+                        buffer = Rice::Buffer≺unsigned char≻.new(arr)
+                        unsigned_char_pointer(buffer, buffer.size))";
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -271,18 +295,21 @@ TESTCASE(unsigned_char_pointer_array)
   code = R"(arr = ["A", "B"].map do |char|
                                char.ord
                              end  
-            unsigned_char_pointer(arr, arr.size))";
+            buffer = Rice::Buffer≺unsigned char≻.new(arr)
+            unsigned_char_pointer(buffer, buffer.size))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[A, B]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [65, 66]
-            unsigned_char_pointer(arr, arr.size))";
+            buffer = Rice::Buffer≺unsigned char≻.new(arr)
+            unsigned_char_pointer(buffer, buffer.size))";
   result = m.module_eval(code);
   ASSERT_EQUAL("[A, B]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [true]
-            unsigned_char_pointer(arr, arr.size))";
+            buffer = Rice::Buffer≺unsigned char≻.new(arr)
+            unsigned_char_pointer(buffer, buffer.size))";
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -315,10 +342,11 @@ TESTCASE(double)
 TESTCASE(double_pointer_array)
 {
   Module m = define_module("Testing");
-  m.define_singleton_function("double_pointer", &toString<double>);
+  m.define_singleton_function("double_pointer", &arrayToString<double>);
 
   std::string code = R"(arr = [1.1, 2.2, 3.3, 4.4]
-                        double_pointer(arr, arr.size))";
+                        buffer = Rice::Buffer≺double≻.new(arr)
+                        double_pointer(buffer, buffer.size))";
 
   Object result = m.module_eval(code);
 
@@ -350,20 +378,23 @@ TESTCASE(float_pointer_array)
 {
   Module m = define_module("Testing");
 
-  m.define_singleton_function("float_pointer", &toString<float>);
+  m.define_singleton_function("float_pointer", &arrayToString<float>);
 
   std::string code = R"(arr = [4.3, 3.2, 2.1, 1.1]
-                        float_pointer(arr, arr.size))";
+                        buffer = Rice::Buffer≺float≻.new(arr)
+                        float_pointer(buffer, buffer.size))";
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[4.3, 3.2, 2.1, 1.1]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [4, 3, 2.8, 1]
-            float_pointer(arr, arr.size))";
+           buffer = Rice::Buffer≺float≻.new(arr)
+            float_pointer(buffer, buffer.size))";
   result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2.8, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [4, "bad", 2, 1]
-            float_pointer(arr, arr.size))";
+            buffer = Rice::Buffer≺float≻.new(arr)
+            float_pointer(buffer, buffer.size))";
 
   ASSERT_EXCEPTION_CHECK(
     Exception,
@@ -372,6 +403,41 @@ TESTCASE(float_pointer_array)
   );
 }
 
+TESTCASE(float_array_array)
+{
+  Module m = define_module("Testing");
+
+  m.define_singleton_function("array_array_to_string", &arrayofArraysToString<float>);
+
+  std::string code = R"(buffer = Rice::Buffer≺float∗≻.new([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]])
+                        array_array_to_string(buffer, buffer.size, 2))";
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL("[[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]]", detail::From_Ruby<std::string>().convert(result.value()));
+
+  code = R"(buffer = Rice::Buffer≺float∗≻.new([[4, 3], [2.8, 1]])
+            array_array_to_string(buffer, buffer.size, 2))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL("[[4, 3], [2.8, 1]]", detail::From_Ruby<std::string>().convert(result.value()));
+
+  code = R"(buffer = Rice::Buffer≺float∗≻.new([[4, "bad"], [2, 1]])
+            array_array_to_string(buffer, buffer.size, 2))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("can't convert String into Float", ex.what())
+  );
+
+  code = R"(array = [[4, "bad"], [2, 1]]
+            array_array_to_string(array, array.size, 2))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT_EQUAL("wrong argument type Array (expected Buffer≺float∗≻)", ex.what())
+  );
+}
+
 TESTCASE(int)
 {
   ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(INT2NUM(0)));
@@ -392,15 +458,17 @@ TESTCASE(int)
 TESTCASE(int_pointer_array)
 {
   Module m = define_module("Testing");
-  m.define_singleton_function("int_pointer", &toString<int>);
+  m.define_singleton_function("int_pointer", &arrayToString<int>);
 
   std::string code = R"(arr = [4, 3, 2, 1]
-                        int_pointer(arr, arr.size))";
+                        buffer = Rice::Buffer≺int≻.new(arr)
+                        int_pointer(buffer, buffer.size))";
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 
   code = R"(arr = [4.2, 3.8, 2.0, 1]
-            int_pointer(arr, arr.size))";
+            buffer = Rice::Buffer≺int≻.new(arr)
+            int_pointer(buffer, buffer.size))";
   result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 }
@@ -539,4 +607,3 @@ TESTCASE(void_pointer_array)
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 }
-

data/test/test_Iterator.cpp

@@ -352,7 +352,7 @@ TESTCASE(IterateNoCopy)
 
   ASSERT_EQUAL(container.data_.size(), a.size());
 
-  for (int i = 0; i < container.data_.size(); i++)
+  for (size_t i = 0; i < container.data_.size(); i++)
   {
     Data& expected = container.data_[i];
     Data_Object<Data> actual(a[i]);

data/test/{test_JumpException.cpp → test_Jump_Exception.cpp}

@@ -1,4 +1,5 @@
 #include "unittest.hpp"
+#include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 
 using namespace Rice;

data/test/test_Keep_Alive.cpp

@@ -1,7 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 using namespace Rice;
 
@@ -112,7 +111,10 @@ namespace
     {
     }
 
-    std::string name();
+    uint32_t index()
+    {
+      return this->index_;
+    }
 
   private:
     Connection& connection_;
@@ -126,20 +128,7 @@ namespace
     {
       return Column(*this, index);
     }
-
-    std::string getName(uint32_t index)
-    {
-      return this->prefix_ + std::to_string(index);
-    }
-
-  private:
-    std::string prefix_ = "column_";
   };
-
-  std::string Column::name()
-  {
-    return this->connection_.getName(this->index_);
-  }
 }
 
 Object getColumn(Module& m, uint32_t index)
@@ -151,7 +140,7 @@ Object getColumn(Module& m, uint32_t index)
 TESTCASE(test_return)
 {
   define_class<Column>("Column")
-    .define_method("name", &Column::name);
+    .define_method("index", &Column::index);
 
   define_class<Connection>("Connection")
     .define_constructor(Constructor<Connection>())
@@ -161,6 +150,6 @@ TESTCASE(test_return)
 
   Object column = getColumn(m, 3);
   rb_gc_start();
-  String name = column.call("name");
-  ASSERT_EQUAL("column_3", name.c_str());
+  Object index = column.call("index");
+  ASSERT_EQUAL(3, detail::From_Ruby<int>().convert(index));
 }

data/test/test_Keep_Alive_No_Wrapper.cpp

@@ -1,7 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 using namespace Rice;
 

data/test/test_Module.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 
 #include <rice/rice.hpp>
@@ -11,6 +11,7 @@ TESTSUITE(Module);
 SETUP(Module)
 {
   embed_ruby();
+  define_fundamental_buffer_types();
 }
 
 TEARDOWN(Module)
@@ -187,7 +188,7 @@ TESTCASE(method_int_passed_no_args)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval("o = Object.new; o.extend(self); o.foo"),
-    ASSERT_EQUAL("wrong number of arguments (given 0, expected 1)", ex.what())
+    ASSERT_EQUAL("Missing argument. Name: arg_0. Index: 0.", ex.what())
   );
 }
 
@@ -272,7 +273,7 @@ TESTCASE(default_arguments_still_throws_argument_error)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval("o = Object.new; o.extend(self); o.foo()"),
-    ASSERT_EQUAL("wrong number of arguments (given 0, expected 1..3)", ex.what())
+    ASSERT_EQUAL("Missing argument. Name: arg1. Index: 0.", ex.what())
   );
 
   ASSERT_EXCEPTION_CHECK(
@@ -284,7 +285,7 @@ TESTCASE(default_arguments_still_throws_argument_error)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval("o = Object.new; o.extend(self); o.foo(3, 4, false, 17)"),
-    ASSERT_EQUAL("wrong number of arguments (given 4, expected 1..3)", ex.what())
+    ASSERT_EQUAL("wrong number of arguments (given 4, expected 3)", ex.what())
   );
 }
 
@@ -464,7 +465,9 @@ TESTCASE(define_method_works_with_pointers)
   Module m(anonymous_module());
   m.define_module_function("bar", &with_pointers);
 
-  m.call("bar", 3, "testing");
+  int anInt = 3;
+  Buffer<int> buffer(&anInt, 1);
+  m.call("bar", std::move(buffer), "testing");
 
   ASSERT_EQUAL(3, with_pointers_x);
   ASSERT_EQUAL("testing", with_pointers_str);
@@ -499,8 +502,12 @@ TESTCASE(pointers)
   define_global_function("with_pointers", &withPointers);
 
   Module m = define_module("TestingModule");
+  std::string code = R"(int_buffer = Rice::Buffer≺int≻.new(32)
+                          bool_buffer = Rice::Buffer≺bool≻.new(true)
+                          double_buffer = Rice::Buffer≺float≻.new(33.0)
+                          float_buffer = Rice::Buffer≺double≻.new(34.0)
+                          with_pointers(int_buffer, bool_buffer, double_buffer, float_buffer))";
 
-  std::string code = "with_pointers(32, true, 33.0, 34.0)";
   m.module_eval(code);
 
   ASSERT_EQUAL(intValue, 32);

data/test/test_Native_Registry.cpp

@@ -2,7 +2,6 @@
 #include "embed_ruby.hpp"
 
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 using namespace Rice;