rice 4.3.3 → 4.6.0

data/rice/Data_Type.hpp

@@ -1,7 +1,218 @@
 #ifndef Rice__Data_Type__hpp_
 #define Rice__Data_Type__hpp_
 
-#include "Data_Type_defn.hpp"
-#include "Data_Type.ipp"
+#include <set>
 
-#endif // Rice__Data_Type__hpp_
+namespace Rice
+{
+  //! A mechanism for binding ruby types to C++ types.
+  /*! This class binds run-time types (Ruby VALUEs) to compile-time types
+   *  (C++ types).  The binding can occur only once.
+   */
+  template<typename T>
+  class Data_Type : public Class
+  {
+    static_assert(std::is_same_v<detail::intrinsic_type<T>, T>);
+
+  public:
+    using type = T;
+
+    //! Default constructor which does not bind.
+    /*! No member functions must be called on this Data_Type except bind,
+     *  until the type is bound.
+     */
+    Data_Type();
+
+    //! Constructor which takes a Module.
+    /*! Binds the type to the given VALUE according to the rules given
+     *  above.
+     *  \param klass the module to which to bind.
+     */
+    Data_Type(Module const & v);
+
+    //! Return the Ruby class.
+    /*! \return the ruby class to which the type is bound.
+     */
+    static Class klass();
+
+    //! Return the Ruby data type.
+    static rb_data_type_t* ruby_data_type();
+
+    //! Assignment operator which takes a Module
+    /*! \param klass must be the class to which this data type is already
+     *  bound.
+     *  \return *this
+     */
+    Data_Type& operator=(Module const & klass);
+
+    /*! Creates a singleton method allocate and an instance method called
+     *  initialize which together create a new instance of the class.  The
+     *  allocate method allocates memory for the object reference and the
+     *  initialize method constructs the object.
+     *  \param constructor an object that has a static member function
+     *  construct() that constructs a new instance of T and sets the object's data
+     *  member to point to the new instance.  A helper class Constructor
+     *  is provided that does precisely this.
+     *  \param args a list of Arg instance used to define default parameters (optional)
+     *
+     *  For example:
+     *  \code
+     *    define_class<Foo>("Foo")
+     *      .define_constructor(Constructor<Foo>());
+     *  \endcode
+     */
+    template<typename Constructor_T, typename...Rice_Arg_Ts>
+    Data_Type<T>& define_constructor(Constructor_T constructor, Rice_Arg_Ts const& ...args);
+
+    /*! Runs a function that should define this Data_Types methods and attributes.
+     *  This is useful when creating classes from a C++ class template.
+     *
+     *  \param builder A function that addes methods/attributes to this class
+     *
+     *  For example:
+     *  \code
+     *    void builder(Data_Type<Matrix<T, R, C>>& klass)
+     *    {
+     *      klass.define_method...
+     *      return klass;
+     *    }
+     *
+     *    define_class<<Matrix<T, R, C>>>("Matrix")
+     *      .build(&builder);
+     *
+     *  \endcode
+     */
+    template<typename Func_T>
+    Data_Type<T>& define(Func_T func);
+
+    //! Register a Director class for this class.
+    /*! For any class that uses Rice::Director to enable polymorphism
+     *  across the languages, you need to register that director proxy
+     *  class with this method. Not doing so will cause the resulting 
+     *  library to die at run time when it tries to convert the base
+     *  type into the Director proxy type.
+     *
+     *  This method takes no methodInfo, just needs the type of the
+     *  Director proxy class.
+     *
+     *  For example:
+     *  \code
+     *    class FooDirector : public Foo, public Rice::Director {
+     *      ...
+     *    };
+     *
+     *    define_class<Foo>("Foo")
+     *      .define_director<FooDirector>()
+     *      .define_constructor(Constructor<FooDirector, Rice::Object>());
+     *  \endcode
+     */
+    template<typename Director_T>
+    Data_Type<T>& define_director();
+
+    //! Determine if the type is bound.
+    /*! \return true if the object is bound, false otherwise.
+     */
+    static bool is_bound();
+    static void check_is_bound();
+    static bool is_defined();
+    static bool check_defined(const std::string& name, Object parent = rb_cObject);
+
+    // This is only for testing - DO NOT USE!!!
+    static void unbind();
+
+    static bool is_descendant(VALUE value);
+  
+    //! Define an iterator.
+    /*! Essentially this is a conversion from a C++-style begin/end
+     *  iterator to a Ruby-style \#each iterator.
+     *  \param begin a member function pointer to a function that returns
+     *  an iterator to the beginning of the sequence.
+     *  \param end a member function pointer to a function that returns an
+     *  iterator to the end of the sequence.
+     *  \param name the name of the iterator.
+     *  \return *this
+     */
+
+    template<typename Iterator_Func_T>
+    Data_Type<T>& define_iterator(Iterator_Func_T begin, Iterator_Func_T end, std::string name = "each");
+
+    template <typename Attribute_T>
+    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
+  
+    template <typename Attribute_T>
+    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
+
+    #include "cpp_api/shared_methods.hpp"
+  protected:
+    //! Bind a Data_Type to a VALUE.
+    /*! Throws an exception if the Data_Type is already bound to a
+     *  different class.  Any existing instances of the Data_Type will be
+     *  bound after this function returns.
+     *  \param klass the ruby type to which to bind.
+     *  \return *this
+     */
+    template <typename Base_T = void>
+    static Data_Type<T> bind(const Module& klass);
+
+    template<typename T_, typename Base_T>
+    friend Rice::Data_Type<T_> define_class_under(Object parent, Identifier id, Class superKlass);
+
+    template<typename T_, typename Base_T>
+    friend Rice::Data_Type<T_> define_class_under(Object parent, char const * name);
+
+    template<typename T_, typename Base_T>
+    friend Rice::Data_Type<T_> define_class(char const * name);
+
+    template<bool IsMethod, typename Function_T>
+    void wrap_native_call(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
+
+  private:
+    template<typename T_>
+    friend class Data_Type;
+
+    static inline VALUE klass_ = Qnil;
+
+    // Typed Data support
+    static inline rb_data_type_t* rb_data_type_ = nullptr;
+
+    static inline std::set<Data_Type<T>*>& unbound_instances();
+  };
+
+  //! Define a new data class in the namespace given by module.
+  /*! This override allows you to specify a Ruby class as the base class versus a 
+   *  wrapped C++ class. This functionality is rarely needed - but is essential for
+   *  creating new custom Exception classes where the Ruby superclass should be
+   *  rb_eStandard
+   *  \param T the C++ type of the wrapped class.
+   *  \param module the Module in which to define the class.
+   *  \param name the name of the new class.
+   *  \param superKlass the Ruby super class.
+   *  \return the new class.
+   */
+  template<typename T, typename Base_T = void>
+  Data_Type<T> define_class_under(Object parent, Identifier id, Class superKlass = rb_cObject);
+
+  //! Define a new data class in the namespace given by module.
+  /*! By default the class will inherit from Ruby's rb_cObject. This
+   *  can be overriden via the Base_T template parameter. Note that
+   *  Base_T must already have been registered.
+   *  \param T the C++ type of the wrapped class.
+   *  \param module the the Module in which to define the class.
+   *  \return the new class.
+   */
+  template<typename T, typename Base_T = void>
+  Data_Type<T> define_class_under(Object parent, char const* name);
+
+  //! Define a new data class in the default namespace.
+  /*! By default the class will inherit from Ruby's rb_cObject. This
+   *  can be overriden via the Base_T template parameter. Note that
+   *  Base_T must already have been registered.
+   *  \param T the C++ type of the wrapped class.
+   *  \param module the the Module in which to define the class.
+   *  \return the new class.
+   */
+  template<typename T, typename Base_T = void>
+  Data_Type<T> define_class(char const* name);
+}
+
+#endif // Rice__Data_Type__hpp_

data/rice/Data_Type.ipp

@@ -1,24 +1,9 @@
-#ifndef Rice__Data_Type__ipp_
-#define Rice__Data_Type__ipp_
-
-#include "traits/attribute_traits.hpp"
-#include "traits/method_traits.hpp"
-#include "detail/NativeRegistry.hpp"
-#include "detail/NativeAttribute.hpp"
-#include "detail/default_allocation_func.hpp"
-#include "detail/TypeRegistry.hpp"
-#include "detail/Wrapper.hpp"
-#include "detail/NativeIterator.hpp"
-#include "cpp_api/Class.hpp"
-#include "cpp_api/String.hpp"
-#include "ruby_mark.hpp"
-
 #include <stdexcept>
 
 namespace Rice
 {
   template<typename T>
-  void ruby_mark_internal(detail::Wrapper* wrapper)
+  inline void ruby_mark_internal(detail::WrapperBase* wrapper)
   {
     // Tell the wrapper to mark the objects its keeping alive
     wrapper->ruby_mark();
@@ -29,17 +14,23 @@ namespace Rice
   }
 
   template<typename T>
-  void ruby_free_internal(detail::Wrapper* wrapper)
+  inline void ruby_free_internal(detail::WrapperBase* wrapper)
   {
     delete wrapper;
   }
 
   template<typename T>
-  size_t ruby_size_internal(const T* data)
+  inline size_t ruby_size_internal(const T* data)
   {
     return sizeof(T);
   }
 
+  template<>
+  inline size_t ruby_size_internal(const void* data)
+  {
+    return sizeof(void*);
+  }
+
   template<typename T>
   template <typename Base_T>
   inline Data_Type<T> Data_Type<T>::bind(const Module& klass)
@@ -68,13 +59,12 @@ namespace Rice
     // Now register with the type registry
     detail::Registries::instance.types.add<T>(klass_, rb_data_type_);
 
-    for (typename Instances::iterator it = unbound_instances().begin(),
-      end = unbound_instances().end();
-      it != end;
-      unbound_instances().erase(it++))
-    {
-      (*it)->set_value(klass);
+    auto instances = unbound_instances();
+    for (auto instance: instances)
+    { 
+      instance->set_value(klass);
     }
+    instances.clear();
 
     return Data_Type<T>();
   }
@@ -94,10 +84,24 @@ namespace Rice
     rb_data_type_ = nullptr;
   }
 
+  // Track unbound instances (ie, declared variables of type Data_Type<T>
+  // before define_class is called). We can't simply use a static inline
+  // member because it sometimes crashes clang and gcc (msvc seems fine)
   template<typename T>
-  inline Data_Type<T>::Data_Type() : Class(klass_ == Qnil ? rb_cObject : klass_)
+  inline std::set<Data_Type<T>*>& Data_Type<T>::unbound_instances()
   {
-    if (!is_bound())
+    static std::set<Data_Type<T>*> unbound_instances;
+    return unbound_instances;
+  }
+
+  template<typename T>
+  inline Data_Type<T>::Data_Type()
+  {
+    if (is_bound())
+    {
+      this->set_value(klass_);
+    }
+    else
     {
       unbound_instances().insert(this);
     }
@@ -109,12 +113,6 @@ namespace Rice
     this->bind(klass);
   }
 
-  template<typename T>
-  inline Data_Type<T>::~Data_Type()
-  {
-    unbound_instances().erase(this);
-  }
-
   template<typename T>
   inline rb_data_type_t* Data_Type<T>::ruby_data_type()
   {
@@ -137,17 +135,50 @@ namespace Rice
   }
 
   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)
+  template<typename Constructor_T, typename...Rice_Arg_Ts>
+  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T constructor, Rice_Arg_Ts const& ...args)
   {
     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>);
 
-    // Define an initialize function that will create the C++ object
-    this->define_method("initialize", &Constructor_T::construct, args...);
+    // We can't do anything with move constructors so blow up
+    static_assert(!Constructor_T::isMoveConstructor(), "Rice does not support move constructors");
+
+    // If this is a copy constructor then use it to support Ruby's Object#dup and Object#clone methods.
+    // Otherwise if a user calls #dup or #clone an error will occur because the newly cloned Ruby
+    // object will have a NULL ptr because the C++ object is never copied. This also prevents having
+    // very unlike Ruby code of:
+    // 
+    //    my_object_copy = MyObject.new(my_ojbect_original).
 
+    if constexpr (Constructor_T::isCopyConstructor())
+    {
+      // Define initialize_copy that will copy the C++ object
+      this->define_method("initialize_copy", &Constructor_T::initialize_copy, args...);
+    }
+    else if constexpr (Constructor_T::isMoveConstructor())
+    {
+      throw std::runtime_error("Rice does not support move constructors");
+    }
+    else
+    {
+      // Define an initialize function that will create the C++ object
+      this->define_method("initialize", &Constructor_T::initialize, args...);
+    }
+
+    return *this;
+  }
+
+  template<typename T>
+  template<typename Function_T>
+  inline Data_Type<T>& Data_Type<T>::define(Function_T func)
+  {
+    // The passed in this pointer is an RValue, so we need to keep it alive by
+    // assigning it to a const lvalue
+    const auto& dummy = *this;
+    func(*this);
     return *this;
   }
 
@@ -155,7 +186,7 @@ namespace Rice
   template<typename Director_T>
   inline Data_Type<T>& Data_Type<T>::define_director()
   {
-    if (!detail::Registries::instance.types.isDefined<Director_T>())
+    if (!Data_Type<Director_T>::is_defined())
     {
       Data_Type<Director_T>::bind(*this);
     }
@@ -184,56 +215,86 @@ namespace Rice
   {
     if (!is_bound())
     {
-      std::string message = "Type " + detail::typeName(typeid(T)) + " is not bound";
-      throw std::runtime_error(message.c_str());
+      std::string message = "Type is not defined with Rice: " + detail::typeName(typeid(T));
+      throw std::invalid_argument(message.c_str());
     }
   }
 
-  template<typename T, typename Base_T>
-  inline Data_Type<T> define_class_under(Object module, char const* name)
+  template<typename T>
+  inline bool Data_Type<T>::is_defined()
+  {
+    return detail::Registries::instance.types.isDefined<T>();
+  }
+
+  template<typename T>
+  inline bool Data_Type<T>::check_defined(const std::string& name, Object parent)
   {
-    if (detail::Registries::instance.types.isDefined<T>())
+    if (Data_Type<T>::is_defined())
     {
-      return Data_Type<T>();
+      Data_Type<T> dataType;
+      parent.const_set_maybe(name, dataType.klass());
+      return true;
+    }
+    else
+    {
+      return false;
     }
-    
-    Class superKlass;
+  }
+   
+  template<typename Base_T>
+  inline Class get_superklass()
+  {
+    Class result;
 
     if constexpr (std::is_void_v<Base_T>)
     {
-      superKlass = rb_cObject;
+      result = rb_cObject;
     }
     else
     {
-      superKlass = Data_Type<Base_T>::klass();
+      // This gives a chance for to auto-register classes such as std::exception
+      detail::verifyType<Base_T>();
+      result = 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);
+
+    return result;
   }
 
   template<typename T, typename Base_T>
-  inline Data_Type<T> define_class(char const* name)
+  inline Data_Type<T> define_class_under(Object parent, Identifier id, Class superKlass)
   {
-    if (detail::Registries::instance.types.isDefined<T>())
+    if (Rice::Data_Type<T>::check_defined(id.str(), parent))
     {
       return Data_Type<T>();
     }
 
-    Class superKlass;
-    if constexpr (std::is_void_v<Base_T>)
-    {
-      superKlass = rb_cObject;
-    }
-    else
+    Class klass = define_class_under(parent, id, superKlass);
+    klass.undef_creation_funcs();
+    return Data_Type<T>::template bind<Base_T>(klass);
+  }
+
+  template<typename T, typename Base_T>
+  inline Data_Type<T> define_class_under(Object parent, char const* name)
+  {
+    Identifier id(name);
+    Class superKlass = get_superklass<Base_T>();
+    return define_class_under<T, Base_T>(parent, id, superKlass);
+  }
+  
+  template<typename T, typename Base_T>
+  inline Data_Type<T> define_class(char const* name)
+  {
+    std::string klassName(name);
+
+    if (Rice::Data_Type<T>::check_defined(klassName))
     {
-      superKlass = Data_Type<Base_T>::klass();
+      return Data_Type<T>();
     }
 
-    Class c = define_class(name, superKlass);
-    c.undef_creation_funcs();
-    return Data_Type<T>::template bind<Base_T>(c);
+    Class superKlass = get_superklass<Base_T>();
+    Class klass = define_class(name, superKlass);
+    klass.undef_creation_funcs();
+    return Data_Type<T>::template bind<Base_T>(klass);
   }
 
   template<typename T>
@@ -256,8 +317,18 @@ namespace Rice
     // Make sure the Attribute type has been previously seen by Rice
     detail::verifyType<typename detail::attribute_traits<Attribute_T>::attr_type>();
 
-    // Define native attribute
-    detail::NativeAttribute<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute), access);
+    // Define native attribute getter
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
+      detail::NativeAttributeGet<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute));
+
+    using Attr_T = typename detail::NativeAttributeSet<Attribute_T>::Attr_T;
+    if constexpr (!std::is_const_v<Attr_T> &&
+                  (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
+    {
+      // Define native attribute setter
+      if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
+        detail::NativeAttributeSet<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute));
+    }
 
     return *this;
   }
@@ -271,7 +342,14 @@ namespace Rice
 
     // Define native attribute
     VALUE singleton = detail::protect(rb_singleton_class, this->value());
-    detail::NativeAttribute<Attribute_T>::define(singleton, name, std::forward<Attribute_T>(attribute), access);
+
+    // Define native attribute getter
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
+      detail::NativeAttributeGet<Attribute_T>::define(singleton, name, std::forward<Attribute_T>(attribute));
+
+    // Define native attribute setter
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
+      detail::NativeAttributeSet<Attribute_T>::define(singleton, name, std::forward<Attribute_T>(attribute));
 
     return *this;
   }
@@ -289,4 +367,3 @@ namespace Rice
     detail::NativeFunction<T, Function_T, IsMethod>::define(klass, name, std::forward<Function_T>(function), methodInfo);
   }
 }
-#endif

data/rice/Director.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__Director__hpp_
 #define Rice__Director__hpp_
 
-#include "cpp_api/Object.hpp"
-
 namespace Rice
 {
   /**

data/rice/Enum.hpp

@@ -1,9 +1,6 @@
 #ifndef Rice__Enum__hpp_
 #define Rice__Enum__hpp_
 
-#include "Data_Type.hpp"
-#include <map>
-
 namespace Rice
 {
   /*!
@@ -33,7 +30,6 @@ namespace Rice
     using Underlying_T = std::underlying_type_t<Enum_T>;
 
   public:
-
     Enum() = default;
 
     //! Construct and initialize.
@@ -59,9 +55,10 @@ namespace Rice
   };
 
   template<typename T>
-  Enum<T> define_enum(char const* name, Module module = rb_cObject);
-} // namespace Rice
+  Enum<T> define_enum(char const* name);
 
-#include "Enum.ipp"
+  template<typename T>
+  Enum<T> define_enum_under(char const* name, Module module );
+} // namespace Rice
 
 #endif // Rice__Enum__hpp_