rice 2.1.1 → 4.0.0

data/rice/Data_Type.hpp

@@ -4,5 +4,4 @@
 #include "Data_Type_defn.hpp"
 #include "Data_Type.ipp"
 
-#endif // Rice__Data_Type__hpp_
-
+#endif // Rice__Data_Type__hpp_

data/rice/Data_Type.ipp

@@ -1,365 +1,321 @@
 #ifndef Rice__Data_Type__ipp_
 #define Rice__Data_Type__ipp_
 
+#include "detail/method_data.hpp"
+#include "detail/NativeAttribute.hpp"
+#include "detail/default_allocation_func.hpp"
+#include "detail/TypeRegistry.hpp"
+#include "detail/Wrapper.hpp"
+#include "detail/Iterator.hpp"
 #include "Class.hpp"
 #include "String.hpp"
-#include "Data_Object.hpp"
-#include "detail/default_allocation_func.hpp"
-#include "detail/creation_funcs.hpp"
-#include "detail/method_data.hpp"
-#include "detail/Caster.hpp"
-#include "detail/demangle.hpp"
 
 #include <stdexcept>
-#include <typeinfo>
 
-template<typename T>
-VALUE Rice::Data_Type<T>::klass_ = Qnil;
+namespace Rice
+{
+  template<typename T>
+  void ruby_mark_internal(detail::Wrapper* wrapper)
+  {
+    // Tell the wrapper to mark the objects its keeping alive
+    wrapper->ruby_mark();
 
-template<typename T>
-std_unique_ptr<Rice::detail::Abstract_Caster> Rice::Data_Type<T>::caster_;
+    // Get the underlying data and call custom mark function (if any)
+    T* data = static_cast<T*>(wrapper->get());
+    ruby_mark<T>(data);
+  }
 
-template<typename T>
-template<typename Base_T>
-inline Rice::Data_Type<T> Rice::Data_Type<T>::
-bind(Module const & klass)
-{
-  if(klass.value() == klass_)
+  template<typename T>
+  void ruby_free_internal(detail::Wrapper* wrapper)
   {
-    return Data_Type<T>();
+    delete wrapper;
   }
 
-  if(is_bound())
+  template<typename T>
+  size_t ruby_size_internal(const T* data)
   {
-    std::string s;
-    s = "Data type ";
-    s += detail::demangle(typeid(T).name());
-    s += " is already bound to a different type";
-    throw std::runtime_error(s.c_str());
+    return sizeof(T);
   }
 
-  // TODO: Make sure base type is bound; throw an exception otherwise.
-  // We can't do this just yet, because we don't have a specialization
-  // for binding to void.
-  klass_ = klass;
+  template<typename T>
+  template <typename Base_T>
+  inline Data_Type<T> Data_Type<T>::bind(Module const& klass)
+  {
+    if (is_bound())
+    {
+      std::string message = "Type " + detail::typeName(typeid(T)) + " is already bound to a different type";
+      throw std::runtime_error(message.c_str());
+    }
+
+    klass_ = klass;
 
-  // TODO: do we need to unregister when the program exits?  we have to
-  // be careful if we do, because the ruby interpreter might have
-  // already shut down.  The correct behavior is probably to register an
-  // exit proc with the interpreter, so the proc gets called before the
-  // GC shuts down.
-  rb_gc_register_address(&klass_);
+    rb_type_ = new rb_data_type_t();
+    rb_type_->wrap_struct_name = strdup(Rice::detail::protect(rb_class2name, klass_));
+    rb_type_->function.dmark = reinterpret_cast<void(*)(void*)>(&Rice::ruby_mark_internal<T>);
+    rb_type_->function.dfree = reinterpret_cast<void(*)(void*)>(&Rice::ruby_free_internal<T>);
+    rb_type_->function.dsize = reinterpret_cast<size_t(*)(const void*)>(&Rice::ruby_size_internal<T>);
+    rb_type_->data = nullptr;
+    rb_type_->flags = RUBY_TYPED_FREE_IMMEDIATELY;
 
-  for(typename Instances::iterator it = unbound_instances().begin(),
+    if constexpr (!std::is_void_v<Base_T>)
+    {
+      rb_type_->parent = Data_Type<Base_T>::rb_type();
+    }
+
+    // Now register with the type registry
+    detail::TypeRegistry::add<T>(klass_, rb_type_);
+
+    for (typename Instances::iterator it = unbound_instances().begin(),
       end = unbound_instances().end();
       it != end;
       unbound_instances().erase(it++))
+    {
+      (*it)->set_value(klass);
+    }
+
+    return Data_Type<T>();
+  }
+
+  template<typename T>
+  inline void Data_Type<T>::unbind()
   {
-    (*it)->set_value(klass);
+    detail::TypeRegistry::remove<T>();
+
+    if (klass_ != Qnil)
+    {
+      klass_ = Qnil;
+    }
+
+    // There could be objects floating around using the existing rb_type so 
+    // do not delete it. This is of course a memory leak.
+    rb_type_ = nullptr;
   }
 
-  detail::Abstract_Caster * base_caster = Data_Type<Base_T>().caster();
-  caster_.reset(new detail::Caster<T, Base_T>(base_caster, klass));
-  Data_Type_Base::casters().insert(std::make_pair(klass, caster_.get()));
-  return Data_Type<T>();
-}
+  template<typename T>
+  inline Data_Type<T>::Data_Type() : Class(klass_ == Qnil ? rb_cObject : klass_)
+  {
+    if (!is_bound())
+    {
+      unbound_instances().insert(this);
+    }
+  }
 
-template<typename T>
-inline Rice::Data_Type<T>::
-Data_Type()
-  : Module_impl<Data_Type_Base, Data_Type<T> >(
-      klass_ == Qnil ? rb_cObject : klass_)
-{
-  if(!is_bound())
+  template<typename T>
+  inline Data_Type<T>::Data_Type(Module const& klass) : Class(klass)
   {
-    unbound_instances().insert(this);
+    this->bind(klass);
   }
-}
 
-template<typename T>
-inline Rice::Data_Type<T>::
-Data_Type(Module const & klass)
-  : Module_impl<Data_Type_Base, Data_Type<T> >(
-      klass)
-{
-  this->bind<void>(klass);
-}
+  template<typename T>
+  inline Data_Type<T>::~Data_Type()
+  {
+    unbound_instances().erase(this);
+  }
 
-template<typename T>
-inline Rice::Data_Type<T>::
-~Data_Type()
-{
-  unbound_instances().erase(this);
-}
+  template<typename T>
+  inline rb_data_type_t* Data_Type<T>::rb_type()
+  {
+    check_is_bound();
+    return rb_type_;
+  }
 
-template<typename T>
-Rice::Module
-Rice::Data_Type<T>::
-klass() {
-  if(is_bound())
+  template<typename T>
+  inline Class Data_Type<T>::klass()
   {
+    check_is_bound();
     return klass_;
   }
-  else
+
+  template<typename T>
+  inline Data_Type<T>& Data_Type<T>::operator=(Module const& klass)
   {
-    std::string s;
-    s += detail::demangle(typeid(T *).name());
-    s += " is unbound";
-    throw std::runtime_error(s.c_str());
+    this->bind(klass);
+    return *this;
   }
-}
 
-template<typename T>
-Rice::Data_Type<T> & Rice::Data_Type<T>::
-operator=(Module const & klass)
-{
-  this->bind<void>(klass);
-  return *this;
-}
-
-template<typename T>
-template<typename Constructor_T>
-inline Rice::Data_Type<T> & Rice::Data_Type<T>::
-define_constructor(
-    Constructor_T /* constructor */,
-    Arguments* arguments)
-{
-  check_is_bound();
-
-  // Normal constructor pattern with new/initialize
-  rb_define_alloc_func(
-      static_cast<VALUE>(*this),
-      detail::default_allocation_func<T>);
-  this->define_method(
-      "initialize",
-      &Constructor_T::construct,
-      arguments
-      );
-
-  return *this;
-}
+  template<typename T>
+  template<typename Constructor_T>
+  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T, MethodInfo* methodInfo)
+  {
+    check_is_bound();
 
-template<typename T>
-template<typename Constructor_T>
-inline Rice::Data_Type<T> & Rice::Data_Type<T>::
-define_constructor(
-    Constructor_T constructor,
-    Arg const& arg)
-{
-  Arguments* args = new Arguments();
-  args->add(arg);
-  return define_constructor(constructor, args);
-}
+    // Normal constructor pattern with new/initialize
+    detail::protect(rb_define_alloc_func, static_cast<VALUE>(*this), detail::default_allocation_func<T>);
+    this->define_method("initialize", &Constructor_T::construct, methodInfo);
 
+    return *this;
+  }
 
-template<typename T>
-template<typename Director_T>
-inline Rice::Data_Type<T>& Rice::Data_Type<T>::
-define_director()
-{
-  Rice::Data_Type<Director_T>::template bind<T>(*this);
-  return *this;
-}
+  template<typename T>
+  template<typename Constructor_T, typename...Arg_Ts>
+  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T constructor, Arg_Ts const& ...args)
+  {
+    check_is_bound();
 
-template<typename T>
-inline T * Rice::Data_Type<T>::
-from_ruby(Object x)
-{
-  check_is_bound();
+    // Define a Ruby allocator which creates the Ruby object
+    detail::protect(rb_define_alloc_func, static_cast<VALUE>(*this), detail::default_allocation_func<T>);
 
-  void * v = DATA_PTR(x.value());
-  Class klass = x.class_of();
+    // Define an initialize function that will create the C++ object
+    this->define_method("initialize", &Constructor_T::construct, args...);
 
-  if(klass.value() == klass_)
-  {
-    // Great, not converting to a base/derived type
-    Data_Type<T> data_klass;
-    Data_Object<T> obj(x, data_klass);
-    return obj.get();
+    return *this;
   }
 
-  Data_Type_Base::Casters::const_iterator it = Data_Type_Base::casters().begin();
-  Data_Type_Base::Casters::const_iterator end = Data_Type_Base::casters().end();
-   
-  // Finding the bound type that relates to the given klass is
-  // a two step process. We iterate over the list of known type casters,
-  // looking for:
-  //
-  // 1) casters that handle this direct type
-  // 2) casters that handle types that are ancestors of klass
-  //
-  // Step 2 allows us to handle the case where a Rice-wrapped class
-  // is subclassed in Ruby but then an instance of that class is passed
-  // back into C++ (say, in a Listener / callback construction)
-  //
-
-  VALUE ancestors = rb_mod_ancestors(klass.value());
-
-  long earliest = RARRAY_LEN(ancestors) + 1;
-
-  int index;
-  VALUE indexFound;
-  Data_Type_Base::Casters::const_iterator toUse = end;
-
-  for(; it != end; it++) {
-    // Do we match directly?
-    if(klass.value() == it->first) {
-      toUse = it;
-      break;
+  template<typename T>
+  template<typename Director_T>
+  inline Data_Type<T>& Data_Type<T>::define_director()
+  {
+    if (!detail::TypeRegistry::isDefined<Director_T>())
+    {
+      Data_Type<Director_T>::bind(*this);
     }
 
-    // Check for ancestors. Trick is, we need to find the lowest
-    // ancestor that does have a Caster to make sure that we're casting
-    // to the closest C++ type that the Ruby class is subclassing. 
-    // There might be multiple ancestors that are also wrapped in
-    // the extension, so find the earliest in the list and use that one.
-    indexFound = rb_funcall(ancestors, rb_intern("index"), 1, it->first);
+    // TODO - hack to fake Ruby into thinking that a Director is
+    // the same as the base data type
+    Data_Type<Director_T>::rb_type_ = Data_Type<T>::rb_type_;
+    return *this;
+  }
 
-    if(indexFound != Qnil) {
-      index = NUM2INT(indexFound);
+  template<typename T>
+  inline bool Data_Type<T>::is_bound()
+  {
+    return klass_ != Qnil;
+  }
 
-      if(index < earliest) {
-        earliest = index;
-        toUse = it;
-      }
+  template<typename T>
+  inline bool Data_Type<T>::is_descendant(VALUE value)
+  {
+    check_is_bound();
+    return detail::protect(rb_obj_is_kind_of, value, klass_) == Qtrue;
+  }
+
+  template<typename T>
+  inline void Data_Type<T>::check_is_bound()
+  {
+    if (!is_bound())
+    {
+      std::string message = "Type " + detail::typeName(typeid(T)) + " is not bound";
+      throw std::runtime_error(message.c_str());
     }
   }
-  
-  if(toUse == end)
+
+  template<typename T, typename Base_T>
+  inline Data_Type<T> define_class_under(Object module, char const* name)
   {
-    std::string s = "Class ";
-    s += klass.name().str();
-    s += " is not registered/bound in Rice";
-    throw std::runtime_error(s);
+    if (detail::TypeRegistry::isDefined<T>())
+    {
+      return Data_Type<T>();
+    }
+    
+    Class superKlass;
+
+    if constexpr (std::is_void_v<Base_T>)
+    {
+      superKlass = rb_cObject;
+    }
+    else
+    {
+      superKlass = Data_Type<Base_T>::klass();
+    }
+    
+    Class c = define_class_under(module, name, superKlass);
+    c.undef_creation_funcs();
+    return Data_Type<T>::template bind<Base_T>(c);
   }
 
-  detail::Abstract_Caster * caster = toUse->second;
-  if(caster)
+  template<typename T, typename Base_T>
+  inline Data_Type<T> define_class(char const* name)
   {
-    T * result = static_cast<T *>(caster->cast_to_base(v, klass_));
-    return result;
+    if (detail::TypeRegistry::isDefined<T>())
+    {
+      return Data_Type<T>();
+    }
+
+    Class superKlass;
+    if constexpr (std::is_void_v<Base_T>)
+    {
+      superKlass = rb_cObject;
+    }
+    else
+    {
+      superKlass = Data_Type<Base_T>::klass();
+    }
+
+    Class c = define_class(name, superKlass);
+    c.undef_creation_funcs();
+    return Data_Type<T>::template bind<Base_T>(c);
   }
-  else
+
+  template<typename T>
+  template<typename U, typename Iterator_T>
+  inline Data_Type<T>& Data_Type<T>::define_iterator(Iterator_T(U::* begin)(), Iterator_T(U::* end)(), Identifier name)
   {
-    return static_cast<T *>(v);
+    using Iter_T = detail::Iterator<U, Iterator_T>;
+    Iter_T* iterator = new Iter_T(begin, end);
+    detail::MethodData::define_method(Data_Type<T>::klass(), name,
+      (RUBY_METHOD_FUNC)iterator->call, 0, iterator);
+
+    return *this;
   }
-}
 
-template<typename T>
-inline bool Rice::Data_Type<T>::
-is_bound()
-{
-  return klass_ != Qnil;
-}
+  template <typename T>
+  template <typename Attr_T>
+  inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attr_T attr, AttrAccess access)
+  {
+    auto* native = detail::Make_Native_Attribute(attr, access);
+    using Native_T = typename std::remove_pointer_t<decltype(native)>;
 
-template<typename T>
-inline Rice::detail::Abstract_Caster * Rice::Data_Type<T>::
-caster() const
-{
-  check_is_bound();
-  return caster_.get();
-}
+    detail::verifyType<typename Native_T::Native_Return_T>();
 
-namespace Rice
-{
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
+    {
+      detail::MethodData::define_method( klass_, Identifier(name).id(),
+        RUBY_METHOD_FUNC(&Native_T::get), 0, native);
+    }
 
-template<>
-inline detail::Abstract_Caster * Data_Type<void>::
-caster() const
-{
-  return 0;
-}
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
+    {
+      if (std::is_const_v<std::remove_pointer_t<Attr_T>>)
+      {
+        throw std::runtime_error(name + " is readonly");
+      }
 
-template<typename T>
-void Data_Type<T>::
-check_is_bound()
-{
-  if(!is_bound())
-  {
-    std::string s;
-    s = "Data type ";
-    s += detail::demangle(typeid(T).name());
-    s += " is not bound";
-    throw std::runtime_error(s.c_str());
+      detail::MethodData::define_method( klass_, Identifier(name + "=").id(),
+        RUBY_METHOD_FUNC(&Native_T::set), 1, native);
+    }
+
+    return *this;
   }
-}
 
-} // Rice
+  template <typename T>
+  template <typename Attr_T>
+  inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attr_T attr, AttrAccess access)
+  {
+    auto* native = detail::Make_Native_Attribute(attr, access);
+    using Native_T = typename std::remove_pointer_t<decltype(native)>;
 
-template<typename T>
-inline Rice::Data_Type<T> Rice::
-define_class_under(
-    Object module,
-    char const * name)
-{
-  Class c(define_class_under(module, name, rb_cObject));
-  c.undef_creation_funcs();
-  return Data_Type<T>::template bind<void>(c);
-}
+    detail::verifyType<typename Native_T::Native_Return_T>();
 
-template<typename T, typename Base_T>
-inline Rice::Data_Type<T> Rice::
-define_class_under(
-    Object module,
-    char const * name)
-{
-  Data_Type<Base_T> base_dt;
-  Class c(define_class_under(module, name, base_dt));
-  c.undef_creation_funcs();
-  return Data_Type<T>::template bind<Base_T>(c);
-}
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
+    {
+      VALUE singleton = detail::protect(rb_singleton_class, this->value());
+      detail::MethodData::define_method(singleton, Identifier(name).id(),
+        RUBY_METHOD_FUNC(&Native_T::get), 0, native);
+    }
 
-template<typename T>
-inline Rice::Data_Type<T> Rice::
-define_class(
-    char const * name)
-{
-  Class c(define_class(name, rb_cObject));
-  c.undef_creation_funcs();
-  return Data_Type<T>::template bind<void>(c);
-}
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
+    {
+      if (std::is_const_v<std::remove_pointer_t<Attr_T>>)
+      {
+        throw std::runtime_error(name  + " is readonly");
+      }
 
-template<typename T, typename Base_T>
-inline Rice::Data_Type<T> Rice::
-define_class(
-    char const * name)
-{
-  Data_Type<Base_T> base_dt;
-  Class c(define_class(name, base_dt));
-  c.undef_creation_funcs();
-  return Data_Type<T>::template bind<Base_T>(c);
-}
+      VALUE singleton = detail::protect(rb_singleton_class, this->value());
+      detail::MethodData::define_method(singleton, Identifier(name + "=").id(),
+        RUBY_METHOD_FUNC(&Native_T::set), 1, native);
+    }
 
-template<typename From_T, typename To_T>
-inline void 
-Rice::define_implicit_cast()
-{
-  // As Rice currently expects only one entry into
-  // this list for a given klass VALUE, we need to get
-  // the current caster for From_T and insert in our
-  // new caster as the head of the caster list
-
-  Class from_class = Data_Type<From_T>::klass().value();
-  Class to_class = Data_Type<To_T>::klass().value();
-
-  detail::Abstract_Caster* from_caster = 
-    Data_Type<From_T>::caster_.release();
-
-  detail::Abstract_Caster* new_caster = 
-    new detail::Implicit_Caster<To_T, From_T>(from_caster, to_class);
-
-  // Insert our new caster into the list for the from class
-  Data_Type_Base::casters().erase(from_class);
-  Data_Type_Base::casters().insert(
-    std::make_pair(
-      from_class,
-      new_caster
-    )
-  );
-
-  // And make sure the from_class has direct access to the
-  // updated caster list
-  Data_Type<From_T>::caster_.reset(new_caster);
+    return *this;
+  }
 }
-
-#endif // Rice__Data_Type__ipp_
+#endif