rice 3.0.0 → 4.0.3

data/rice/Data_Type_defn.hpp

@@ -2,260 +2,192 @@
 #define Rice__Data_Type_defn__hpp_
 
 #include "Class_defn.hpp"
-#include "Data_Type_fwd.hpp"
 #include "detail/ruby.hpp"
-#include <memory>
-#include <map>
 #include <set>
 
-/*!
- *  \example map/map.cpp
- */
-
 namespace Rice
 {
-
-namespace detail
-{
-  class Abstract_Caster;
-}
-
-class Module;
-
-//! The base class for all instantiations of Data_Type.
-class Data_Type_Base
-  : public Module_impl<Class, Data_Type_Base>
-{
-public:
-  //! Default constructor.
-  Data_Type_Base();
-
-  //! Constructor.
-  Data_Type_Base(VALUE v);
-
-  //! Destructor.
-  virtual ~Data_Type_Base() = 0;
-
-  // Must be public to workaround gcc 3.3
-  typedef std::map<VALUE, detail::Abstract_Caster *> Casters;
-
-  virtual detail::Abstract_Caster * caster() const = 0;
-
-  static Casters & casters();
-
-private:
-  static Casters * casters_;
-};
-
-//! Define a new data class in the namespace given by module.
-/*! The class will have a base class of Object.
- *  \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>
-Rice::Data_Type<T> define_class_under(
-    Object module,
-    char const * name);
-
-//! Define a new data class in the namespace given by module.
-/*! The class with have a base class determined by Base_T (specifically,
- *  Data_Type<Base_T>::klass).  Therefore, the type Base_T must already
- *  have been registered using define_class<> or define_class_under<>.
- *  \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>
-Rice::Data_Type<T> define_class_under(
-    Object module,
-    char const * name);
-
-//! Define a new data class in the default namespace.
-/*! The class will have a base class of Object.
- *  \param T the C++ type of the wrapped class.
- *  \return the new class.
- */
-template<typename T>
-Rice::Data_Type<T> define_class(
-    char const * name);
-
-//! Define a new data class in the default namespace.
-/*! The class with have a base class determined by Base_T (specifically,
- *  Data_Type<Base_T>::klass).  Therefore, the type Base_T must already
- *  have been registered using define_class<> or define_class_under<>.
- *  \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>
-Rice::Data_Type<T> define_class(
-    char const * name);
-
-//! Define an implicit conversion rule between two types.
-/*! Given two types, which can be custom types already 
- *  wrapped into Rice or fundamental C++ types, this
- *  tells Rice that the two types can be used interchangably.
- *  \param From_T The type to convert from
- *  \param To_T The type to convert to
- */
-template<typename From_T, typename To_T>
-void define_implicit_cast();
-
-//! 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 Module_impl<Data_Type_Base, Data_Type<T> >
-{
-public:
-  //! The C++ type being held.
-  typedef T Type;
-
-  //! 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.
+  //! 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.
    */
-  Data_Type(Module const & v);
-
-  //! Destructor.
-  virtual ~Data_Type();
+  template<typename T>
+  class Data_Type : public Class
+  {
+    static_assert(std::is_same_v<detail::intrinsic_type<T>, T>);
+
+  public:
+    //! 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);
+
+    //! Destructor.
+    virtual ~Data_Type();
  
-  //! Explictly return the Ruby type.
-  /*! \return the ruby class to which the type is bound.
-   */
-  static Module klass();
-
-  //! Assignment operator which takes a Module
-  /*! \param klass must be the class to which this data type is already
-   *  bound.
-   *  \return *this
-   */
-  virtual Data_Type & operator=(Module const & klass);
-
-  //! Define a constructor for the class.
-  /*! 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.
-   *  For example:
-   *  \code
-   *    define_class<Foo>("Foo")
-   *      .define_constructor(Constructor<Foo>());
-   *  \endcode
+    //! Return the Ruby class.
+    /*! \return the ruby class to which the type is bound.
+     */
+    static Class klass();
+
+    //! Return the Ruby type.
+    static rb_data_type_t* rb_type();
+
+    //! Assignment operator which takes a Module
+    /*! \param klass must be the class to which this data type is already
+     *  bound.
+     *  \return *this
+     */
+    virtual Data_Type & operator=(Module const & klass);
+
+    //! Define a constructor for the class.
+    template<typename Constructor_T>
+    [[deprecated("Please call define_constructor with Arg parameters")]]
+    Data_Type<T> & define_constructor(Constructor_T constructor, MethodInfo * methodInfo);
+
+    /*! 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...Arg_Ts>
+    Data_Type<T> & define_constructor(Constructor_T constructor, Arg_Ts const& ...args);
+
+    //! 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();
+
+    // 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 U = T, typename Iterator_Return_T>
+    Data_Type<T>& define_iterator(Iterator_Return_T(U::* begin)(), Iterator_Return_T(U::* end)(), Identifier name = "each");
+
+    template <typename Attr_T>
+    Data_Type<T>& define_attr(std::string name, Attr_T attr, AttrAccess access = AttrAccess::ReadWrite);
+  
+    template <typename Attr_T>
+    Data_Type<T>& define_singleton_attr(std::string name, Attr_T attr, 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 bind(Module const & klass);
+
+    template<typename T_, typename Base_T_>
+    friend Rice::Data_Type<T_> define_class_under(Object module, char const * name);
+
+    template<typename T_, typename Base_T_>
+    friend Rice::Data_Type<T_> define_class(char const * name);
+
+  private:
+    template<typename T_>
+    friend class Data_Type;
+
+    static inline VALUE klass_ = Qnil;
+
+    // Typed Data support
+    static inline rb_data_type_t* rb_type_ = nullptr;
+
+    typedef std::set<Data_Type<T> *> Instances;
+
+    static Instances & unbound_instances()
+    {
+      static Instances unbound_instances;
+      return unbound_instances;
+    }
+  };
+
+  //! 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 Constructor_T>
-  Data_Type<T> & define_constructor(
-      Constructor_T constructor,
-      Arguments * arguments = 0);
-
-  template<typename Constructor_T>
-  Data_Type<T> & define_constructor(
-      Constructor_T constructor,
-      Arg const& arg);
-
-  //! 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, and cannot find an appropriate Caster.
-   *
-   *  This method takes no arguments, 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();
-
-  //! Convert ruby object x to type T.
-  /*! \param x the object to convert.
-   *  \return the C++ object wrapped inside object x.
-   */
-  static T * from_ruby(Object x);
-
-  //! Determine if the type is bound.
-  /*! \return true if the object is bound, false otherwise.
-   */
-  static bool is_bound();
-
-  virtual detail::Abstract_Caster * caster() const;
-
-  static std_unique_ptr<detail::Abstract_Caster> caster_;
-
-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 T, typename Base_T = void>
+  Data_Type<T> define_class_under(Object module, 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 Base_T>
-  static Data_Type bind(Module const & klass);
-
-  template<typename T_>
-  friend Rice::Data_Type<T_> define_class_under(
-      Object module,
-      char const * name);
-
-  template<typename T_, typename Base_T_>
-  friend Rice::Data_Type<T_> define_class_under(
-      Object module,
-      char const * name);
-
-  template<typename T_>
-  friend Rice::Data_Type<T_> Rice::define_class(
-      char const * name);
-
-  template<typename T_, typename Base_T_>
-  friend Rice::Data_Type<T_> define_class(
-      char const * name);
-
-private:
-  template<typename T_>
-  friend class Data_Type;
-
-  static void check_is_bound();
-
-  static VALUE klass_;
-
-  typedef std::set<Data_Type<T> *> Instances;
-
-  static Instances & unbound_instances()
-  {
-    static Instances unbound_instances;
-    return unbound_instances;
-  }
-};
-
+  template<typename T, typename Base_T = void>
+  Data_Type<T> define_class(char const* name);
 
 } // namespace Rice
 
 #include "Data_Type.ipp"
 
-#endif // Rice__Data_Type_defn__hpp_
-
+#endif // Rice__Data_Type_defn__hpp_

data/rice/Director.hpp

@@ -1,10 +1,10 @@
 #ifndef Rice__Director__hpp_
 #define Rice__Director__hpp_
 
-#include "Object.hpp"
-
-namespace Rice {
+#include "cpp_api/Object.hpp"
 
+namespace Rice
+{
   /**
    * A Director works exactly as a SWIG %director works (thus the name).
    * You use this class to help build proxy classes so that polymorphism
@@ -15,15 +15,20 @@ namespace Rice {
     public:
       //! Construct new Director. Needs the Ruby object so that the
       //  proxy class can call methods on that object.
-      Director(Object self);
+      Director(Object self) : self_(self)
+      {
+      }
 
-      virtual ~Director() { }
+      virtual ~Director() = default;
 
       //! Raise a ruby exception when a call comes through for a pure virtual method
       /*! If a Ruby script calls 'super' on a method that's otherwise a pure virtual
        *  method, use this method to throw an exception in this case.
        */
-      void raisePureVirtual() const;
+      void raisePureVirtual() const
+      {
+        rb_raise(rb_eNotImpError, "Cannot call super() into a pure-virtual C++ method");
+      }
 
       //! Get the Ruby object linked to this C++ instance
       Object getSelf() const { return self_; }

data/rice/Enum.hpp

@@ -1,117 +1,67 @@
 #ifndef Rice__Enum__hpp_
 #define Rice__Enum__hpp_
 
-#include "to_from_ruby_defn.hpp"
-#include "Address_Registration_Guard.hpp"
-#include "Array.hpp"
-#include "Hash.hpp"
-#include "String.hpp"
-#include "Module.hpp"
 #include "Data_Type.hpp"
+#include <map>
 
 namespace Rice
 {
-
-//! Default traits for the Enum class template.
-template<typename Enum_T>
-struct Default_Enum_Traits
-{
-  //! Converts the enum value to a long.
-  static long as_long(Enum_T value);
-};
-
-/*!
- *  \example enum/sample_enum.cpp
- */
-
-//! A wrapper for enumerated types.
-/*! Provides a simple type-safe wrapper for enumerated types.  At the
- *  ruby level, the class will have convenience methods for iterating
- *  over all the defined enum values, converting the values to strings,
- *  and more.
- *
- *  \param Enum_T the enumerated type
- *  \param Enum_Traits specifies the traits of the enumerated type.
- *
- *  Example:
- *  \code
- *    enum Color { Red, Green, Blue };
- *    Enum<Color> rb_cColor = define_enum<Color>("Color")
- *      .define_value("Red", Red)
- *      .define_value("Green", Green)
- *      .define_value("Blue", Blue);
- *  \endcode
- */
-template<typename Enum_T, typename Enum_Traits = Default_Enum_Traits<Enum_T> >
-class Enum
-  : public Module_impl<Data_Type<Enum_T>, Enum<Enum_T, Enum_Traits> >
-{
-public:
-  //! Default constructor.
-  Enum();
-
-  //! Construct and initialize.
-  Enum(
-      char const * name,
-      Module module = rb_cObject);
-
-  //! Copy constructor.
-  Enum(Enum const & other);
-
-  //! Assignment operator.
-  Enum & operator=(Enum const & other);
-
-  //! Destructor.
-  virtual ~Enum();
-
-  //! Define a new enum value.
-  /*! \param name the name of the enum value.
-   *  \param value the value to associate with name.
-   *  \return *this
+  /*!
+   *  \example enum/sample_enum.cpp
    */
-  Enum<Enum_T, Enum_Traits> & define_value(
-      char const * name,
-      Enum_T value);
-
-  void swap(Enum & other);
-
-private:
-  //! Initialize the enum type.
-  /*! Must be called only once.
-   *  \param name the name of the class to define
-   *  \param module the module in which to place the enum class.
-   *  \return *this
-   */
-  Enum<Enum_T, Enum_Traits> & initialize(
-      char const * name,
-      Module module = rb_cObject);
-
-private:
-  static Object each(Object self);
-  static Object to_s(Object self);
-  static Object to_i(Object self);
-  static Object inspect(Object self);
-  static Object compare(Object lhs, Object rhs);
-  static Object eql(Object lhs, Object rhs);
-  static Object hash(Object self);
-  static Object from_int(Class klass, Object i);
-
-private:
-  Array enums_;
-  Address_Registration_Guard enums_guard_;
-
-  Hash names_;
-  Address_Registration_Guard names_guard_;
-};
-
-template<typename T>
-Enum<T> define_enum(
-    char const * name,
-    Module module = rb_cObject);
 
+   //! A wrapper for enumerated types.
+   /*! Provides a simple type-safe wrapper for enumerated types.  At the
+    *  ruby level, the class will have convenience methods for iterating
+    *  over all the defined enum values, converting the values to strings,
+    *  and more.
+    *
+    *  \param Enum_T the enumerated type
+    *
+    *  Example:
+    *  \code
+    *    enum Color { Red, Green, Blue };
+    *    Enum<Color> rb_cColor = define_enum<Color>("Color")
+    *      .define_value("Red", Red)
+    *      .define_value("Green", Green)
+    *      .define_value("Blue", Blue);
+    *  \endcode
+    */
+  template<typename Enum_T>
+  class Enum : public Data_Type<Enum_T>
+  {
+    using Underlying_T = std::underlying_type_t<Enum_T>;
+
+  public:
+
+    Enum() = default;
+
+    //! Construct and initialize.
+    Enum(char const* name, Module module = rb_cObject);
+
+    //! Define a new enum value.
+    /*! \param name the name of the enum value.
+     *  \param value the value to associate with name.
+     *  \return *this
+     */
+    Enum<Enum_T>& define_value(std::string name, Enum_T value);
+
+    //! Maps an enum value to the correct Ruby object
+    /*! \param klass The bound Ruby class
+     *  \param enumValue The enum value
+     *  \return Object - The Ruby wrapper */
+    static Object from_enum(Class klass, Enum_T enumValue);
+
+  private:
+    void define_methods(Data_Type<Enum_T> klass);
+
+    static inline std::map<Enum_T, std::string> valuesToNames_;
+  };
+
+  template<typename T>
+  Enum<T> define_enum(char const* name, Module module = rb_cObject);
 } // namespace Rice
 
 #include "Enum.ipp"
 
-#endif // Rice__Enum__hpp_
-
+#endif // Rice__Enum__hpp_