rice 3.0.0 → 4.0.0

data/rice/Data_Object_defn.hpp

@@ -1,11 +1,11 @@
 #ifndef Rice__Data_Object_defn__hpp_
 #define Rice__Data_Object_defn__hpp_
 
-#include "Object_defn.hpp"
-#include "Data_Type_fwd.hpp"
-#include "ruby_mark.hpp"
+#include <optional>
+
 #include "detail/to_ruby.hpp"
 #include "detail/ruby.hpp"
+#include "cpp_api/Object_defn.hpp"
 
 /*! \file
  *  \brief Provides a helper class for wrapping and unwrapping C++
@@ -14,124 +14,84 @@
 
 namespace Rice
 {
-
-template<typename T>
-struct Default_Mark_Function
-{
-  typedef void (*Ruby_Data_Func)(T * obj);
-  static const Ruby_Data_Func mark;
-};
-
-template<typename T>
-struct Default_Free_Function
-{
-  static void free(T * obj) { delete obj; }
-};
-
-
-//! A smartpointer-like wrapper for Ruby data objects.
-/*! A data object is a ruby object of type T_DATA, which is usually
- *  created by using the Data_Wrap_Struct or Data_Make_Struct macro.
- *  This class wraps creation of the data structure, providing a
- *  type-safe object-oriented interface to the underlying C interface.
- *  This class works in conjunction with the Data_Type class to ensure
- *  type safety.
- *
- *  Example:
- *  \code
- *    class Foo { };
- *    ...
- *    Data_Type<Foo> rb_cFoo = define_class("Foo");
- *    ...
- *    // Wrap:
- *    Data_Object<Foo> foo1(new Foo);
- *
- *    // Get value to return:
- *    VALUE v = foo1.value()
- *
- *    // Unwrap:
- *    Data_Object<Foo> foo2(v, rb_cFoo);
- *  \endcode
- */
-template<typename T>
-class Data_Object
-  : public Object
-{
-public:
-  //! A function that takes a T* and returns void.
-  typedef void (*Ruby_Data_Func)(T * obj);
-
-  //! Wrap a C++ object.
-  /*! This constructor is analogous to calling Data_Wrap_Struct.  Be
-   *  careful not to call this function more than once for the same
-   *  pointer (in general, it should only be called for newly
-   *  constructed objects that need to be managed by Ruby's garbage
-   *  collector).
-   *  \param obj the object to wrap.
-   *  \param klass the Ruby class to use for the newly created Ruby
-   *  object.
-   *  \param mark_func a function that gets called by the garbage
-   *  collector to mark the object's children.
-   *  \param free_func a function that gets called by the garbage
-   *  collector to free the object.
-   */
-  Data_Object(
-      T * obj,
-      VALUE klass = Data_Type<T>::klass(),
-      Ruby_Data_Func mark_func = Default_Mark_Function<T>::mark,
-      Ruby_Data_Func free_func = Default_Free_Function<T>::free);
-
-  //! Unwrap a Ruby object.
-  /*! This constructor is analogous to calling Data_Get_Struct.  Uses
-   *  Data_Type<T>::klass as the class of the object.
-   *  \param value the Ruby object to unwrap.
+  //! A smartpointer-like wrapper for Ruby data objects.
+  /*! A data object is a ruby object of type T_DATA, which is usually
+   *  created by using the Data_Wrap_Struct or Data_Make_Struct macro.
+   *  This class wraps creation of the data structure, providing a
+   *  type-safe object-oriented interface to the underlying C interface.
+   *  This class works in conjunction with the Data_Type class to ensure
+   *  type safety.
+   *
+   *  Example:
+   *  \code
+   *    class Foo { };
+   *    ...
+   *    Data_Type<Foo> rb_cFoo = define_class("Foo");
+   *    ...
+   *    // Wrap:
+   *    Data_Object<Foo> foo1(new Foo);
+   *
+   *    // Get value to return:
+   *    VALUE v = foo1.value()
+   *
+   *    // Unwrap:
+   *    Data_Object<Foo> foo2(v, rb_cFoo);
+   *  \endcode
    */
-  Data_Object(
-      Object value);
-
-  //! Unwrap a Ruby object.
-  /*! This constructor is analogous to calling Data_Get_Struct.  Will
-   *  throw an exception if the class of the object differs from the
-   *  specified class.
-   *  \param value the Ruby object to unwrap.
-   *  \param klass the expected class of the object.
-   */
-  template<typename U>
-  Data_Object(
-      Object value,
-      Data_Type<U> const & klass = Data_Type<T>::klass());
-
-  //! Make a copy of a Data_Object
-  /*! \param other the Data_Object to copy.
-   */
-  Data_Object(Data_Object const & other);
-
-  T & operator*() const { return *obj_; } //!< Return a reference to obj_
-  T * operator->() const { return obj_; } //!< Return a pointer to obj_
-  T * get() const { return obj_; }        //!< Return a pointer to obj_
-
-  //! Swap with another data object of the same type
-  /*! \param ref the object with which to swap.
-   */
-  template<typename U>
-  void swap(Data_Object<U> & ref);
-
-private:
-  static void check_cpp_type(Data_Type<T> const & klass);
-
-private:
-  T * obj_;
-};
-
-namespace detail
-{
   template<typename T>
-  struct to_ruby_<Data_Object<T> >
+  class Data_Object : public Object
   {
-    static Rice::Object convert(Data_Object<T> const & x);
+    static_assert(!std::is_pointer_v<T>);
+    static_assert(!std::is_reference_v<T>);
+    static_assert(!std::is_const_v<T>);
+    static_assert(!std::is_volatile_v<T>);
+
+  public:
+    static T* from_ruby(VALUE value);
+    static std::optional<T> implicit_from_ruby(VALUE value);
+
+  public:
+    //! Wrap a C++ object.
+    /*! This constructor is analogous to calling Data_Wrap_Struct.  Be
+     *  careful not to call this function more than once for the same
+     *  pointer (in general, it should only be called for newly
+     *  constructed objects that need to be managed by Ruby's garbage
+     *  collector).
+     *  \param obj the object to wrap.
+     *  \param klass the Ruby class to use for the newly created Ruby
+     *  object.
+     *  \param mark_func a function that gets called by the garbage
+     *  collector to mark the object's children.
+     *  \param free_func a function that gets called by the garbage
+     *  collector to free the object.
+     */
+    Data_Object(T* obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
+    Data_Object(T& obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
+
+    //! Unwrap a Ruby object.
+    /*! This constructor is analogous to calling Data_Get_Struct.  Uses
+     *  Data_Type<T>::klass as the class of the object.
+     *  \param value the Ruby object to unwrap.
+     */
+    Data_Object(Object value);
+
+    //! Unwrap a Ruby object.
+    /*! This constructor is analogous to calling Data_Get_Struct.  Will
+     *  throw an exception if the class of the object differs from the
+     *  specified class.
+     *  \param value the Ruby object to unwrap.
+     *  \param klass the expected class of the object.
+     */
+    template<typename U>
+    Data_Object(Object value);
+
+    T& operator*() const; //!< Return a reference to obj_
+    T* operator->() const; //!< Return a pointer to obj_
+    T* get() const;        //!< Return a pointer to obj_
+
+  private:
+    static void check_ruby_type(VALUE value);
   };
-}
-
 } // namespace Rice
 
 #endif // Rice__Data_Object_defn__hpp_

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