rice2 2.2.0

data/rice/Data_Type_defn.hpp

@@ -0,0 +1,261 @@
+#ifndef Rice__Data_Type_defn__hpp_
+#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.
+   */
+  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
+   */
+  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 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;
+  }
+};
+
+
+} // namespace Rice
+
+#include "Data_Type.ipp"
+
+#endif // Rice__Data_Type_defn__hpp_
+

data/rice/Data_Type_fwd.hpp

@@ -0,0 +1,12 @@
+#ifndef Rice__Data_Type_fwd__hpp_
+#define Rice__Data_Type_fwd__hpp_
+
+namespace Rice
+{
+
+  template<typename T>
+  class Data_Type;
+
+} // Rice
+
+#endif // Rice__Data_Type_fwd__hpp_

data/rice/Director.cpp

@@ -0,0 +1,13 @@
+#include "Director.hpp"
+
+namespace Rice {
+
+  Director::Director(Object self) {
+    self_ = self;
+  }
+
+  void Director::raisePureVirtual() const {
+    rb_raise(rb_eNotImpError, "Cannot call super() into a pure-virtual C++ method");
+  }
+
+}

data/rice/Director.hpp

@@ -0,0 +1,39 @@
+#ifndef Rice__Director__hpp_
+#define Rice__Director__hpp_
+
+#include "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
+   * works from C++ into Ruby. See the main README for how this class works.
+   */
+  class Director
+  {
+    public:
+      //! Construct new Director. Needs the Ruby object so that the
+      //  proxy class can call methods on that object.
+      Director(Object self);
+
+      virtual ~Director() { }
+
+      //! 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;
+
+      //! Get the Ruby object linked to this C++ instance
+      Object getSelf() const { return self_; }
+
+    private:
+
+      // Save the Ruby object related to the instance of this class
+      Object self_;
+
+  };
+}
+
+#endif // Rice__Director__hpp_

data/rice/Enum.hpp

@@ -0,0 +1,117 @@
+#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"
+
+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
+   */
+  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);
+
+} // namespace Rice
+
+#include "Enum.ipp"
+
+#endif // Rice__Enum__hpp_
+

data/rice/Enum.ipp

@@ -0,0 +1,246 @@
+#ifndef Rice__Enum__ipp_
+#define Rice__Enum__ipp_
+
+#include "Data_Object.hpp"
+#include "Class.hpp"
+#include "String.hpp"
+#include "protect.hpp"
+#include <memory>
+
+template<typename Enum_T>
+long Rice::Default_Enum_Traits<Enum_T>::as_long(Enum_T value)
+{
+  return static_cast<long>(value);
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Enum<Enum_T, Enum_Traits>::
+Enum()
+  : Module_impl<Data_Type<Enum_T>, Enum<Enum_T, Enum_Traits> >()
+  , enums_()
+  , enums_guard_(&enums_)
+  , names_()
+  , names_guard_(&names_)
+{
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Enum<Enum_T, Enum_Traits>::
+Enum(
+    char const * name,
+    Module module)
+  : Module_impl<Data_Type<Enum_T>, Enum<Enum_T, Enum_Traits> >()
+  , enums_()
+  , enums_guard_(&enums_)
+  , names_()
+  , names_guard_(&names_)
+{
+  this->template bind<void>(initialize(name, module));
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Enum<Enum_T, Enum_Traits>::
+Enum(Enum<Enum_T, Enum_Traits> const & other)
+  : Module_impl<Data_Type<Enum_T>, Enum<Enum_T, Enum_Traits> >(other)
+  , enums_(other.enums_)
+  , enums_guard_(&enums_)
+  , names_(other.names_)
+  , names_guard_(&names_)
+{
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Enum<Enum_T, Enum_Traits> & Rice::Enum<Enum_T, Enum_Traits>::
+operator=(Rice::Enum<Enum_T, Enum_Traits> const & other)
+{
+  Rice::Enum<Enum_T, Enum_Traits> tmp(other);
+  this->swap(tmp);
+  return *this;
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Enum<Enum_T, Enum_Traits>::
+~Enum()
+{
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Enum<Enum_T, Enum_Traits> & Rice::Enum<Enum_T, Enum_Traits>::
+initialize(
+    char const * name,
+    Module module)
+{
+  Class c = Rice::define_class_under<Enum_T>(module, name)
+    .define_method("to_s", to_s)
+    .define_method("to_i", to_i)
+    .define_method("inspect", inspect)
+    .define_method("<=>", compare)
+    .define_method("hash", hash)
+    .define_method("eql?", eql)
+    .define_method("==", eql)
+    .define_method("===", eql)
+    .define_singleton_method("each", each)
+    .define_singleton_method("from_int", from_int)
+    .include_module(rb_mComparable);
+
+  // TODO: This should be unnecessary (it should be taken care of when
+  // define_class_under binds the C++ and ruby types)
+  this->set_value(c);
+
+  protect(rb_iv_set, c, "enums", enums_);
+  protect(rb_iv_set, c, "names", names_);
+
+  return *this;
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Enum<Enum_T, Enum_Traits> & Rice::Enum<Enum_T, Enum_Traits>::
+define_value(
+    char const * name,
+    Enum_T value)
+{
+  std_unique_ptr<Enum_T> copy(new Enum_T(value));
+  Rice::Data_Object<Enum_T> m(copy.get(), *this);
+  copy.release();
+  names_[m] = String(name);
+  this->const_set(name, m);
+  enums_.push(m);
+
+  return *this;
+}
+
+
+template<typename Enum_T, typename Enum_Traits>
+void Rice::Enum<Enum_T, Enum_Traits>::
+swap(Enum<Enum_T, Enum_Traits> & other)
+{
+  Data_Type<Enum_T>::swap(other);
+  enums_.swap(other.enums_);
+  names_.swap(other.names_);
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
+each(Object self)
+{
+  VALUE enums_v = rb_iv_get(self, "enums");
+  Check_Type(enums_v, T_ARRAY);
+  Array enums(enums_v);
+  for(size_t j = 0; j < enums.size(); ++j)
+  {
+    rb_yield(enums[j].value());
+  }
+  return Qnil;
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
+to_s(Object self)
+{
+  Data_Type<Enum_T> klass;
+  Rice::Data_Object<Enum_T> m(self, klass);
+  Object enum_class = rb_class_of(m);
+  Hash names(rb_iv_get(enum_class, "names"));
+  Object name = names[m];
+  if(name.is_nil())
+  {
+    return String::format("INVALID(%d)", Enum_Traits::as_long(*m));
+  }
+  else
+  {
+    return String(name);
+  }
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
+inspect(Object self)
+{
+  return String::format(
+      "#<%s::%s>",
+      String(self.class_of().name()).c_str(),
+      String(to_s(self)).c_str());
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
+compare(Object lhs, Object rhs)
+{
+  if(lhs.class_of() != rhs.class_of())
+  {
+    String lhs_name(lhs.class_of().name());
+    String rhs_name(rhs.class_of().name());
+    rb_raise(
+        rb_eTypeError,
+        "Cannot compare %s to %s",
+        lhs_name.c_str(),
+        rhs_name.c_str());
+  }
+
+  Data_Type<Enum_T> klass;
+  Rice::Data_Object<Enum_T> l(lhs, klass);
+  Rice::Data_Object<Enum_T> r(rhs, klass);
+
+  Enum_T left(*l);
+  Enum_T right(*r);  
+
+  if(left == right)
+  {
+    return INT2NUM(0);
+  }
+  else if(Enum_Traits::as_long(left) < Enum_Traits::as_long(right))
+  {
+    return INT2NUM(-1);
+  }
+  else
+  {
+    return INT2NUM(1);
+  }
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
+eql(Object lhs, Object rhs)
+{
+  using ::from_ruby; // Workaround for g++ 3.3.3
+  bool is_equal = from_ruby<int>(compare(lhs, rhs)) == 0; 
+  return to_ruby(is_equal);
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
+to_i(Object self)
+{
+  Data_Type<Enum_T> klass;
+  Rice::Data_Object<Enum_T> m(self, klass);
+  return LONG2NUM(Enum_Traits::as_long(*m));
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
+hash(Object self)
+{
+  return to_i(self);
+}
+
+template<typename Enum_T, typename Enum_Traits>
+Rice::Object Rice::Enum<Enum_T, Enum_Traits>::
+from_int(Class klass, Object i)
+{
+  using ::from_ruby; // Workaround for g++ 3.3.3
+  Rice::Data_Object<Enum_T> m(
+      new Enum_T(static_cast<Enum_T>(from_ruby<long>(i))),
+      klass);
+  return m.value();
+}
+
+template<typename T>
+Rice::Enum<T> Rice::
+define_enum(
+    char const * name,
+    Module module)
+{
+  return Enum<T>(name, module);
+}
+#endif // Rice__Enum__ipp_
+