wurlinc-rice 1.4.0.1

data/rice/Array.ipp

@@ -0,0 +1,263 @@
+#ifndef Rice__Array__ipp_
+#define Rice__Array__ipp_
+
+#include "protect.hpp"
+
+inline Rice::Array::
+Array()
+  : Builtin_Object<RArray, T_ARRAY>(protect(rb_ary_new))
+{
+}
+
+inline Rice::Array::
+Array(Object v)
+  : Builtin_Object<RArray, T_ARRAY>(v)
+{
+}
+
+inline Rice::Array::
+Array(VALUE v)
+  : Builtin_Object<RArray, T_ARRAY>(v)
+{
+}
+
+template<typename Iter_T>
+inline Rice::Array::
+Array(Iter_T it, Iter_T end)
+  : Builtin_Object<RArray, T_ARRAY>(protect(rb_ary_new))
+{
+  for(; it != end; ++it)
+  {
+    push(*it);
+  }
+}
+
+template<typename T, size_t n>
+inline Rice::Array::
+Array(T const (& a)[n])
+  : Builtin_Object<RArray, T_ARRAY>(protect(rb_ary_new))
+{
+  for(size_t j = 0; j < n; ++j)
+  {
+    push(a[j]);
+  }
+}
+
+inline size_t Rice::Array::
+size() const
+{
+  return RARRAY_LEN(this->value());
+}
+
+inline Rice::Object Rice::Array::
+operator[](ptrdiff_t index) const
+{
+  VALUE * ptr = RARRAY_PTR(this->value());
+  return ptr[position_of(index)];
+}
+
+inline Rice::Array::Proxy Rice::Array::
+operator[](ptrdiff_t index)
+{
+  return Proxy(*this, position_of(index));
+}
+
+template<typename T>
+inline Rice::Object Rice::Array::
+push(T const & obj)
+{
+  return protect(rb_ary_push, value(), to_ruby(obj));
+}
+
+inline Rice::Object Rice::Array::
+pop()
+{
+  return protect(rb_ary_pop, value());
+}
+
+template<typename T>
+inline Rice::Object Rice::Array::
+unshift(T const & obj)
+{
+  return protect(rb_ary_unshift, value(), to_ruby(obj));
+}
+
+inline Rice::Object Rice::Array::
+shift()
+{
+  return protect(rb_ary_shift, value());
+}
+
+inline VALUE * Rice::Array::
+to_c_array()
+{
+  return RARRAY_PTR(this->value());
+}
+
+inline size_t Rice::Array::
+position_of(ptrdiff_t index) const
+{
+  if(index < 0)
+  {
+    return size() + index;
+  }
+  else
+  {
+    return static_cast<size_t>(index);
+  }
+}
+
+inline Rice::Array::Proxy::
+Proxy(Array array, size_t index)
+  : array_(array)
+  , index_(index)
+{
+}
+
+inline Rice::Array::Proxy::
+operator Rice::Object() const
+{
+  return RARRAY_PTR(array_.value())[index_];
+}
+
+inline VALUE Rice::Array::Proxy::
+value() const
+{
+  return RARRAY_PTR(array_.value())[index_];
+}
+
+template<typename T>
+Rice::Object Rice::Array::Proxy::
+operator=(T const & value)
+{
+  Object o = to_ruby(value);
+  RARRAY_PTR(array_.value())[index_] = o.value();
+  return o;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Rice::Array::Iterator<Array_Ref_T, Value_T>::
+Iterator(Array_Ref_T array, size_t index)
+  : array_(array)
+  , index_(index)
+{
+}
+
+template<typename Array_Ref_T, typename Value_T>
+template<typename Array_Ref_T_, typename Value_T_>
+inline
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+Iterator(Iterator<Array_Ref_T_, Value_T_> const & rhs)
+  : array_(rhs.array())
+  , index_(rhs.index())
+  , tmp_()
+{
+}
+
+template<typename Array_Ref_T, typename Value_T>
+template<typename Array_Ref_T_, typename Value_T_>
+inline Rice::Array::Iterator<Array_Ref_T, Value_T> &
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator=(Iterator<Array_Ref_T_, Value_T_> const & rhs)
+{
+  array_ = rhs.array_;
+  index_ = rhs.index_;
+  return *this;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Rice::Array::Iterator<Array_Ref_T, Value_T> &
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator++()
+{
+  ++index_;
+  return *this;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Rice::Array::Iterator<Array_Ref_T, Value_T>
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator++(int)
+{
+  Array copy(*this);
+  ++(*this);
+  return *this;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Value_T
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator*()
+{
+  return array_[index_];
+}
+
+template<typename Array_Ref_T, typename Value_T>
+inline Rice::Object *
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator->()
+{
+  tmp_ = array_[index_];
+  return &tmp_;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+template<typename Array_Ref_T_, typename Value_T_>
+inline bool
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator==(Iterator<Array_Ref_T_, Value_T_> const & rhs) const
+{
+  return array_.value() == rhs.array_.value() && index_ == rhs.index_;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+template<typename Array_Ref_T_, typename Value_T_>
+inline bool
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+operator!=(Iterator<Array_Ref_T_, Value_T_> const & rhs) const
+{
+  return !(*this == rhs);
+}
+
+template<typename Array_Ref_T, typename Value_T>
+Array_Ref_T
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+array() const
+{
+  return array_;
+}
+
+template<typename Array_Ref_T, typename Value_T>
+size_t
+Rice::Array::Iterator<Array_Ref_T, Value_T>::
+index() const
+{
+  return index_;
+}
+
+inline Rice::Array::iterator Rice::Array::
+begin()
+{
+  return iterator(*this, 0);
+}
+
+inline Rice::Array::const_iterator Rice::Array::
+begin() const
+{
+  return const_iterator(*this, 0);
+}
+
+inline Rice::Array::iterator Rice::Array::
+end()
+{
+  return iterator(*this, size());
+}
+
+inline Rice::Array::const_iterator Rice::Array::
+end() const
+{
+  return const_iterator(*this, size());
+}
+
+#endif // Rice__Array__ipp_
+

data/rice/Builtin_Object.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__Builtin_Object__hpp_
+#define Rice__Builtin_Object__hpp_
+
+#include "Builtin_Object_defn.hpp"
+#include "Builtin_Object.ipp"
+
+#endif // Rice__Builtin_Object__hpp_
+

data/rice/Builtin_Object.ipp

@@ -0,0 +1,50 @@
+#ifndef Rice__Builtin_Object__ipp_
+#define Rice__Builtin_Object__ipp_
+
+#include "Object.hpp"
+#include "protect.hpp"
+#include "detail/check_ruby_type.hpp"
+
+#include <algorithm>
+
+namespace Rice
+{
+
+namespace detail
+{
+  inline VALUE check_type(Object value, int type)
+  {
+    rb_check_type(value, type);
+    return Qnil;
+  }
+}
+
+template<typename T, int Builtin_Type>
+inline Builtin_Object<T, Builtin_Type>::
+Builtin_Object(Object value)
+  : Object(value)
+  , obj_((T*)(value.value()))
+{
+  protect(detail::check_type, value, Builtin_Type);
+}
+
+template<typename T, int Builtin_Type>
+inline Builtin_Object<T, Builtin_Type>::
+Builtin_Object(Builtin_Object<T, Builtin_Type> const & other)
+  : Object(other.value())
+  , obj_(other.obj_)
+{
+}
+
+template<typename T, int Builtin_Type>
+inline void Builtin_Object<T, Builtin_Type>::
+swap(Builtin_Object<T, Builtin_Type> & ref)
+{
+  std::swap(obj_, ref.obj_);
+  Object::swap(ref);
+}
+
+} // namespace Rice
+
+#endif // Rice__Builtin_Object__ipp_
+

data/rice/Builtin_Object_defn.hpp

@@ -0,0 +1,51 @@
+#ifndef Rice__Builtin_Object_defn__hpp_
+#define Rice__Builtin_Object_defn__hpp_
+
+#include "Object_defn.hpp"
+#include "Allocation_Strategies.hpp"
+#include "detail/ruby.hpp"
+
+namespace Rice
+{
+
+//! A smartpointer-like wrapper for Ruby builtin objects.
+/*! A builtin object is one of Ruby's internal types, e.g. RArray or
+ *  RString.  Every builtin type structure has a corresponding integer
+ *  type number (e.g T_ARRAY for RArray or T_STRING for RString).  This
+ *  class is a wrapper for those types of objects, primarily useful as a
+ *  base class for other wrapper classes like Array and Hash.
+ */
+template<typename T, int Builtin_Type>
+class Builtin_Object
+  : public Object
+{
+public:
+  //! Wrap an already allocated Ruby object.
+  /*! Checks to see if the object is an object of type Builtin_Type; a
+   *  C++ exception is thrown if this is not the case.
+   *  \param value the object to be wrapped.
+   */
+  Builtin_Object(Object value);
+
+  //! Make a copy of a Builtin_Object
+  /*! \param other the Builtin_Object to be copied.
+   */
+  Builtin_Object(Builtin_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 builtin object of the same type
+  /*! \param ref the object with which to swap.
+   */
+  void swap(Builtin_Object<T, Builtin_Type> & ref);
+
+private:
+  T * obj_;
+};
+
+} // namespace Rice
+
+#endif // Rice__Builtin_Object_defn__hpp_
+

data/rice/Class.cpp

@@ -0,0 +1,57 @@
+#include "Class.hpp"
+#include "Exception.hpp"
+#include "detail/creation_funcs.hpp"
+
+Rice::Class::
+Class()
+  : Module_impl<Module, Class>()
+{
+}
+
+Rice::Class::
+Class(VALUE v)
+  : Module_impl<Module, Class>(v)
+{
+  if(::rb_type(v) != T_CLASS)
+  {
+    throw Exception(
+        rb_eTypeError,
+        "Expected a Class but got a %s",
+        rb_class2name(CLASS_OF(v))); // TODO: might raise an exception
+  }
+}
+
+Rice::Class & Rice::Class::
+undef_creation_funcs()
+{
+  detail::undef_creation_funcs(*this);
+  return *this;
+}
+
+Rice::Class Rice::
+define_class_under(
+    Rice::Object module,
+    char const * name,
+    Rice::Object superclass)
+{
+  VALUE v = rb_define_class_under(module, name, superclass);
+  return Class(v);
+}
+
+Rice::Class Rice::
+define_class(
+    char const * name,
+    Rice::Object superclass)
+{
+  VALUE v = rb_define_class(name, superclass);
+  return Class(v);
+}
+
+Rice::Class Rice::
+anonymous_class(
+    Rice::Object superclass)
+{
+  VALUE v = Class(rb_cClass).call("new");
+  return Class(v);
+}
+

data/rice/Class.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__Class__hpp_
+#define Rice__Class__hpp_
+
+#include "Class_defn.hpp"
+#include "Class.ipp"
+
+#endif // Rice__Class__hpp_
+

data/rice/Class.ipp

@@ -0,0 +1,6 @@
+#ifndef Rice__Class__ipp_
+#define Rice__Class__ipp_
+
+#include "Module.ipp"
+
+#endif // Rice__Class__ipp_

data/rice/Class_defn.hpp

@@ -0,0 +1,83 @@
+#ifndef Rice__Class_defn__hpp_
+#define Rice__Class_defn__hpp_
+
+#include "Object_defn.hpp"
+#include "Module_impl.hpp"
+#include "Module_defn.hpp"
+#include "to_from_ruby_defn.hpp"
+#include "Identifier.hpp"
+
+/*!
+ *  \example inheritance/animals.cpp
+ */
+
+namespace Rice
+{
+
+//! A helper for defining a Class and its methods.
+/*! This class provides a C++-style interface to ruby's Class class and
+ *  for defining methods on that class.
+ */
+class Class
+  : public Module_impl<Module, Class>
+{
+public:
+  //! Default construct a new class wrapper and initialize it to
+  //! rb_cObject.
+  Class();
+
+  //! Construct a new class wrapper from a ruby object of type T_CLASS.
+  Class(VALUE v);
+
+  //! Disallow creation of an instance from Ruby code.
+  /*! Undefines the singleton method allocate (or new, if using a
+   *  version of ruby prior to 1.7) and the instance method initialize.
+   */
+  Class & undef_creation_funcs();
+};
+
+//! Define a new class in the namespace given by module.
+/*! \param module the Module in which to define the class.
+ *  \param name the name of the class.
+ *  \param superclass the base class to use.
+ *  \return the new class.
+ */
+Class define_class_under(
+    Object module,
+    char const * name,
+    Object superclass = rb_cObject);
+
+//! Define a new class in the default namespace.
+/*! \param name the name of the class.
+ *  \param superclass the base class to use.
+ *  \return the new class.
+ */
+Class define_class(
+    char const * name,
+    Object superclass = rb_cObject);
+
+//! Create a new anonymous class.
+/*! \param superclass the base class to use.
+ *  \return the new class.
+ */
+Class anonymous_class(
+    Object superclass = rb_cObject);
+
+} // namespace Rice
+
+template<>
+inline
+Rice::Class from_ruby<Rice::Class>(Rice::Object x)
+{
+  return Rice::Class(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<Rice::Class>(Rice::Class const & x)
+{
+  return x;
+}
+
+#endif // Rice__Class_defn__hpp_
+