rice 4.3.3 → 4.6.0

data/test/test_Tracking.cpp

@@ -87,6 +87,7 @@ SETUP(Tracking)
 TEARDOWN(Tracking)
 {
   detail::Registries::instance.instances.isEnabled = true;
+  rb_gc_start();
 }
 
 TESTCASE(TransferPointer)

data/test/test_Type.cpp

@@ -0,0 +1,171 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+
+#include <rice/rice.hpp>
+
+#include <complex>
+
+using namespace Rice;
+
+TESTSUITE(Type);
+
+namespace Outer
+{
+  namespace Inner
+  {
+    using Vec1 = std::vector<std::complex<float>>;
+    using Vec2 = std::vector<unsigned char*>;
+    using Map1 = std::map<std::string, std::vector<std::complex<float>>>;
+    using UnorderedMap1 = std::unordered_map<std::string, std::complex<float>>;
+
+    class SomeClass
+    {
+    };
+
+    using Vec3 = std::vector<SomeClass>;
+  }
+}
+
+SETUP(Type)
+{
+  embed_ruby();
+}
+
+TEARDOWN(Type)
+{
+  rb_gc_start();
+}
+
+TESTCASE(FindGroup)
+{
+  std::string name = "class std::vector<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >";
+
+  std::string group = detail::findGroup(name, 0);
+  ASSERT_EQUAL("<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >", group.c_str());
+
+  group = detail::findGroup(name, 18);
+  ASSERT_EQUAL("<unsigned char, 2>", group.c_str());
+  
+  group = detail::findGroup(name, 49);
+  ASSERT_EQUAL("<class cv::Vec<unsigned char, 2> >", group.c_str());
+
+  ASSERT_EXCEPTION_CHECK(
+    std::runtime_error,
+    detail::findGroup(name, 48),
+      ASSERT_EQUAL("Unbalanced Group", ex.what())
+  );
+}
+
+TESTCASE(CppClassName)
+{
+  std::string typeName = detail::typeName(typeid(std::string));
+  std::string className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::string", className.c_str());
+
+  typeName = detail::typeName(typeid(std::wstring));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::wstring", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<std::string>));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<std::string>", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<std::wstring>));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<std::wstring>", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<double*>));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<double*>", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<double**>));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<double**>", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec1));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<std::complex<float>>", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec2));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<unsigned char*>", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec3));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::vector<Outer::Inner::SomeClass>", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Map1));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::map<std::string, std::vector<std::complex<float>>>", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::UnorderedMap1));
+  className = detail::cppClassName(typeName);
+  ASSERT_EQUAL("std::unordered_map<std::string, std::complex<float>>", className.c_str());
+}
+
+TESTCASE(RubyClassName)
+{
+  std::string typeName = detail::typeName(typeid(std::string));
+  std::string className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("String", className.c_str());
+
+  typeName = detail::typeName(typeid(std::wstring));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Wstring", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<std::string>));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺string≻", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<std::wstring>));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺wstring≻", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<double*>));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺double∗≻", className.c_str());
+
+  typeName = detail::typeName(typeid(std::vector<double**>));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺double∗∗≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec1));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺complex≺float≻≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec2));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺unsigned char∗≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Vec3));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Vector≺Outer꞉꞉Inner꞉꞉SomeClass≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::Map1));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("Map≺string‚ vector≺complex≺float≻≻≻", className.c_str());
+
+  typeName = detail::typeName(typeid(Outer::Inner::UnorderedMap1));
+  className = detail::rubyClassName(typeName);
+  ASSERT_EQUAL("UnorderedMap≺string‚ complex≺float≻≻", className.c_str());
+}
+
+TESTCASE(MakeRubyClass)
+{
+  std::string typeName = detail::typeName(typeid(Outer::Inner::Vec1));
+  std::string rubyClassName = detail::rubyClassName(typeName);
+
+  Module module = define_module("Testing");
+
+  Identifier id(rubyClassName);
+  define_class_under<Outer::Inner::Vec1>(module, id);
+  
+  std::string code = R"(Testing.constants.grep(/Vector/).sort)";
+  
+  Array result = module.module_eval(code);
+  ASSERT_EQUAL(1, result.size());
+
+  // FIXME - fails compilation on GCC
+  // Symbol element = result[0];
+  // ASSERT_EQUAL("Vector≺complex≺float≻≻", element.c_str());
+}

data/test/test_global_functions.cpp

@@ -11,16 +11,21 @@ SETUP(GlobalFunction)
   embed_ruby();
 }
 
-namespace {
+TEARDOWN(GlobalFunctions)
+{
+  rb_gc_start();
+}
 
+namespace
+{
   bool no_args()
   {
     return true;
   }
 
-  int int_arg(int arg)
+  int int_arg(int value)
   {
-    return 2 * arg;
+    return 2 * value;
   }
 }
 
@@ -52,6 +57,28 @@ TESTCASE(int_arg)
   ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(result));
 }
 
+TESTCASE(int_kw_arg)
+{
+  define_global_function("method_with_kw_args_1", &int_arg, Arg("value"));
+  Module m = Module(rb_mKernel);
+  std::string code = R"(method_with_kw_args_1(value: 15))";
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(int_kw_arg_invalid)
+{
+  define_global_function("method_with_kw_args_2", &int_arg, Arg("value"));
+  Module m = Module(rb_mKernel);
+  std::string code = R"(method_with_kw_args_2(wrong: 15))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.instance_eval(code),
+    ASSERT_EQUAL("Unknown keyword: wrong", ex.what())
+  );
+}
+
 TESTCASE(int_arg_lambda)
 {
   define_global_function("method_with_args", [](int value)
@@ -85,7 +112,7 @@ namespace
 
 TESTCASE(default_arguments_for_define_global_function)
 {
-  define_global_function("foo", &defaults_method_one, Arg("arg1"), Arg("arg2") = (int)3, Arg("arg3") = (bool)true);
+  define_global_function("foo", &defaults_method_one, Arg("arg1"), Arg("arg2") = (int)3, Arg("arg3") = true);
   Module m(rb_mKernel);
 
   m.call("foo", 2);
@@ -107,7 +134,39 @@ TESTCASE(default_arguments_for_define_global_function)
   ASSERT(!defaults_method_one_arg3);
 }
 
-TESTCASE(default_arguments_for_define_global_function_and_returning)
+TESTCASE(default_arguments_kw)
+{
+  define_global_function("defaults_method_one_kw", &defaults_method_one,
+    Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true);
+  Module m = Module(rb_mKernel);
+
+  std::string code = R"(defaults_method_one_kw(4, arg2: 5))";
+  m.instance_eval(code);
+  ASSERT_EQUAL(4, defaults_method_one_arg1);
+  ASSERT_EQUAL(5, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  code = R"(defaults_method_one_kw(arg1: 9, arg2: 11, arg3: false))";
+  m.instance_eval(code);
+  ASSERT_EQUAL(9, defaults_method_one_arg1);
+  ASSERT_EQUAL(11, defaults_method_one_arg2);
+  ASSERT(!defaults_method_one_arg3);
+
+  code = R"(defaults_method_one_kw(4, arg3: false))";
+  m.instance_eval(code);
+  ASSERT_EQUAL(4, defaults_method_one_arg1);
+  ASSERT_EQUAL(3, defaults_method_one_arg2);
+  ASSERT_EQUAL(false, defaults_method_one_arg3);
+
+  code = R"(defaults_method_one_kw(arg2: 5))";
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.instance_eval(code),
+    ASSERT_EQUAL("Missing argument. Name: arg1. Index: 0.", ex.what())
+  );
+}
+
+TESTCASE(default_arguments_and_returning)
 {
   define_global_function("foo_ret", &defaults_returns, Arg("arg1"), Arg("arg2") = (int)3);
   Module m(rb_mKernel);
@@ -119,7 +178,8 @@ TESTCASE(default_arguments_for_define_global_function_and_returning)
   ASSERT_EQUAL(INT2NUM(50), o.value());
 }
 
-namespace {
+namespace
+{
   int the_one_default_arg = 0;
   void method_with_one_default_arg(int num = 4) {
     the_one_default_arg = num;
@@ -132,4 +192,4 @@ TESTCASE(single_default_argument)
   Module m(rb_mKernel);
   m.call("foo");
   ASSERT_EQUAL(4, the_one_default_arg);
-}
+}

data/test/unittest.cpp

@@ -3,6 +3,10 @@
 #include <map>
 #include "unittest.hpp"
 
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
 size_t assertions;
 
 namespace
@@ -98,6 +102,10 @@ char* findOption(char** begin, char** end, const std::string& option)
 
 int main(int argc, char** argv)
 {
+#ifdef _WIN32
+  SetConsoleOutputCP(CP_UTF8);
+#endif
+
   std::vector<Test_Suite> suites;
 
   char* moduleName = findOption(argv, argv + argc, "--suite");

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.3.3
+  version: 4.6.0
 platform: ruby
 authors:
 - Paul Brannan
 - Jason Roelofs
 - Charlie Savage
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-22 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,60 +67,106 @@ extra_rdoc_files:
 - README.md
 files:
 - CHANGELOG.md
+- CMakeLists.txt
+- CMakePresets.json
 - CONTRIBUTORS.md
 - COPYING
+- FindRuby.cmake
 - Gemfile
 - README.md
 - Rakefile
 - include/rice/rice.hpp
 - include/rice/stl.hpp
+- lib/make_rice_headers.rb
 - lib/mkmf-rice.rb
-- lib/version.rb
+- lib/rice.rb
+- lib/rice/version.rb
+- lib/rubygems/builder.rb
+- lib/rubygems/cmake_builder.rb
+- lib/rubygems_plugin.rb
+- rice.gemspec
 - rice/Address_Registration_Guard.hpp
 - rice/Address_Registration_Guard.ipp
-- rice/Address_Registration_Guard_defn.hpp
 - rice/Arg.hpp
 - rice/Arg.ipp
+- rice/Buffer.hpp
+- rice/Buffer.ipp
+- rice/Callback.hpp
+- rice/Callback.ipp
 - rice/Constructor.hpp
+- rice/Constructor.ipp
 - rice/Data_Object.hpp
 - rice/Data_Object.ipp
-- rice/Data_Object_defn.hpp
 - rice/Data_Type.hpp
 - rice/Data_Type.ipp
-- rice/Data_Type_defn.hpp
 - rice/Director.hpp
 - rice/Enum.hpp
 - rice/Enum.ipp
 - rice/Exception.hpp
 - rice/Exception.ipp
-- rice/Exception_defn.hpp
-- rice/HandlerRegistration.hpp
-- rice/Identifier.hpp
-- rice/Identifier.ipp
+- rice/Init.hpp
+- rice/Init.ipp
+- rice/JumpException.hpp
+- rice/JumpException.ipp
+- rice/MemoryView.hpp
+- rice/MemoryView.ipp
 - rice/Return.hpp
 - rice/Return.ipp
-- rice/detail/ExceptionHandler.hpp
-- rice/detail/ExceptionHandler.ipp
-- rice/detail/ExceptionHandler_defn.hpp
+- rice/cpp_api/Array.hpp
+- rice/cpp_api/Array.ipp
+- rice/cpp_api/Builtin_Object.hpp
+- rice/cpp_api/Builtin_Object.ipp
+- rice/cpp_api/Class.hpp
+- rice/cpp_api/Class.ipp
+- rice/cpp_api/Encoding.hpp
+- rice/cpp_api/Encoding.ipp
+- rice/cpp_api/Hash.hpp
+- rice/cpp_api/Hash.ipp
+- rice/cpp_api/Identifier.hpp
+- rice/cpp_api/Identifier.ipp
+- rice/cpp_api/Module.hpp
+- rice/cpp_api/Module.ipp
+- rice/cpp_api/Object.hpp
+- rice/cpp_api/Object.ipp
+- rice/cpp_api/String.hpp
+- rice/cpp_api/String.ipp
+- rice/cpp_api/Struct.hpp
+- rice/cpp_api/Struct.ipp
+- rice/cpp_api/Symbol.hpp
+- rice/cpp_api/Symbol.ipp
+- rice/cpp_api/shared_methods.hpp
+- rice/detail/DefaultHandler.hpp
+- rice/detail/DefaultHandler.ipp
 - rice/detail/HandlerRegistry.hpp
 - rice/detail/HandlerRegistry.ipp
 - rice/detail/InstanceRegistry.hpp
 - rice/detail/InstanceRegistry.ipp
-- rice/detail/Jump_Tag.hpp
 - rice/detail/MethodInfo.hpp
 - rice/detail/MethodInfo.ipp
-- rice/detail/NativeAttribute.hpp
-- rice/detail/NativeAttribute.ipp
+- rice/detail/Native.hpp
+- rice/detail/Native.ipp
+- rice/detail/NativeAttributeGet.hpp
+- rice/detail/NativeAttributeGet.ipp
+- rice/detail/NativeAttributeSet.hpp
+- rice/detail/NativeAttributeSet.ipp
+- rice/detail/NativeCallbackFFI.hpp
+- rice/detail/NativeCallbackFFI.ipp
+- rice/detail/NativeCallbackSimple.hpp
+- rice/detail/NativeCallbackSimple.ipp
 - rice/detail/NativeFunction.hpp
 - rice/detail/NativeFunction.ipp
 - rice/detail/NativeIterator.hpp
 - rice/detail/NativeIterator.ipp
 - rice/detail/NativeRegistry.hpp
 - rice/detail/NativeRegistry.ipp
+- rice/detail/Proc.hpp
+- rice/detail/Proc.ipp
 - rice/detail/Registries.hpp
 - rice/detail/Registries.ipp
 - rice/detail/RubyFunction.hpp
 - rice/detail/RubyFunction.ipp
+- rice/detail/RubyType.hpp
+- rice/detail/RubyType.ipp
 - rice/detail/Type.hpp
 - rice/detail/Type.ipp
 - rice/detail/TypeRegistry.hpp
@@ -133,17 +178,61 @@ files:
 - rice/detail/default_allocation_func.ipp
 - rice/detail/from_ruby.hpp
 - rice/detail/from_ruby.ipp
-- rice/detail/from_ruby_defn.hpp
 - rice/detail/ruby.hpp
 - rice/detail/to_ruby.hpp
 - rice/detail/to_ruby.ipp
-- rice/detail/to_ruby_defn.hpp
 - rice/forward_declares.ipp
 - rice/global_function.hpp
 - rice/global_function.ipp
+- rice/libc/file.hpp
+- rice/libc/file.ipp
 - rice/rice.hpp
 - rice/ruby_mark.hpp
 - rice/stl.hpp
+- rice/stl/complex.hpp
+- rice/stl/complex.ipp
+- rice/stl/exception.hpp
+- rice/stl/exception.ipp
+- rice/stl/exception_ptr.hpp
+- rice/stl/exception_ptr.ipp
+- rice/stl/map.hpp
+- rice/stl/map.ipp
+- rice/stl/monostate.hpp
+- rice/stl/monostate.ipp
+- rice/stl/multimap.hpp
+- rice/stl/multimap.ipp
+- rice/stl/optional.hpp
+- rice/stl/optional.ipp
+- rice/stl/pair.hpp
+- rice/stl/pair.ipp
+- rice/stl/reference_wrapper.hpp
+- rice/stl/reference_wrapper.ipp
+- rice/stl/set.hpp
+- rice/stl/set.ipp
+- rice/stl/shared_ptr.hpp
+- rice/stl/shared_ptr.ipp
+- rice/stl/string.hpp
+- rice/stl/string.ipp
+- rice/stl/string_view.hpp
+- rice/stl/string_view.ipp
+- rice/stl/tuple.hpp
+- rice/stl/tuple.ipp
+- rice/stl/type_index.hpp
+- rice/stl/type_index.ipp
+- rice/stl/type_info.hpp
+- rice/stl/type_info.ipp
+- rice/stl/unique_ptr.hpp
+- rice/stl/unique_ptr.ipp
+- rice/stl/unordered_map.hpp
+- rice/stl/unordered_map.ipp
+- rice/stl/variant.hpp
+- rice/stl/variant.ipp
+- rice/stl/vector.hpp
+- rice/stl/vector.ipp
+- rice/traits/attribute_traits.hpp
+- rice/traits/function_traits.hpp
+- rice/traits/method_traits.hpp
+- rice/traits/rice_traits.hpp
 - sample/callbacks/extconf.rb
 - sample/callbacks/sample_callbacks.cpp
 - sample/callbacks/test.rb
@@ -171,7 +260,9 @@ files:
 - test/test_Address_Registration_Guard.cpp
 - test/test_Array.cpp
 - test/test_Attribute.cpp
+- test/test_Buffer.cpp
 - test/test_Builtin_Object.cpp
+- test/test_Callback.cpp
 - test/test_Class.cpp
 - test/test_Constructor.cpp
 - test/test_Data_Object.cpp
@@ -179,34 +270,46 @@ files:
 - test/test_Director.cpp
 - test/test_Enum.cpp
 - test/test_Exception.cpp
+- test/test_File.cpp
+- test/test_From_Ruby.cpp
 - test/test_Hash.cpp
 - test/test_Identifier.cpp
 - test/test_Inheritance.cpp
 - test/test_Iterator.cpp
-- test/test_Jump_Tag.cpp
+- test/test_Jump_Exception.cpp
 - test/test_Keep_Alive.cpp
 - test/test_Keep_Alive_No_Wrapper.cpp
 - test/test_Memory_Management.cpp
 - test/test_Module.cpp
 - test/test_Native_Registry.cpp
 - test/test_Object.cpp
+- test/test_Overloads.cpp
 - test/test_Ownership.cpp
+- test/test_Proc.cpp
 - test/test_Self.cpp
+- test/test_Stl_Exception.cpp
 - test/test_Stl_Map.cpp
+- test/test_Stl_Multimap.cpp
 - test/test_Stl_Optional.cpp
 - test/test_Stl_Pair.cpp
 - test/test_Stl_Reference_Wrapper.cpp
-- test/test_Stl_SmartPointer.cpp
+- test/test_Stl_Set.cpp
+- test/test_Stl_SharedPtr.cpp
 - test/test_Stl_String.cpp
 - test/test_Stl_String_View.cpp
+- test/test_Stl_Tuple.cpp
+- test/test_Stl_Type.cpp
+- test/test_Stl_UniquePtr.cpp
 - test/test_Stl_Unordered_Map.cpp
 - test/test_Stl_Variant.cpp
 - test/test_Stl_Vector.cpp
 - test/test_String.cpp
 - test/test_Struct.cpp
 - test/test_Symbol.cpp
-- test/test_To_From_Ruby.cpp
+- test/test_Template.cpp
+- test/test_To_Ruby.cpp
 - test/test_Tracking.cpp
+- test/test_Type.cpp
 - test/test_global_functions.cpp
 - test/unittest.cpp
 - test/unittest.hpp
@@ -218,7 +321,6 @@ metadata:
   changelog_uri: https://github.com/ruby-rice/rice/blob/master/CHANGELOG.md
   documentation_uri: https://ruby-rice.github.io
   source_code_uri: https://github.com/ruby-rice/rice
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -226,15 +328,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby Interface for C++ Extensions
 test_files:

data/lib/version.rb

@@ -1,3 +0,0 @@
-module Rice
-  VERSION = "4.3.3"
-end

data/rice/Address_Registration_Guard_defn.hpp

@@ -1,79 +0,0 @@
-#ifndef Rice__Address_Registration_Guard_defn__hpp_
-#define Rice__Address_Registration_Guard_defn__hpp_
-
-#include "cpp_api/Object_defn.hpp"
-#include "detail/ruby.hpp"
-
-namespace Rice
-{
-  //! A guard to register a given address with the GC.
-  /*! Calls rb_gc_register_address upon construction and
-   *  rb_gc_unregister_address upon destruction.
-   *  For example:
-   *  \code
-   *    Class Foo
-   *    {
-   *    public:
-   *      Foo()
-   *        : string_(rb_str_new2())
-   *        , guard_(&string_);
-   *
-   *    private:
-   *      VALUE string_;
-   *      Address_Registration_Guard guard_;
-   *    };
-   *  \endcode
-   */
-  class Address_Registration_Guard
-  {
-  public:
-    //! Register an address with the GC.
-    /*  \param address The address to register with the GC.  The address
-     *  must point to a valid ruby object (RObject).
-     */
-    Address_Registration_Guard(VALUE* address);
-
-    //! Register an Object with the GC.
-    /*! \param object The Object to register with the GC.  The object must
-     *  not be destroyed before the Address_Registration_Guard is
-     *  destroyed.
-     */
-    Address_Registration_Guard(Object* object);
-
-    //! Unregister an address/Object with the GC.
-    /*! Destruct an Address_Registration_Guard.  The address registered
-     *  with the Address_Registration_Guard when it was constructed will
-     *  be unregistered from the GC.
-     */
-    ~Address_Registration_Guard();
-
-    // Disable copying
-    Address_Registration_Guard(Address_Registration_Guard const& other) = delete;
-    Address_Registration_Guard& operator=(Address_Registration_Guard const& other) = delete;
-
-    // Enable moving
-    Address_Registration_Guard(Address_Registration_Guard&& other);
-    Address_Registration_Guard& operator=(Address_Registration_Guard&& other);
-
-    //! Get the address that is registered with the GC.
-    VALUE* address() const;
-
-    /** Called during Ruby's exit process since we should not call
-     * rb_gc unregister_address there
-     */
-    static void disable();
-
-  private:
-    inline static bool enabled = true;
-    inline static bool exit_handler_registered = false;
-    static void registerExitHandler();
-
-  private:
-    void registerAddress() const;
-    void unregisterAddress();
-
-    VALUE* address_ = nullptr;
-  };
-} // namespace Rice
-
-#endif // Rice__Address_Registration_Guard_defn__hpp_