rice 3.0.0 → 4.0.0

data/rice/detail/Wrapper.hpp

@@ -0,0 +1,51 @@
+#ifndef Rice__detail__Wrapper__hpp_
+#define Rice__detail__Wrapper__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+namespace detail
+{
+
+class Wrapper
+{
+public:
+  virtual ~Wrapper() = default;
+  virtual void* get() = 0;
+
+  void ruby_mark();
+  void addKeepAlive(VALUE value);
+
+private:
+  // We use a vector for speed and memory locality versus a set which does
+  // not scale well when getting to tens of thousands of objects (not expecting
+  // that to happen...but just in case)
+  std::vector<VALUE> keepAlive_;
+};
+
+template <typename T, typename Wrapper_T = void>
+VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T& data, bool isOwner);
+
+template <typename T, typename Wrapper_T = void>
+VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T* data, bool isOwner);
+
+template <typename T>
+T* unwrap(VALUE value, rb_data_type_t* rb_type);
+
+Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type);
+
+void* unwrap(VALUE value);
+
+template <typename T>
+void replace(VALUE value, rb_data_type_t* rb_type, T* data, bool isOwner);
+
+Wrapper* getWrapper(VALUE value);
+
+} // namespace detail
+} // namespace Rice
+
+#include "Wrapper.ipp"
+
+#endif // Rice__detail__Wrapper__hpp_
+

data/rice/detail/Wrapper.ipp

@@ -0,0 +1,151 @@
+#include <memory>
+
+namespace Rice::detail
+{
+  inline void Wrapper::ruby_mark()
+  {
+    for (VALUE value : this->keepAlive_)
+    {
+      rb_gc_mark(value);
+    }
+  }
+
+  inline void Wrapper::addKeepAlive(VALUE value)
+  {
+    this->keepAlive_.push_back(value);
+  }
+
+  template <typename T>
+  class WrapperValue : public Wrapper
+  {
+  public:
+    WrapperValue(T& data): data_(std::move(data))
+    {
+    }
+
+    void* get() override
+    {
+      return (void*)&this->data_;
+    }
+
+  private:
+    T data_;
+  };
+
+  template <typename T>
+  class WrapperReference : public Wrapper
+  {
+  public:
+    WrapperReference(const T& data): data_(data)
+    {
+    }
+
+    void* get() override
+    {
+      return (void*)&this->data_;
+    }
+
+  private:
+    const T& data_;
+  };
+
+  template <typename T>
+  class WrapperPointer : public Wrapper
+  {
+  public:
+    WrapperPointer(T* data, bool isOwner) : data_(data), isOwner_(isOwner)
+    {
+    }
+
+    ~WrapperPointer()
+    {
+      if (this->isOwner_)
+      {
+        delete this->data_;
+      }
+    }
+
+    void* get() override
+    {
+      return (void*)this->data_;
+    }
+
+  private:
+    T* data_ = nullptr;
+    bool isOwner_ = false;
+  };
+
+  // ---- Helper Functions -------
+  template <typename T, typename Wrapper_T>
+  inline VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T& data, bool isOwner)
+  {
+    if constexpr (!std::is_void_v<Wrapper_T>)
+    {
+      Wrapper_T* wrapper = new Wrapper_T(data);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+    else if (isOwner)
+    {
+      WrapperValue<T>* wrapper = new WrapperValue<T>(data);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+    else
+    {
+      WrapperReference<T>* wrapper = new WrapperReference<T>(data);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+  };
+
+  template <typename T, typename Wrapper_T>
+  inline VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T* data, bool isOwner)
+  {
+    if constexpr (!std::is_void_v<Wrapper_T>)
+    {
+      Wrapper_T* wrapper = new Wrapper_T(data);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+    else
+    {
+      WrapperPointer<T>* wrapper = new WrapperPointer<T>(data, isOwner);
+      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+    }
+  };
+
+  template <typename T>
+  inline T* unwrap(VALUE value, rb_data_type_t* rb_type)
+  {
+    Wrapper* wrapper = getWrapper(value, rb_type);
+    TypedData_Get_Struct(value, Wrapper, rb_type, wrapper);
+    return static_cast<T*>(wrapper->get());
+  }
+
+  inline void* unwrap(VALUE value)
+  {
+    // Direct access to avoid any type checking
+    Wrapper* wrapper = (Wrapper*)RTYPEDDATA_DATA(value);
+    return wrapper->get();
+  }
+
+  inline Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type)
+  {
+    Wrapper* wrapper = nullptr;
+    TypedData_Get_Struct(value, Wrapper, rb_type, wrapper);
+    return wrapper;
+  }
+
+  template <typename T>
+  inline void replace(VALUE value, rb_data_type_t* rb_type, T* data, bool isOwner)
+  {
+    WrapperPointer<T>* wrapper = nullptr;
+    TypedData_Get_Struct(value, WrapperPointer<T>, rb_type, wrapper);
+    delete wrapper;
+
+    wrapper = new WrapperPointer<T>(data, true);
+    RTYPEDDATA_DATA(value) = wrapper;
+  }
+
+  inline Wrapper* getWrapper(VALUE value)
+  {
+    return static_cast<Wrapper*>(RTYPEDDATA_DATA(value));
+  }
+} // namespace

data/rice/detail/default_allocation_func.hpp

@@ -1,23 +1,12 @@
 #ifndef Rice__detail__default_allocation_func__hpp_
 #define Rice__detail__default_allocation_func__hpp_
 
-namespace Rice
+namespace Rice::detail
 {
-
-namespace detail
-{
-
-//! A default implementation of an allocate_func.  This function does no
-//! actual allocation; the initialize_func can later do the real
-//! allocation with: DATA_PTR(self) = new Type(arg1, arg2, ...)
-template<typename T>
-VALUE default_allocation_func(VALUE klass);
-
-} // detail
-
-} // Rice
-
-#include "default_allocation_func.ipp"
-
-#endif // Rice__detail__default_allocation_func__hpp_
-
+  //! A default implementation of an allocate_func.  This function does no
+  //! actual allocation; the initialize_func can later do the real
+  //! allocation with: DATA_PTR(self) = new Type(arg1, arg2, ...)
+  template<typename T>
+  VALUE default_allocation_func(VALUE klass);
+}
+#endif // Rice__detail__default_allocation_func__hpp_

data/rice/detail/default_allocation_func.ipp

@@ -1,11 +1,12 @@
 #include "../Data_Object.hpp"
 
-template<typename T>
-VALUE Rice::detail::
-default_allocation_func(VALUE klass)
+namespace Rice::detail
 {
-  Data_Object<T> m(static_cast<T*>(0), klass);
-  return m.value();
-} 
-
-
+  template<typename T>
+  VALUE default_allocation_func(VALUE klass)
+  {
+    // Create a new Ruby object but since we do not yet have a C++ object
+    // just pass a nullptr. It will be set via the Constructor call
+    return TypedData_Wrap_Struct(klass, Data_Type<T>::rb_type(), nullptr);
+  }
+}

data/rice/detail/from_ruby.hpp

@@ -1,43 +1,8 @@
 #ifndef Rice__detail__from_ruby__hpp_
 #define Rice__detail__from_ruby__hpp_
 
-namespace Rice
-{
-  namespace detail
-  {
-    template<typename T>
-    struct from_ruby_
-    {
-      typedef T Retval_T;
-
-      static T convert(Rice::Object x);
-    };
-
-    template<typename T>
-    struct from_ruby_<T *>
-    {
-      typedef T * Retval_T;
-
-      static T * convert(Rice::Object x);
-    };
-
-    template<typename T>
-    struct from_ruby_<T const *>
-    {
-      typedef T const * Retval_T;
-
-      static T const * convert(Rice::Object x);
-    };
-
-    template<typename T>
-    struct from_ruby_<T &>
-    {
-      typedef T & Retval_T;
-
-      static T & convert(Rice::Object x);
-    };
-  } // detail
-} // Rice
+#include "from_ruby_defn.hpp"
+#include "from_ruby.ipp"
 
 #endif // Rice__detail__from_ruby__hpp_
 

data/rice/detail/from_ruby.ipp

@@ -1,60 +1,1034 @@
 #ifndef Rice__detail__from_ruby__ipp_
 #define Rice__detail__from_ruby__ipp_
 
-#include "../Data_Type.hpp"
-#include "../String.hpp"
-#include "demangle.hpp"
-#include <typeinfo>
-
-template<typename T>
-T Rice::detail::from_ruby_<T>::
-convert(Rice::Object x)
+#include <optional>
+#include <stdexcept>
+#include "../Exception_defn.hpp"
+#include "../Arg.hpp"
+#include "RubyFunction.hpp"
+
+/* This file implements conversions from Ruby to native values fo fundamental types 
+   such as bool, int, float, etc. It also includes conversions for chars and strings */
+namespace Rice::detail
 {
-  if(rb_type(x.value()) == T_DATA)
+  // ===========  short  ============
+  template<>
+  class From_Ruby<short>
   {
-    return *Data_Type<T>::from_ruby(x);
-  }
-  else
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    short convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<short>();
+      }
+      else
+      {
+        return protect(rb_num2short_inline, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<short&>
   {
-    std::string s("Unable to convert ");
-    s += x.class_of().name().c_str();
-    s += " to ";
-    s += demangle(typeid(T).name());
-    throw std::invalid_argument(s.c_str());
-  }
-}
+  public:
+    From_Ruby() = default;
 
-template<typename T>
-T * Rice::detail::from_ruby_<T *>::
-convert(Rice::Object x)
-{
-  if(rb_type(x.value()) == T_DATA)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    short& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<short>();
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2short_inline, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    short converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<short*>
   {
-    return Data_Type<T>::from_ruby(x);
-  }
-  else
+  public:
+    short* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2short_inline, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    short converted_ = 0;
+  };
+
+  // ===========  int  ============
+  template<>
+  class From_Ruby<int>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    int convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<int>();
+      }
+      else
+      {
+        return (int)protect(rb_num2long_inline, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<int&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    int& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<int>();
+      }
+      else
+      {
+        this->converted_ = (int)protect(rb_num2long_inline, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    int converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<int*>
+  {
+  public:
+    int* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = (int)protect(rb_num2long_inline, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    int converted_;
+  };
+
+  // ===========  long  ============
+  template<>
+  class From_Ruby<long>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    long convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<long>();
+      }
+      else
+      {
+        return protect(rb_num2long_inline, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<long&>
   {
-    std::string s("Unable to convert ");
-    s += x.class_of().name().c_str();
-    s += " to ";
-    s += demangle(typeid(T *).name());
-    throw std::invalid_argument(s.c_str());
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    long& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<long>();
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2long_inline, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    long converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<long*>
+  {
+  public:
+    long* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2long_inline, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    long converted_ = 0;
+  };
+
+  // ===========  long long  ============
+  template<>
+  class From_Ruby<long long>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    long long convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<long long>();
+      }
+      else
+      {
+        return protect(rb_num2ll_inline, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<long long&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    long long& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<long long>();
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2ll_inline, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    long long converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<long long*>
+  {
+  public:
+    long long* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2ll_inline, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    long long converted_ = 0;
+  };
+
+  // ===========  unsigned short  ============
+  template<>
+  class From_Ruby<unsigned short>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    unsigned short convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned short>();
+      }
+      else
+      {
+        return protect(rb_num2ushort, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned short&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    unsigned short& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned short>();
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2ushort, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    unsigned short converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<unsigned short*>
+  {
+  public:
+    unsigned short* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2ushort, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    unsigned short converted_ = 0;
+  };
+
+  // ===========  unsigned int  ============
+  template<>
+  class From_Ruby<unsigned int>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    unsigned int convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned int>();
+      }
+      else
+      {
+        return (unsigned int)protect(rb_num2ulong_inline, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned int&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    unsigned int& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned int>();
+      }
+      else
+      {
+        this->converted_ = (unsigned int)protect(rb_num2ulong_inline, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    unsigned int converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<unsigned int*>
+  {
+  public:
+    unsigned int* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = (unsigned int)protect(rb_num2ulong_inline, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    unsigned int converted_ = 0;
+  };
+
+  // ===========  unsigned long  ============
+  template<>
+  class From_Ruby<unsigned long>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    unsigned long convert(VALUE value)
+    {
+      if (this->arg_ && this->arg_->getIsValue())
+      {
+        return (unsigned long)value;
+      }
+      else if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned long>();
+      }
+      else
+      {
+        return protect(rb_num2ulong_inline, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned long&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    unsigned long& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned long>();
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2ulong_inline, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    unsigned long converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<unsigned long*>
+  {
+  public:
+    unsigned long* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2ulong_inline, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    unsigned long converted_ = 0;
+  };
+
+  // ===========  unsigned long long  ============
+  template<>
+  class From_Ruby<unsigned long long>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    unsigned long long convert(VALUE value)
+    {
+      if (this->arg_ && this->arg_->getIsValue())
+      {
+        return value;
+      }
+      else if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned long long>();
+      }
+      else
+      {
+        return protect(rb_num2ull, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<unsigned long long&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    unsigned long long& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned long long>();
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2ull, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    unsigned long long converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<unsigned long long*>
+  {
+  public:
+    unsigned long long* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2ull, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    unsigned long long converted_ = 0;
+  };
+
+  // ===========  bool  ============
+  template<>
+  class From_Ruby<bool>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    bool convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<bool>();
+      }
+      else
+      {
+        return RTEST(value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<bool&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    bool& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<bool>();
+      }
+      else
+      {
+        this->converted_ = RTEST(value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    bool converted_ = false;
+  };
+
+  template<>
+  class From_Ruby<bool*>
+  {
+  public:
+    bool* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = RTEST(value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    bool converted_ = false;
+  };
+
+  // ===========  char  ============
+  template<typename T>
+  inline T charFromRuby(VALUE value)
+  {
+    switch (rb_type(value))
+    {
+      case T_STRING:
+      {
+        if (RSTRING_LEN(value) == 1)
+        {
+          return RSTRING_PTR(value)[0];
+        }
+        else
+        {
+          throw std::invalid_argument("from_ruby<char>: string must have length 1");
+        }
+        break;
+      }
+      case T_FIXNUM:
+      {
+        return From_Ruby<long>().convert(value) & 0xff;
+        break;
+      }
+      default:
+      {
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+          detail::protect(rb_obj_classname, value), "char type");
+      }
+    }
   }
-}
+  
+  template<>
+  class From_Ruby<char>
+  {
+  public:
+    From_Ruby() = default;
 
-template<typename T>
-T const * Rice::detail::from_ruby_<T const *>::
-convert(Rice::Object x)
-{
-  return from_ruby<T *>(x);
-}
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
 
-template<typename T>
-T & Rice::detail::from_ruby_<T &>::
-convert(Rice::Object x)
-{
-  return *from_ruby<T *>(x);
-}
+    char convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<char>();
+      }
+      else
+      {
+        return charFromRuby<char>(value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
 
-#endif // Rice__detail__from_ruby__ipp_
+  template<>
+  class From_Ruby<char&>
+  {
+  public:
+    From_Ruby() = default;
 
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    char& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<char>();
+      }
+      else
+      {
+        this->converted_ = charFromRuby<char>(value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    char converted_ = 0;
+  };
+
+  template<>
+  class From_Ruby<char*>
+  {
+  public:
+    char* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        detail::protect(rb_check_type, value, (int)T_STRING);
+        return RSTRING_PTR(value);
+      }
+    }
+  };
+  
+  // This is mostly for testing. NativeFunction removes const before calling From_Ruby
+  template<>
+  class From_Ruby<char const*>
+  {
+  public:
+    char const* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        detail::protect(rb_check_type, value, (int)T_STRING);
+        return RSTRING_PTR(value);
+      }
+    }
+  };
+
+  // ===========  unsinged char  ============
+  template<>
+  class From_Ruby<unsigned char>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    unsigned char convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<unsigned char>();
+      }
+      else
+      {
+        return charFromRuby<unsigned char>(value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  // ===========  signed char  ============
+  template<>
+  class From_Ruby<signed char>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    signed char convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<signed char>();
+      }
+      else
+      {
+        return charFromRuby<signed char>(value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  // ===========  double  ============
+  template<>
+  class From_Ruby<double>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    double convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<double>();
+      }
+      else
+      {
+        return protect(rb_num2dbl, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<double&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    double& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<double>();
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2dbl, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    double converted_;
+  };
+
+  template<>
+  class From_Ruby<double*>
+  {
+  public:
+    double* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = protect(rb_num2dbl, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    double converted_;
+  };
+
+  // ===========  float  ============
+  template<>
+  class From_Ruby<float>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    float convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<float>();
+      }
+      else
+      {
+        return (float)protect(rb_num2dbl, value);
+      }
+    }
+  
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<float&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    float& convert(VALUE value)
+    {
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->defaultValue<float>();
+      }
+      else
+      {
+        this->converted_ = (float)protect(rb_num2dbl, value);
+        return this->converted_;
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    float converted_;
+  };
+
+  template<>
+  class From_Ruby<float*>
+  {
+  public:
+    float* convert(VALUE value)
+    {
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        this->converted_ = (float)protect(rb_num2dbl, value);
+        return &this->converted_;
+      }
+    }
+
+  private:
+    float converted_;
+  };
+}
+#endif // Rice__detail__from_ruby__ipp_