rice 4.3.3 → 4.6.0

data/rice/detail/from_ruby_defn.hpp

@@ -1,38 +0,0 @@
-#ifndef Rice__detail__from_ruby_defn__hpp_
-#define Rice__detail__from_ruby_defn__hpp_
-
-#include <type_traits>
-
-#include "ruby.hpp"
-
-namespace Rice::detail
-{
-  //! Convert a Ruby object to C++.
-  /*! If the Ruby object can be converted to an immediate value, returns a
-   *  copy of the Ruby object.  If the Ruby object is holding a C++
-   *  object and the type specified is a pointer to that type, returns a
-   *  pointer to that object.
-   *
-   *  Conversions from ruby to a pointer type are automatically generated
-   *  when a type is bound using Data_Type.  If no conversion exists an
-   *  exception is thrown.
-   *
-   *  \param T the C++ type to which to convert.
-   *  \param x the Ruby object to convert.
-   *  \return a C++ representation of the Ruby object.
-   *
-   *  Example:
-   *  \code
-   *    Object x = INT2NUM(42);
-   *    std::cout << From_Ruby<int>::convert(x);
-   *
-   *    Data_Object<Foo> foo(new Foo);
-   *    std::cout << *From_Ruby<Foo *>(foo) << std::endl;
-   *  \endcode
-   */
-
-  template <typename T>
-  class From_Ruby;
-}
-
-#endif // Rice__detail__From_Ruby2_defn__hpp_

data/rice/detail/to_ruby_defn.hpp

@@ -1,48 +0,0 @@
-#ifndef Rice__detail__to_ruby_defn__hpp_
-#define Rice__detail__to_ruby_defn__hpp_
-
-#include "../traits/rice_traits.hpp"
-
-namespace Rice
-{
-  namespace detail
-  {
-    //! Convert a C++ object to Ruby.
-    /*! If x is a pointer, wraps the pointee as a Ruby object.  If x is an
-     *  Object, returns x.
-     *
-     *  If no conversion exists a compile-time error is generated.
-     *
-     *  \param x the object to convert.
-     *  \return a Ruby representation of the C++ object.
-     *
-     *  Example:
-     *  \code
-     *    rb_p(to_ruby(42));
-     *
-     *    Foo * p_foo = new Foo();
-     *    rb_p(to_ruby(p_foo));
-     *  \endcode
-     */
-    template <typename T>
-    class To_Ruby;
-   
-    // Helper template function that let's users avoid having to specify the template type - its deduced
-    template <typename T>
-    VALUE to_ruby(T&& x)
-    {
-      using Unqualified_T = remove_cv_recursive_t<T>;
-      return To_Ruby<Unqualified_T>().convert(std::forward<T>(x));
-    }
-
-    // Helper template function that let's users avoid having to specify the template type - its deduced
-    template <typename T>
-    VALUE to_ruby(T* x)
-    {
-      using Unqualified_T = remove_cv_recursive_t<T>;
-      return To_Ruby<Unqualified_T*>().convert(x);
-    }
-  } // detail
-} // Rice
-
-#endif // Rice__detail__to_ruby_defn__hpp_

data/test/test_Jump_Tag.cpp

@@ -1,17 +0,0 @@
-#include "unittest.hpp"
-#include <rice/rice.hpp>
-
-using namespace Rice;
-
-TESTSUITE(Jump_Tag);
-
-SETUP(Jump_Tag)
-{
-}
-
-TESTCASE(construct)
-{
-  Jump_Tag jump_tag(42);
-  ASSERT_EQUAL(42, jump_tag.tag);
-}
-

data/test/test_Stl_SmartPointer.cpp

@@ -1,283 +0,0 @@
-#include "unittest.hpp"
-#include "embed_ruby.hpp"
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
-
-#include <memory>
-
-using namespace Rice;
-
-TESTSUITE(SmartPointer);
-
-namespace
-{
-  class MyClass
-  {
-  public:
-    static inline int32_t constructorCalls = 0;
-    static inline int32_t copyConstructorCalls = 0;
-    static inline int32_t moveConstructorCalls = 0;
-    static inline int32_t destructorCalls = 0;
-
-    static void reset()
-    {
-      constructorCalls = 0;
-      copyConstructorCalls = 0;
-      moveConstructorCalls = 0;
-      destructorCalls = 0;
-    }
-
-  public:
-    int flag = 0;
-
-  public:
-    MyClass()
-    {
-      constructorCalls++;
-    }
-
-    ~MyClass()
-    {
-      destructorCalls++;
-    }
-
-    MyClass(const MyClass& other): flag(other.flag)
-    {
-      copyConstructorCalls++;
-    }
-
-    MyClass(MyClass&& other) : flag(other.flag)
-    {
-      moveConstructorCalls++;
-    }
-
-    void setFlag(int value)
-    {
-      this->flag = value;
-    }
-  };
-
-  class Factory
-  {
-  public:
-    std::unique_ptr<MyClass> transfer()
-    {
-      return std::make_unique<MyClass>();
-    }
-
-    std::shared_ptr<MyClass> share()
-    {
-      if (!instance_)
-      {
-        instance_ = std::make_shared<MyClass>();
-      }
-      return instance_;
-    }
-
-    std::shared_ptr<MyClass>& share_ref()
-    {
-      if (!instance_)
-      {
-        instance_ = std::make_shared<MyClass>();
-      }
-      return instance_;
-    }
-
-  public:
-    static inline std::shared_ptr<MyClass> instance_;
-  };
-
-  int extractFlagUniquePtrRef(std::unique_ptr<MyClass>& myClass)
-  {
-    return myClass->flag;
-  }
-
-  int extractFlagSharedPtr(std::shared_ptr<MyClass> myClass)
-  {
-    return myClass->flag;
-  }
-
-  int extractFlagSharedPtrRef(std::shared_ptr<MyClass>& myClass)
-  {
-    return myClass->flag;
-  }
-}
-
-SETUP(SmartPointer)
-{
-  embed_ruby();
-
-  define_class<MyClass>("MyClass").
-    define_method("set_flag", &MyClass::setFlag);
-
-  define_class<Factory>("Factory").
-    define_constructor(Constructor<Factory>()).
-    define_method("transfer", &Factory::transfer).
-    define_method("share", &Factory::share).
-    define_method("share_ref", &Factory::share_ref);
-
-  define_global_function("extract_flag_unique_ptr_ref", &extractFlagUniquePtrRef);
-  define_global_function("extract_flag_shared_ptr", &extractFlagSharedPtr);
-  define_global_function("extract_flag_shared_ptr_ref", &extractFlagSharedPtrRef);
-
-  define_global_function("extract_flag_shared_ptr_with_default", &extractFlagSharedPtr,
-      Arg("myClass") = std::make_shared<MyClass>());
-  define_global_function("extract_flag_shared_ptr_ref_with_default", &extractFlagSharedPtrRef,
-      Arg("myClass") = std::make_shared<MyClass>());
-}
-
-TESTCASE(TransferOwnership)
-{
-  MyClass::reset();
-
-  Module m = define_module("TestingModule");
-
-  std::string code = R"(factory = Factory.new
-                        10.times do |i|
-                          my_class = factory.transfer
-                          my_class.set_flag(i)
-                          my_class = nil
-                        end)";
-
-  m.module_eval(code);
-  rb_gc_start();
-
-  ASSERT_EQUAL(10, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(10, MyClass::destructorCalls);
-  ASSERT(!Factory::instance_);
-}
-
-TESTCASE(ShareOwnership)
-{
-  MyClass::reset();
-
-  Module m = define_module("TestingModule");
-
-  // Create ruby objects that point to the same instance of MyClass
-  std::string code = R"(factory = Factory.new
-                        10.times do |i|
-                          my_class = factory.share
-                          my_class.set_flag(i)
-                        end)";
-
-
-  ASSERT_EQUAL(0, Factory::instance_.use_count());
-  m.module_eval(code);
-  
-  ASSERT_EQUAL(11, Factory::instance_.use_count());
-  rb_gc_start();
-  ASSERT_EQUAL(1, Factory::instance_.use_count());
-
-  ASSERT_EQUAL(1, MyClass::constructorCalls);
-  ASSERT_EQUAL(0, MyClass::copyConstructorCalls);
-  ASSERT_EQUAL(0, MyClass::moveConstructorCalls);
-  ASSERT_EQUAL(0, MyClass::destructorCalls);
-  ASSERT_EQUAL(9, Factory::instance_->flag);
-}
-
-
-TESTCASE(ShareOwnership2)
-{
-  MyClass::reset();
-
-  Module m = define_module("TestingModule");
-
-  // Create ruby objects that point to the same instance of MyClass
-  std::string code = R"(factory = Factory.new
-                        10.times do |i|
-                          my_class = factory.share
-                          my_class.set_flag(i)
-                        end)";
-
-  Factory factory;
-  std::shared_ptr<MyClass> myClass = factory.share();
-  ASSERT_EQUAL(2, Factory::instance_.use_count());
-
-  // Call some ruby code
-  Data_Object<Factory> wrapper(factory);
-  ASSERT_EQUAL(2, Factory::instance_.use_count());
-  wrapper.instance_eval("self.share_ref.set_flag(1)");
-
-  ASSERT_EQUAL(3, Factory::instance_.use_count());
-  rb_gc_start();
-  ASSERT_EQUAL(2, Factory::instance_.use_count());
-}
-
-TESTCASE(UniquePtrRefParameter)
-{
-  MyClass::reset();
-
-  Module m = define_module("TestingModule");
-
-  std::string code = R"(factory = Factory.new
-                        my_class = factory.transfer
-                        my_class.set_flag(7)
-                        extract_flag_unique_ptr_ref(my_class))";
-
-  Object result = m.module_eval(code);
-  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result));
-}
-
-TESTCASE(SharedPtrParameter)
-{
-  MyClass::reset();
-
-  Module m = define_module("TestingModule");
-
-  std::string code = R"(factory = Factory.new
-                        my_class = factory.share
-                        my_class.set_flag(8)
-                        extract_flag_shared_ptr(my_class))";
-
-  Object result = m.module_eval(code);
-  ASSERT_EQUAL(8, detail::From_Ruby<int>().convert(result));
-}
-
-TESTCASE(SharedPtrRefParameter)
-{
-  MyClass::reset();
-
-  Module m = define_module("TestingModule");
-
-  std::string code = R"(factory = Factory.new
-                        my_class = factory.share
-                        my_class.set_flag(9)
-                        extract_flag_shared_ptr_ref(my_class))";
-
-  Object result = m.module_eval(code);
-  ASSERT_EQUAL(9, detail::From_Ruby<int>().convert(result));
-}
-
-TESTCASE(SharedPtrDefaultParameter)
-{
-  MyClass::reset();
-
-  Module m = define_module("TestingModule");
-
-  std::string code = R"(factory = Factory.new
-                        my_class = factory.share
-                        my_class.set_flag(7)
-                        extract_flag_shared_ptr_with_default())";
-
-  Object result = m.module_eval(code);
-  // The default value kicks in and ignores any previous pointer
-  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
-}
-
-TESTCASE(SharedPtrRefDefaultParameter)
-{
-  MyClass::reset();
-
-  Module m = define_module("TestingModule");
-
-  std::string code = R"(factory = Factory.new
-                        my_class = factory.share
-                        my_class.set_flag(7)
-                        extract_flag_shared_ptr_ref_with_default())";
-
-  Object result = m.module_eval(code);
-  // The default value kicks in and ignores any previous pointer
-  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
-}