rice 4.5.0 → 4.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (166) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +23 -0
  3. data/CMakeLists.txt +31 -0
  4. data/CMakePresets.json +75 -0
  5. data/COPYING +3 -2
  6. data/FindRuby.cmake +437 -0
  7. data/Rakefile +5 -4
  8. data/include/rice/rice.hpp +5436 -3201
  9. data/include/rice/stl.hpp +2355 -1269
  10. data/lib/make_rice_headers.rb +79 -0
  11. data/lib/mkmf-rice.rb +4 -0
  12. data/lib/rice/version.rb +3 -0
  13. data/lib/rice.rb +1 -0
  14. data/lib/rubygems/builder.rb +11 -0
  15. data/lib/rubygems/cmake_builder.rb +113 -0
  16. data/lib/rubygems_plugin.rb +9 -0
  17. data/rice/Arg.hpp +7 -1
  18. data/rice/Arg.ipp +11 -2
  19. data/rice/Buffer.hpp +123 -0
  20. data/rice/Buffer.ipp +599 -0
  21. data/rice/Constructor.ipp +3 -3
  22. data/rice/Data_Object.hpp +2 -3
  23. data/rice/Data_Object.ipp +188 -188
  24. data/rice/Data_Type.hpp +4 -5
  25. data/rice/Data_Type.ipp +42 -26
  26. data/rice/Enum.hpp +0 -1
  27. data/rice/Enum.ipp +26 -23
  28. data/rice/Init.hpp +8 -0
  29. data/rice/Init.ipp +8 -0
  30. data/rice/MemoryView.ipp +1 -41
  31. data/rice/Return.hpp +1 -1
  32. data/rice/Return.ipp +6 -0
  33. data/rice/cpp_api/Array.hpp +209 -0
  34. data/rice/cpp_api/Array.ipp +304 -0
  35. data/rice/cpp_api/Builtin_Object.hpp +31 -0
  36. data/rice/cpp_api/Builtin_Object.ipp +37 -0
  37. data/rice/cpp_api/Class.hpp +70 -0
  38. data/rice/cpp_api/Class.ipp +97 -0
  39. data/rice/cpp_api/Encoding.hpp +32 -0
  40. data/rice/cpp_api/Encoding.ipp +59 -0
  41. data/rice/cpp_api/Hash.hpp +194 -0
  42. data/rice/cpp_api/Hash.ipp +257 -0
  43. data/rice/cpp_api/Identifier.hpp +46 -0
  44. data/rice/cpp_api/Identifier.ipp +31 -0
  45. data/rice/cpp_api/Module.hpp +72 -0
  46. data/rice/cpp_api/Module.ipp +101 -0
  47. data/rice/cpp_api/Object.hpp +272 -0
  48. data/rice/cpp_api/Object.ipp +235 -0
  49. data/rice/cpp_api/String.hpp +74 -0
  50. data/rice/cpp_api/String.ipp +120 -0
  51. data/rice/cpp_api/Struct.hpp +113 -0
  52. data/rice/cpp_api/Struct.ipp +92 -0
  53. data/rice/cpp_api/Symbol.hpp +46 -0
  54. data/rice/cpp_api/Symbol.ipp +93 -0
  55. data/rice/cpp_api/shared_methods.hpp +134 -0
  56. data/rice/detail/MethodInfo.hpp +1 -9
  57. data/rice/detail/MethodInfo.ipp +5 -72
  58. data/rice/detail/Native.hpp +3 -2
  59. data/rice/detail/Native.ipp +32 -4
  60. data/rice/detail/NativeAttributeGet.hpp +3 -2
  61. data/rice/detail/NativeAttributeGet.ipp +8 -2
  62. data/rice/detail/NativeAttributeSet.hpp +3 -2
  63. data/rice/detail/NativeAttributeSet.ipp +8 -2
  64. data/rice/detail/NativeCallbackFFI.ipp +1 -1
  65. data/rice/detail/NativeFunction.hpp +17 -6
  66. data/rice/detail/NativeFunction.ipp +168 -64
  67. data/rice/detail/NativeIterator.hpp +3 -2
  68. data/rice/detail/NativeIterator.ipp +8 -2
  69. data/rice/detail/RubyType.hpp +2 -5
  70. data/rice/detail/RubyType.ipp +50 -5
  71. data/rice/detail/Type.hpp +3 -1
  72. data/rice/detail/Type.ipp +61 -31
  73. data/rice/detail/Wrapper.hpp +68 -33
  74. data/rice/detail/Wrapper.ipp +103 -113
  75. data/rice/detail/from_ruby.hpp +5 -4
  76. data/rice/detail/from_ruby.ipp +737 -365
  77. data/rice/detail/to_ruby.ipp +1092 -186
  78. data/rice/global_function.ipp +1 -1
  79. data/rice/libc/file.hpp +11 -0
  80. data/rice/libc/file.ipp +32 -0
  81. data/rice/rice.hpp +23 -16
  82. data/rice/stl/complex.hpp +6 -0
  83. data/rice/stl/complex.ipp +93 -0
  84. data/rice/stl/exception.hpp +11 -0
  85. data/rice/stl/exception.ipp +29 -0
  86. data/rice/stl/exception_ptr.hpp +6 -0
  87. data/rice/stl/exception_ptr.ipp +27 -0
  88. data/rice/stl/map.hpp +12 -0
  89. data/rice/stl/map.ipp +469 -0
  90. data/rice/stl/monostate.hpp +6 -0
  91. data/rice/stl/monostate.ipp +80 -0
  92. data/rice/stl/multimap.hpp +14 -0
  93. data/rice/stl/multimap.ipp +448 -0
  94. data/rice/stl/optional.hpp +6 -0
  95. data/rice/stl/optional.ipp +118 -0
  96. data/rice/stl/pair.hpp +13 -0
  97. data/rice/stl/pair.ipp +155 -0
  98. data/rice/stl/reference_wrapper.hpp +6 -0
  99. data/rice/stl/reference_wrapper.ipp +41 -0
  100. data/rice/stl/set.hpp +12 -0
  101. data/rice/stl/set.ipp +495 -0
  102. data/rice/stl/shared_ptr.hpp +28 -0
  103. data/rice/stl/shared_ptr.ipp +224 -0
  104. data/rice/stl/string.hpp +6 -0
  105. data/rice/stl/string.ipp +158 -0
  106. data/rice/stl/string_view.hpp +6 -0
  107. data/rice/stl/string_view.ipp +65 -0
  108. data/rice/stl/tuple.hpp +6 -0
  109. data/rice/stl/tuple.ipp +128 -0
  110. data/rice/stl/type_index.hpp +6 -0
  111. data/rice/stl/type_index.ipp +30 -0
  112. data/rice/stl/type_info.hpp +6 -0
  113. data/rice/stl/type_info.ipp +29 -0
  114. data/rice/stl/unique_ptr.hpp +22 -0
  115. data/rice/stl/unique_ptr.ipp +139 -0
  116. data/rice/stl/unordered_map.hpp +12 -0
  117. data/rice/stl/unordered_map.ipp +469 -0
  118. data/rice/stl/variant.hpp +6 -0
  119. data/rice/stl/variant.ipp +242 -0
  120. data/rice/stl/vector.hpp +12 -0
  121. data/rice/stl/vector.ipp +590 -0
  122. data/rice/stl.hpp +7 -3
  123. data/rice/traits/attribute_traits.hpp +26 -0
  124. data/rice/traits/function_traits.hpp +95 -0
  125. data/rice/traits/method_traits.hpp +47 -0
  126. data/rice/traits/rice_traits.hpp +160 -0
  127. data/rice.gemspec +85 -0
  128. data/test/embed_ruby.cpp +3 -0
  129. data/test/ruby/test_multiple_extensions_same_class.rb +14 -14
  130. data/test/test_Array.cpp +6 -3
  131. data/test/test_Attribute.cpp +34 -1
  132. data/test/test_Buffer.cpp +285 -0
  133. data/test/test_Callback.cpp +2 -3
  134. data/test/test_Data_Object.cpp +88 -34
  135. data/test/test_Data_Type.cpp +106 -65
  136. data/test/test_Director.cpp +7 -3
  137. data/test/test_Enum.cpp +5 -2
  138. data/test/test_File.cpp +1 -1
  139. data/test/test_From_Ruby.cpp +181 -114
  140. data/test/test_Iterator.cpp +1 -1
  141. data/test/{test_JumpException.cpp → test_Jump_Exception.cpp} +1 -0
  142. data/test/test_Keep_Alive.cpp +7 -18
  143. data/test/test_Keep_Alive_No_Wrapper.cpp +0 -1
  144. data/test/test_Module.cpp +13 -6
  145. data/test/test_Native_Registry.cpp +0 -1
  146. data/test/test_Overloads.cpp +180 -5
  147. data/test/test_Ownership.cpp +100 -57
  148. data/test/test_Proc.cpp +0 -1
  149. data/test/test_Self.cpp +4 -4
  150. data/test/test_Stl_Map.cpp +37 -39
  151. data/test/test_Stl_Multimap.cpp +693 -0
  152. data/test/test_Stl_Pair.cpp +8 -8
  153. data/test/test_Stl_Reference_Wrapper.cpp +4 -2
  154. data/test/test_Stl_Set.cpp +790 -0
  155. data/test/{test_Stl_SmartPointer.cpp → test_Stl_SharedPtr.cpp} +97 -127
  156. data/test/test_Stl_Tuple.cpp +116 -0
  157. data/test/test_Stl_Type.cpp +1 -1
  158. data/test/test_Stl_UniquePtr.cpp +202 -0
  159. data/test/test_Stl_Unordered_Map.cpp +28 -34
  160. data/test/test_Stl_Variant.cpp +217 -89
  161. data/test/test_Stl_Vector.cpp +209 -83
  162. data/test/test_To_Ruby.cpp +373 -1
  163. data/test/test_Type.cpp +85 -14
  164. data/test/test_global_functions.cpp +17 -4
  165. metadata +94 -10
  166. data/rice/detail/TupleIterator.hpp +0 -14
data/test/test_Stl_UniquePtr.cpp ADDED
@@ -0,0 +1,202 @@
1
+ #include "unittest.hpp"
2
+ #include "embed_ruby.hpp"
3
+ #include <rice/rice.hpp>
4
+ #include <rice/stl.hpp>
5
+
6
+ #include <memory>
7
+
8
+ using namespace Rice;
9
+
10
+ TESTSUITE(UniquePtr);
11
+
12
+ namespace
13
+ {
14
+ class MyClass
15
+ {
16
+ public:
17
+ static inline int32_t constructorCalls = 0;
18
+ static inline int32_t copyConstructorCalls = 0;
19
+ static inline int32_t moveConstructorCalls = 0;
20
+ static inline int32_t destructorCalls = 0;
21
+
22
+ static void reset()
23
+ {
24
+ constructorCalls = 0;
25
+ copyConstructorCalls = 0;
26
+ moveConstructorCalls = 0;
27
+ destructorCalls = 0;
28
+ }
29
+
30
+ public:
31
+ int flag = 0;
32
+
33
+ public:
34
+ MyClass()
35
+ {
36
+ constructorCalls++;
37
+ }
38
+
39
+ ~MyClass()
40
+ {
41
+ destructorCalls++;
42
+ }
43
+
44
+ MyClass(const MyClass& other): flag(other.flag)
45
+ {
46
+ copyConstructorCalls++;
47
+ }
48
+
49
+ MyClass(MyClass&& other) : flag(other.flag)
50
+ {
51
+ moveConstructorCalls++;
52
+ }
53
+
54
+ void setFlag(int value)
55
+ {
56
+ this->flag = value;
57
+ }
58
+ };
59
+
60
+ class Factory
61
+ {
62
+ public:
63
+ std::unique_ptr<MyClass> transfer()
64
+ {
65
+ return std::make_unique<MyClass>();
66
+ }
67
+ };
68
+
69
+ class Sink
70
+ {
71
+ public:
72
+ int takeOwnership(std::unique_ptr<MyClass> ptr)
73
+ {
74
+ return ptr->flag;
75
+ }
76
+
77
+ int updatePointer(std::unique_ptr<MyClass>& ptr, MyClass* myClass)
78
+ {
79
+ ptr.reset(myClass);
80
+ return ptr->flag;
81
+ }
82
+ };
83
+
84
+ int extractFlagUniquePtrRef(std::unique_ptr<MyClass>& myClass)
85
+ {
86
+ return myClass->flag;
87
+ }
88
+ }
89
+
90
+ SETUP(UniquePtr)
91
+ {
92
+ embed_ruby();
93
+
94
+ #if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 2
95
+ rb_eval_string("GC.stress = true");
96
+ #endif
97
+
98
+ define_class<MyClass>("MyClass").
99
+ define_constructor(Constructor<MyClass>()).
100
+ define_method("set_flag", &MyClass::setFlag);
101
+
102
+ define_class<Factory>("Factory").
103
+ define_constructor(Constructor<Factory>()).
104
+ define_method("transfer", &Factory::transfer);
105
+
106
+ define_class<Sink>("Sink").
107
+ define_constructor(Constructor<Sink>()).
108
+ define_method("take_ownership", &Sink::takeOwnership).
109
+ define_method("update_pointer", &Sink::updatePointer,
110
+ Arg("ptr"), Arg("myClass").takeOwnership());
111
+
112
+ define_global_function("extract_flag_unique_ptr_ref", &extractFlagUniquePtrRef);
113
+ }
114
+
115
+ TEARDOWN(UniquePtr)
116
+ {
117
+ rb_gc_start();
118
+ #if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 2
119
+ rb_eval_string("GC.stress = false");
120
+ #endif
121
+ }
122
+
123
+ TESTCASE(takeOwnership)
124
+ {
125
+ MyClass::reset();
126
+
127
+ Module m = define_module("TestingModule");
128
+
129
+ std::string code = R"(factory = Factory.new
130
+ 10.times do |i|
131
+ my_class = factory.transfer
132
+ my_class.set_flag(i)
133
+ my_class = nil
134
+ end)";
135
+
136
+ m.module_eval(code);
137
+ rb_gc_start();
138
+
139
+ ASSERT_EQUAL(10, MyClass::constructorCalls);
140
+ ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
141
+ ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
142
+ ASSERT_EQUAL(10, MyClass::destructorCalls);
143
+ }
144
+
145
+ TESTCASE(RefParameter)
146
+ {
147
+ MyClass::reset();
148
+
149
+ Module m = define_module("TestingModule");
150
+
151
+ std::string code = R"(factory = Factory.new
152
+ my_class = factory.transfer
153
+ my_class.set_flag(7)
154
+ extract_flag_unique_ptr_ref(my_class))";
155
+
156
+ Object result = m.module_eval(code);
157
+ ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result));
158
+ }
159
+
160
+ TESTCASE(RoundTrip)
161
+ {
162
+ MyClass::reset();
163
+
164
+ Module m = define_module("TestingModule");
165
+
166
+ // Create ruby objects that point to the same instance of MyClass
167
+ std::string code = R"(factory = Factory.new
168
+ my_class = factory.transfer
169
+ my_class.set_flag(5)
170
+
171
+ sink = Sink.new
172
+ sink.take_ownership(my_class))";
173
+
174
+ Object result = m.instance_eval(code);
175
+ ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result.value()));
176
+
177
+ ASSERT_EQUAL(1, MyClass::constructorCalls);
178
+ ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
179
+ ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
180
+ ASSERT_EQUAL(1, MyClass::destructorCalls);
181
+ }
182
+
183
+ TESTCASE(Update)
184
+ {
185
+ MyClass::reset();
186
+
187
+ Module m = define_module("TestingModule");
188
+
189
+ // Create ruby objects that point to the same instance of MyClass
190
+ std::string code = R"(factory = Factory.new
191
+ my_class1 = factory.transfer
192
+ my_class1.set_flag(5)
193
+
194
+ my_class2 = MyClass.new
195
+ my_class2.set_flag(11)
196
+
197
+ sink = Sink.new
198
+ sink.update_pointer(my_class1, my_class2))";
199
+
200
+ Object result = m.instance_eval(code);
201
+ ASSERT_EQUAL(11, detail::From_Ruby<long>().convert(result.value()));
202
+ }
data/test/test_Stl_Unordered_Map.cpp CHANGED
@@ -47,9 +47,9 @@ TESTCASE(StringUnorderedMap)
47
47
  {
48
48
  Module m = define_module("Testing");
49
49
 
50
- Class c = define_unordered_map<std::unordered_map<std::string, std::string>>("StringUnorderedMap");
50
+ Class c = define_unordered_map<std::string, std::string>("StringUnorderedMap");
51
51
 
52
- Object unordered_map = m.module_eval("$unordered_map = StringUnorderedMap.new");
52
+ Object unordered_map = m.module_eval("$unordered_map = Std::StringUnorderedMap.new");
53
53
  Object result = unordered_map.call("size");
54
54
  ASSERT_EQUAL(0, detail::From_Ruby<int32_t>().convert(result));
55
55
 
@@ -66,8 +66,8 @@ TESTCASE(WrongType)
66
66
  {
67
67
  Module m = define_module("Testing");
68
68
 
69
- Class c = define_unordered_map<std::unordered_map<std::string, std::string>>("StringUnorderedMap");
70
- Object unordered_map = m.module_eval("$unordered_map = StringUnorderedMap.new");
69
+ Class c = define_unordered_map<std::string, std::string>("StringUnorderedMap");
70
+ Object unordered_map = m.module_eval("$unordered_map = Std::StringUnorderedMap.new");
71
71
 
72
72
  ASSERT_EXCEPTION_CHECK(
73
73
  Exception,
@@ -84,7 +84,7 @@ TESTCASE(Empty)
84
84
  {
85
85
  Module m = define_module("Testing");
86
86
 
87
- Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
87
+ Class c = define_unordered_map<std::string, std::int32_t>("IntUnorderedMap");
88
88
  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
89
89
 
90
90
  Object result = unordered_map.call("size");
@@ -98,7 +98,7 @@ TESTCASE(Include)
98
98
  {
99
99
  Module m = define_module("Testing");
100
100
 
101
- Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
101
+ Class c = define_unordered_map<std::string, std::int32_t>("IntUnorderedMap");
102
102
  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
103
103
  unordered_map.call("[]=", "one", 1);
104
104
  unordered_map.call("[]=", "two", 2);
@@ -117,7 +117,7 @@ TESTCASE(Value)
117
117
  {
118
118
  Module m = define_module("Testing");
119
119
 
120
- Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
120
+ Class c = define_unordered_map<std::string, std::int32_t>("IntUnorderedMap");
121
121
  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
122
122
  unordered_map.call("[]=", "one", 1);
123
123
  unordered_map.call("[]=", "two", 2);
@@ -133,7 +133,7 @@ TESTCASE(ToString)
133
133
  {
134
134
  Module m = define_module("Testing");
135
135
 
136
- Class c = define_unordered_map<std::unordered_map<std::string, std::int32_t>>("IntUnorderedMap");
136
+ Class c = define_unordered_map<std::string, std::int32_t>("IntUnorderedMap");
137
137
  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
138
138
  unordered_map.call("[]=", "one", 1);
139
139
  unordered_map.call("[]=", "two", 2);
@@ -151,7 +151,7 @@ TESTCASE(Update)
151
151
  {
152
152
  Module m = define_module("Testing");
153
153
 
154
- Class c = define_unordered_map<std::unordered_map<std::string, std::string>>("StringUnorderedMap");
154
+ Class c = define_unordered_map<std::string, std::string>("StringUnorderedMap");
155
155
  Data_Object<std::unordered_map<std::string, std::string>> unordered_map = c.call("new");
156
156
  unordered_map.call("[]=", "one", "original 1");
157
157
  unordered_map.call("[]=", "two", "original 2");
@@ -173,7 +173,7 @@ TESTCASE(Modify)
173
173
  {
174
174
  Module m = define_module("Testing");
175
175
 
176
- Class c = define_unordered_map<std::unordered_map<std::string, int64_t>>("Int64UnorderedMap");
176
+ Class c = define_unordered_map<std::string, int64_t>("Int64UnorderedMap");
177
177
  Data_Object<std::unordered_map<std::string, std::int64_t>> unordered_map = c.call("new");
178
178
 
179
179
  Object result = unordered_map.call("[]=", "one", 3232323232);
@@ -192,7 +192,7 @@ TESTCASE(KeysAndValues)
192
192
  {
193
193
  Module m = define_module("Testing");
194
194
 
195
- Class c = define_unordered_map<std::unordered_map<std::string, int32_t>>("Int32UnorderedMap");
195
+ Class c = define_unordered_map<std::string, int32_t>("Int32UnorderedMap");
196
196
  Data_Object<std::unordered_map<std::string, std::int32_t>> unordered_map = c.call("new");
197
197
 
198
198
  unordered_map.call("[]=", "one", 1);
@@ -220,7 +220,7 @@ TESTCASE(Copy)
220
220
  {
221
221
  Module m = define_module("Testing");
222
222
 
223
- Class c = define_unordered_map<std::unordered_map<std::string, double>>("DoubleUnorderedMap");
223
+ Class c = define_unordered_map<std::string, double>("DoubleUnorderedMap");
224
224
  Object object = c.call("new");
225
225
 
226
226
  object.call("[]=", "one", 11.1);
@@ -241,9 +241,9 @@ TESTCASE(Copy)
241
241
  TESTCASE(Iterate)
242
242
  {
243
243
  Module m = define_module("Testing");
244
- Class c = define_unordered_map<std::unordered_map<std::string, int>>("IntUnorderedMap");
244
+ Class c = define_unordered_map<std::string, int>("IntUnorderedMap");
245
245
 
246
- std::string code = R"(unordered_map = IntUnorderedMap.new
246
+ std::string code = R"(unordered_map = Std::IntUnorderedMap.new
247
247
  unordered_map["five"] = 5
248
248
  unordered_map["six"] = 6
249
249
  unordered_map["seven"] = 7
@@ -265,9 +265,9 @@ TESTCASE(Iterate)
265
265
  TESTCASE(ToEnum)
266
266
  {
267
267
  Module m = define_module("Testing");
268
- Class c = define_unordered_map<std::unordered_map<std::string, int>>("IntUnorderedMap");
268
+ Class c = define_unordered_map<std::string, int>("IntUnorderedMap");
269
269
 
270
- std::string code = R"(unordered_map = IntUnorderedMap.new
270
+ std::string code = R"(unordered_map = Std::IntUnorderedMap.new
271
271
  unordered_map["five"] = 5
272
272
  unordered_map["six"] = 6
273
273
  unordered_map["seven"] = 7
@@ -290,9 +290,9 @@ TESTCASE(ToEnum)
290
290
  TESTCASE(ToEnumSize)
291
291
  {
292
292
  Module m = define_module("TestingModule");
293
- Class c = define_unordered_map<std::unordered_map<std::string, int>>("IntUnorderedMap");
293
+ Class c = define_unordered_map<std::string, int>("IntUnorderedMap");
294
294
 
295
- std::string code = R"(map = IntUnorderedMap.new
295
+ std::string code = R"(map = Std::IntUnorderedMap.new
296
296
  map["five"] = 5
297
297
  map["six"] = 6
298
298
  map["seven"] = 7
@@ -327,7 +327,7 @@ TESTCASE(NotComparable)
327
327
  define_class<NotComparable>("NotComparable").
328
328
  define_constructor(Constructor<NotComparable, uint32_t>());
329
329
 
330
- Class c = define_unordered_map<std::unordered_map<std::string, NotComparable>>("NotComparableUnorderedMap");
330
+ Class c = define_unordered_map<std::string, NotComparable>("NotComparableUnorderedMap");
331
331
 
332
332
  Data_Object<std::unordered_map<std::string, NotComparable>> unordered_map = c.call("new");
333
333
  unordered_map.call("[]=", "one", NotComparable(1));
@@ -346,7 +346,7 @@ TESTCASE(NotPrintable)
346
346
  define_class<NotComparable>("NotComparable").
347
347
  define_constructor(Constructor<NotComparable, uint32_t>());
348
348
 
349
- Class c = define_unordered_map<std::unordered_map<std::string, NotComparable>>("NotComparableUnorderedMap");
349
+ Class c = define_unordered_map<std::string, NotComparable>("NotComparableUnorderedMap");
350
350
 
351
351
  Data_Object<std::unordered_map<std::string, NotComparable>> unordered_map = c.call("new");
352
352
  unordered_map.call("[]=", "one", NotComparable(1));
@@ -387,7 +387,7 @@ TESTCASE(Comparable)
387
387
  define_class<Comparable>("IsComparable").
388
388
  define_constructor(Constructor<Comparable, uint32_t>());
389
389
 
390
- Class c = define_unordered_map<std::unordered_map<std::string, Comparable>>("ComparableUnorderedMap");
390
+ Class c = define_unordered_map<std::string, Comparable>("ComparableUnorderedMap");
391
391
 
392
392
  Data_Object<std::unordered_map<std::string, Comparable>> unordered_map = c.call("new");
393
393
 
@@ -404,7 +404,7 @@ TESTCASE(Printable)
404
404
  define_class<Comparable>("IsComparable").
405
405
  define_constructor(Constructor<Comparable, uint32_t>());
406
406
 
407
- Class c = define_unordered_map<std::unordered_map<std::string, Comparable>>("ComparableUnorderedMap");
407
+ Class c = define_unordered_map<std::string, Comparable>("ComparableUnorderedMap");
408
408
 
409
409
  Data_Object<std::unordered_map<std::string, Comparable>> unordered_map = c.call("new");
410
410
  unordered_map.call("[]=", "one", Comparable(1));
@@ -443,7 +443,7 @@ TESTCASE(AutoRegisterReturn)
443
443
 
444
444
  Module m = define_module("Testing");
445
445
  Object unordered_map = m.module_eval("return_complex_unordered_map");
446
- ASSERT_EQUAL(u8"Rice::Std::UnorderedMap≺string≺char≻‚ complex≺double≻≻",
446
+ ASSERT_EQUAL("Std::UnorderedMap≺string‚ complex≺double≻≻",
447
447
  unordered_map.class_name().str());
448
448
 
449
449
  std::string code = R"(unordered_map = return_complex_unordered_map
@@ -454,14 +454,8 @@ TESTCASE(AutoRegisterReturn)
454
454
  ASSERT_EQUAL(Qtrue, result.value());
455
455
 
456
456
  // Now register the unordered_map again
457
- define_unordered_map<std::unordered_map<std::string, std::complex<double>>>("ComplexUnorderedMap");
458
- code = R"(unordered_map = ComplexUnorderedMap.new)";
459
- result = m.module_eval(code);
460
- ASSERT(result.is_instance_of(unordered_map.class_of()));
461
-
462
- // And again in the module
463
- define_unordered_map_under<std::unordered_map<std::string, std::complex<double>>>(m, "ComplexUnorderedMap2");
464
- code = R"(unordered_map = Testing::ComplexUnorderedMap2.new)";
457
+ define_unordered_map<std::string, std::complex<double>>("ComplexUnorderedMap");
458
+ code = R"(unordered_map = Std::ComplexUnorderedMap.new)";
465
459
  result = m.module_eval(code);
466
460
  ASSERT(result.is_instance_of(unordered_map.class_of()));
467
461
  }
@@ -470,7 +464,7 @@ TESTCASE(AutoRegisterParameter)
470
464
  {
471
465
  define_global_function("pass_complex_unordered_map", &passComplexUnorderedMap);
472
466
 
473
- std::string code = u8R"(unordered_map = Rice::Std::UnorderedMap≺string≺char≻‚ complex≺double≻≻.new
467
+ std::string code = R"(unordered_map = Std::UnorderedMap≺string‚ complex≺double≻≻.new
474
468
  unordered_map["four"] = Complex(4.0, 4.0)
475
469
  unordered_map["five"] = Complex(5.0, 5.0)
476
470
  pass_complex_unordered_map(unordered_map))";
@@ -479,7 +473,7 @@ TESTCASE(AutoRegisterParameter)
479
473
  Object unordered_map = m.module_eval(code);
480
474
 
481
475
  Object result = unordered_map.call("size");
482
- ASSERT_EQUAL(u8"Rice::Std::UnorderedMap≺string≺char≻‚ complex≺double≻≻",
476
+ ASSERT_EQUAL("Std::UnorderedMap≺string‚ complex≺double≻≻",
483
477
  unordered_map.class_name().str());
484
478
  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
485
479
 
@@ -498,7 +492,7 @@ namespace
498
492
 
499
493
  TESTCASE(DefaultValue)
500
494
  {
501
- define_unordered_map<std::unordered_map<std::string, std::string>>("StringUnorderedMap");
495
+ define_unordered_map<std::string, std::string>("StringUnorderedMap");
502
496
  define_global_function("default_unordered_map", &defaultUnorderedMap, Arg("strings") = std::unordered_map<std::string, std::string>{ {"one", "value 1"}, {"two", "value 2"}, {"three", "value 3"} });
503
497
 
504
498
  Module m = define_module("Testing");