rice 3.0.0 → 4.0.0

data/rice/Arg.ipp

@@ -0,0 +1,51 @@
+namespace Rice
+{
+  inline Arg::Arg(std::string name) : name(name)
+  {
+  }
+
+  template<typename Arg_Type>
+  inline Arg& Arg::operator=(Arg_Type val)
+  {
+    this->defaultValue_ = val;
+    return *this;
+  }
+
+  //! Check if this Arg has a default value associated with it
+  inline bool Arg::hasDefaultValue() const
+  {
+    return this->defaultValue_.has_value();
+  }
+
+  //! Return a reference to the default value associated with this Arg
+  /*! \return the type saved to this Arg
+    */
+  template<typename Arg_Type>
+  inline Arg_Type& Arg::defaultValue()
+  {
+    return std::any_cast<Arg_Type&>(this->defaultValue_);
+  }
+
+  inline Arg& Arg::keepAlive()
+  {
+    this->isKeepAlive = true;
+    return *this;
+  }
+
+  inline Arg& Arg::isValue()
+  {
+    isValue_ = true;
+    return *this;
+  }
+
+  inline bool Arg::getIsValue()
+  {
+    return isValue_;
+  }
+
+  // Function to overload the, operator
+  inline Arg Arg::operator,(const Arg& other)
+  {
+    throw std::runtime_error("The Arg class no longer supports the comma operator, please remove the surounding parentheses");
+  }
+} // Rice

data/rice/Constructor.hpp

@@ -1,10 +1,8 @@
 #ifndef Rice__Constructor__hpp_
 #define Rice__Constructor__hpp_
 
-// This causes problems with certain C++ libraries
-#undef TYPE
-
-#include "to_from_ruby_defn.hpp"
+#include "detail/Wrapper.hpp"
+#include "cpp_api/Object_defn.hpp"
 
 namespace Rice
 {
@@ -21,27 +19,27 @@ namespace Rice
   *
   *  For more information, see Rice::Data_Type::define_constructor.
   */
-  template<typename T, typename ...Arg_T>
+  template<typename T, typename...Arg_Ts>
   class Constructor
   {
   public:
-    static void construct(Object self, Arg_T... args)
+    static void construct(VALUE self, Arg_Ts...args)
     {
-      DATA_PTR(self.value()) = new T(args...);
+      T* data = new T(args...);
+      detail::replace<T>(self, Data_Type<T>::rb_type(), data, true);
     }
   };
 
   //! Special-case Constructor used when defining Directors.
-  template<typename T, typename ...Arg_T>
-  class Constructor<T, Object, Arg_T...>
+  template<typename T, typename...Arg_Ts>
+  class Constructor<T, Object, Arg_Ts...>
   {
     public:
-      static void construct(Object self, Arg_T... args)
+      static void construct(Object self, Arg_Ts...args)
       {
-        DATA_PTR(self.value()) = new T(self, args...);
+        T* data = new T(self, args...);
+        detail::replace<T>(self.value(), Data_Type<T>::rb_type(), data, true);
       }
   };
 }
-
-#endif
-
+#endif // Rice__Constructor__hpp_

data/rice/Data_Object.ipp

@@ -1,133 +1,260 @@
 #ifndef Rice__Data_Object__ipp_
 #define Rice__Data_Object__ipp_
 
-#include "detail/check_ruby_type.hpp"
-#include "protect.hpp"
+#include "Data_Type_defn.hpp"
 
 #include <algorithm>
 
-template<typename T>
-const typename Rice::Default_Mark_Function<T>::Ruby_Data_Func
-Rice::Default_Mark_Function<T>::mark = ruby_mark<T>;
-
 namespace Rice
 {
+  template <typename T>
+  Exception create_type_exception(VALUE value)
+  {
+    return Exception(rb_eTypeError, "Wrong argument type. Expected: %s. Received: %s.",
+      detail::protect(rb_class2name, Data_Type<T>::klass().value()),
+      detail::protect(rb_obj_classname, value));
+  }
 
-namespace detail
-{
+  template<typename T>
+  inline Data_Object<T>::Data_Object(T& data, bool isOwner, Class klass)
+  {
+    VALUE value = detail::wrap(klass, Data_Type<T>::rb_type(), data, isOwner);
+    this->set_value(value);
+  }
 
-inline VALUE data_wrap_struct(
-    VALUE klass,
-    RUBY_DATA_FUNC mark,
-    RUBY_DATA_FUNC free,
-    void * obj)
-{
-  return Data_Wrap_Struct(klass, mark, free, obj);
-}
+  template<typename T>
+  inline Data_Object<T>::Data_Object(T* data, bool isOwner, Class klass)
+  {
+    VALUE value = detail::wrap(klass, Data_Type<T>::rb_type(), data, isOwner);
+    this->set_value(value);
+  }
 
-template<typename T>
-inline VALUE wrap(
-    VALUE klass,
-    typename Data_Object<T>::Ruby_Data_Func mark,
-    typename Data_Object<T>::Ruby_Data_Func free,
-    T * obj)
-{
-  // We cast to obj void* here before passing to Data_Wrap_Struct,
-  // becuase otherwise compilation will fail if obj is const.  It's safe
-  // to do this, because unwrap() will always add the const back when
-  // the object is unwrapped.
-  return Rice::protect(data_wrap_struct,
-      klass,
-      reinterpret_cast<RUBY_DATA_FUNC>(mark),
-      reinterpret_cast<RUBY_DATA_FUNC>(free),
-      (void *)obj);
-}
+  template<typename T>
+  inline Data_Object<T>::Data_Object(Object value) : Object(value)
+  {
+    Data_Type<T> klass;
+    check_ruby_type(value);
+  }
 
-template<typename T>
-inline VALUE data_get_struct(VALUE value, T * * obj)
-{
-  Data_Get_Struct(value, T, *obj);
-  return Qnil;
+  template<typename T>
+  template<typename U>
+  inline Data_Object<T>::Data_Object(Object value) : Object(value)
+  {
+    check_ruby_type(value);
+  }
+
+  template<typename T>
+  inline void Data_Object<T>::check_ruby_type(VALUE value)
+  {
+    if (rb_obj_is_kind_of(value, Data_Type<T>::klass()) == Qfalse)
+    {
+      throw create_type_exception<T>(value);
+    }
+  }
+
+  template<typename T>
+  inline T& Data_Object<T>::operator*() const
+  {
+    return *this->get();
+  }
+
+  template<typename T>
+  inline T* Data_Object<T>::operator->() const
+  {
+    return this->get();
+  }
+
+  template<typename T>
+  inline T* Data_Object<T>::get() const
+  {
+    if (this->value() == Qnil)
+    {
+      return nullptr;
+    }
+    else
+    {
+      return detail::unwrap<T>(this->value(), Data_Type<T>::rb_type());
+    }
+  }
+
+  template<typename T>
+  inline T* Data_Object<T>::from_ruby(VALUE value)
+  {
+    if (Data_Type<T>::is_descendant(value))
+    {
+      return detail::unwrap<T>(value, Data_Type<T>::rb_type());
+    }
+    else
+    {
+      throw create_type_exception<T>(value);
+    }
+  }
 }
 
-template<typename T>
-inline T * unwrap(VALUE value)
+namespace Rice::detail
 {
-  T * obj;
-  Rice::protect(data_get_struct<T>, value, &obj);
-  return obj;
-}
+  template<typename T>
+  class To_Ruby
+  {
+  public:
+    VALUE convert(T& data)
+    {
+      // Get the ruby typeinfo
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::TypeRegistry::figureType<T>(data);
 
-} // namespace detail
+      // We always take ownership of data passed by value (yes the parameter is T& but the template
+      // matched <typename T> thus we have to tell wrap to copy the reference we are sending to it
+      return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+    }
+  };
 
-} // namespace Rice
+  template <typename T>
+  class To_Ruby<T&>
+  {
+  public:
+    To_Ruby() = default;
 
-template<typename T>
-inline Rice::Data_Object<T>::
-Data_Object(
-    T * obj,
-    VALUE klass,
-    Ruby_Data_Func mark_func,
-    Ruby_Data_Func free_func)
-  : Object(detail::wrap(klass, mark_func, free_func, obj))
-  , obj_(obj)
-{
-}
+    explicit To_Ruby(Return * returnInfo) : returnInfo_(returnInfo)
+    {
+    }
 
-template<typename T>
-inline Rice::Data_Object<T>::
-Data_Object(
-    Object value)
-  : Object(value)
-  , obj_(detail::unwrap<T>(value))
-{  
-  Data_Type<T> klass;
-  check_cpp_type(klass);
-  detail::check_ruby_type(value, klass, true);
-}
+    VALUE convert(T& data)
+    {
+      // Note that T could be a pointer or reference to a base class while data is in fact a
+      // child class. Lookup the correct type so we return an instance of the correct Ruby class
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::TypeRegistry::figureType<T>(data);
 
-template<typename T>
-template<typename U>
-inline Rice::Data_Object<T>::
-Data_Object(
-    Object value,
-    Data_Type<U> const & klass)
-  : Object(value)
-  , obj_(detail::unwrap<T>(value))
-{  
-  check_cpp_type(klass);
-  detail::check_ruby_type(value, klass, true);
-}
+      bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+      return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+    }
 
-template<typename T>
-inline Rice::Data_Object<T>::
-Data_Object(Data_Object const & other)
-  : Object(other.value())
-  , obj_(other.obj_)
-{
-}
+  private:
+    Return* returnInfo_ = nullptr;
+  };
 
-template<typename T>
-template<typename U>
-inline void Rice::Data_Object<T>::
-swap(Data_Object<U> & ref)
-{
-  std::swap(obj_, ref.obj_);
-  Object::swap(ref);
-}
+  template <typename T>
+  class To_Ruby<T*>
+  {
+  public:
+    To_Ruby() = default;
 
-template<typename T>
-inline void Rice::Data_Object<T>::
-check_cpp_type(Data_Type<T> const & /* klass */)
-{
-}
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
 
-template<typename T>
-Rice::Object Rice::detail::to_ruby_<Rice::Data_Object<T> >::
-convert(Rice::Data_Object<T> const & x)
-{
-  return x;
-}
+    VALUE convert(const T* data)
+    {
+      if (data)
+      {
+        // Note that T could be a pointer or reference to a base class while data is in fact a
+        // child class. Lookup the correct type so we return an instance of the correct Ruby class
+        std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::TypeRegistry::figureType(*data);
+        bool isOwner = this->returnInfo_ && this->returnInfo_->isOwner();
+        return detail::wrap(rubyTypeInfo.first, rubyTypeInfo.second, data, isOwner);
+      }
+      else
+      {
+        return Qnil;
+      }
+    }
+
+  private:
+    Return* returnInfo_ = nullptr;
+  };
+
+  template<typename T>
+  class To_Ruby<Data_Object<T>>
+  {
+  public:
+    VALUE convert(const Object& x)
+    {
+      return x.value();
+    }
+  };
+
+  template <typename T>
+  class From_Ruby
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg * arg) : arg_(arg)
+    {
+    }
+    
+    T convert(VALUE value)
+    {
+      using Intrinsic_T = intrinsic_type<T>;
 
-#endif // Rice__Data_Object__ipp_
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->template defaultValue<Intrinsic_T>();
+      }
+      else
+      {
+        return *Data_Object<Intrinsic_T>::from_ruby(value);
+      }
+    }
 
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<typename T>
+  class From_Ruby<T&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg * arg) : arg_(arg)
+    {
+    }
+
+    T& convert(VALUE value)
+    {
+      using Intrinsic_T = intrinsic_type<T>;
+
+      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
+      {
+        return this->arg_->template defaultValue<Intrinsic_T>();
+      }
+      else
+      {
+        return *Data_Object<Intrinsic_T>::from_ruby(value);
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<typename T>
+  class From_Ruby<T*>
+  {
+  public:
+    T* convert(VALUE value)
+    {
+      using Intrinsic_T = intrinsic_type<T>;
+
+      if (value == Qnil)
+      {
+        return nullptr;
+      }
+      else
+      {
+        return Data_Object<Intrinsic_T>::from_ruby(value);
+      }
+    }
+  };
+
+  template<typename T>
+  class From_Ruby<Data_Object<T>>
+  {
+  public:
+    static Data_Object<T> convert(VALUE value)
+    {
+      return Data_Object<T>(value);
+    }
+  };
+}
+#endif // Rice__Data_Object__ipp_