wurlinc-rice 1.4.0.1

data/rice/Address_Registration_Guard.hpp

@@ -0,0 +1,7 @@
+#ifndef Rice__Address_Registration_Guard__hpp_
+#define Rice__Address_Registration_Guard__hpp_
+
+#include "Address_Registration_Guard_defn.hpp"
+#include "Address_Registration_Guard.ipp"
+
+#endif // Rice__Address_Registration_Guard__hpp_

data/rice/Address_Registration_Guard.ipp

@@ -0,0 +1,34 @@
+#include "Object.hpp"
+#include <algorithm>
+
+inline Rice::Address_Registration_Guard::
+Address_Registration_Guard(VALUE * address)
+  : address_(address)
+{
+  rb_gc_register_address(address);
+}
+
+inline Rice::Address_Registration_Guard::
+Address_Registration_Guard(Object * object)
+  : address_(const_cast<VALUE *>(&object->value()))
+{
+  rb_gc_register_address(address_);
+}
+
+inline Rice::Address_Registration_Guard::
+~Address_Registration_Guard()
+{
+  rb_gc_unregister_address(address_);
+}
+
+inline VALUE * Rice::Address_Registration_Guard::
+address() const
+{
+  return address_;
+}
+
+inline void Rice::Address_Registration_Guard::
+swap(Rice::Address_Registration_Guard & other)
+{
+  std::swap(address_, other.address_);
+}

data/rice/Address_Registration_Guard_defn.hpp

@@ -0,0 +1,65 @@
+#ifndef Rice__Address_Registration_Guard_defn__hpp_
+#define Rice__Address_Registration_Guard_defn__hpp_
+
+#include "Object_defn.hpp"
+#include "detail/ruby.hpp"
+#include "detail/Not_Copyable.hpp"
+
+namespace Rice
+{
+
+//! A guard to register a given address with the GC.
+/*! Calls rb_gc_register_address upon construction and
+ *  rb_gc_unregister_address upon destruction.
+ *  For example:
+ *  \code
+ *    Class Foo
+ *    {
+ *    public:
+ *      Foo()
+ *        : string_(rb_str_new2())
+ *        , guard_(&string_);
+ * 
+ *    private:
+ *      VALUE string_;
+ *      Address_Registration_Guard guard_;
+ *    };
+ *  \endcode
+ */
+class Address_Registration_Guard
+  : private detail::Not_Copyable
+{
+public:
+  //! Register an address with the GC.
+  /*  \param address The address to register with the GC.  The address
+   *  must point to a valid ruby object (RObject).
+   */
+  Address_Registration_Guard(VALUE * address);
+
+  //! Register an Object with the GC.
+  /*! \param object The Object to register with the GC.  The object must
+   *  not be destroyed before the Address_Registration_Guard is
+   *  destroyed.
+   */
+  Address_Registration_Guard(Object * object);
+
+  //! Unregister an address/Object with the GC.
+  /*! Destruct an Address_Registration_Guard.  The address registered
+   *  with the Address_Registration_Guard when it was constructed will
+   *  be unregistered from the GC.
+   */
+  ~Address_Registration_Guard();
+
+  //! Get the address that is registered with the GC.
+  VALUE * address() const;
+
+  //! Swap with another Address_Registration_Guard.
+  void swap(Address_Registration_Guard & other);
+
+private:
+  VALUE * address_;
+};
+
+} // namespace Rice
+
+#endif // Rice__Address_Registration_Guard_defn__hpp_

data/rice/Allocation_Strategies.hpp

@@ -0,0 +1,37 @@
+#ifndef Rice__Default_Allocation_Strategy__hpp_
+#define Rice__Default_Allocation_Strategy__hpp_
+
+#include "detail/ruby.hpp"
+
+/*! \file
+ *  \brief Strategies for allocation/deallocation of objects.
+ */
+
+namespace Rice
+{
+
+template<typename T>
+struct Default_Allocation_Strategy
+{
+  //! Allocate an object using operator new.
+  static T * allocate() { return new T; }
+
+  //! Delete obj using the delete operator.
+  static void free(T * obj) { delete obj; }
+};
+
+template<typename T>
+struct Xmalloc_Allocation_Strategy
+{
+  //! Allocate an array of objects using operator new and xmalloc.
+  static T * allocate() { T * obj = static_cast<T *>(::xmalloc(sizeof(T))); new(obj) T; return obj; }
+
+  //! Delete obj by calling the destructor explicitly and calling xfree.
+  static void free(T * obj) { obj->~T(); ::xfree(obj); }
+};
+
+// TODO: array allocation
+
+} // namespace Rice
+
+#endif // Rice__Default_Allocation_Strategy__hpp_

data/rice/Arg.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__Arg__hpp_
+#define Rice__Arg__hpp_
+
+#include "Arg_impl.hpp"
+#include "detail/Arguments.hpp"
+#include "Arg_operators.hpp"
+
+#endif // Rice__Arg__hpp_

data/rice/Arg_impl.hpp

@@ -0,0 +1,127 @@
+#ifndef Rice__Arg_Impl_hpp_
+#define Rice__Arg_Impl_hpp_
+
+namespace Rice {
+
+  //! Helper for defining default arguments of a method
+  /*! This class exposes the ability to define the default values of a
+   *  wrapped method. Inspired by how Boost.Python handles keyword and
+   *  default arguments, the syntax is simple:
+   *
+   *    define_method(
+   *      "method",
+   *      &method,
+   *      (Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true)
+   *    );
+   *
+   *  which means "for method &method, it takes 3 arguments
+   *  [arg1, arg2, arg3]. Of these arguments, arg2's default is 3
+   *  and arg3's default is true.
+   *
+   *  It may be required to explicitly cast the type of the default
+   *  value to prevent compilation errors.
+   */
+  class Arg
+  {
+    public:
+      //! Initialize a new Arg with the name of the argument
+      /*! We require the name of the argument because 1) it makes code
+       *  easier to read and 2) hopefully Ruby gets keyword arguments
+       *  in the future and this means Rice will be ready for it.
+       */
+      Arg(const char* name)
+        : name_(name)
+        , defaultValue(0)
+      {}
+
+      //! Copy Constructor
+      Arg(const Arg& other)
+        : name_(other.name()),
+          defaultValue(other.defaultValue ? other.defaultValue->clone() : 0)
+      {}
+
+      virtual ~Arg()
+      {
+        if(defaultValue) {
+          delete defaultValue;
+        }
+      }
+
+      //! Set the default value for this Arg
+      /*! Set the default value for this argument.
+       *  If this isn't called on this Arg, then this
+       *  Arg is required in the method call.
+       *
+       *  \param val the value to store as default
+       */
+      template<typename Arg_Type>
+      Arg& operator=(Arg_Type val)
+      {
+        defaultValue = new type<Arg_Type>(val);
+        return *this;
+      }
+
+      //! Check if this Arg has a default value associated with it
+      bool hasDefaultValue() const {
+        return defaultValue != 0;
+      }
+
+      //! Return the default value associated with this Arg
+      /*! \return the type saved to this Arg
+       */
+      template<typename Arg_Type>
+      Arg_Type getDefaultValue()
+      {
+        return static_cast< type<Arg_Type>* >(defaultValue)->held;
+      }
+
+      //! Get the name of this Arg
+      const char* name() const
+      {
+        return name_;
+      }
+
+    private:
+
+      //! Name of the argument
+      const char* name_;
+
+      /**
+       * The following is a stripped down version of
+       * Boost.Any.
+       */
+
+      class type_base
+      {
+        public:
+          virtual ~type_base() {}
+          virtual type_base* clone() const = 0;
+      };
+
+      template<typename Type>
+      class type : public type_base
+      {
+        public:
+          type(Type value)
+            :held(value)
+          {}
+
+          virtual ~type() { }
+
+          virtual type_base* clone() const
+          {
+            return new type(held);
+          }
+
+          Type held;
+      };
+
+    public:
+
+      //! Our saved default value
+      type_base* defaultValue;
+  };
+
+}
+
+#endif // Rice__Arg_Impl_hpp_

data/rice/Arg_operators.cpp

@@ -0,0 +1,21 @@
+#include "Arg_impl.hpp"
+#include "detail/Arguments.hpp"
+#include "Arg_operators.hpp"
+
+namespace Rice {
+
+  Arguments* operator,(Arg arg1, Arg arg2)
+  {
+    Arguments* a = new Arguments();
+    a->add(arg1);
+    a->add(arg2);
+    return a;
+  }
+
+  Arguments* operator,(Arguments* arguments, Arg arg)
+  {
+    arguments->add(arg);
+    return arguments;
+  }
+
+}

data/rice/Arg_operators.hpp

@@ -0,0 +1,19 @@
+#ifndef Rice__Arg_Operators_hpp_
+#define Rice__Arg_Operators_hpp_
+
+namespace Rice
+{
+
+  //! Build the list of Arg objects into an Arguments object
+  /*! Take a list of Arg objects and build up a single Argument
+   *  object used later in method dispatch
+   */
+  Arguments* operator,(Arg arg1, Arg arg2);
+
+  /*! @see operator,(Arg, Arg)
+   */
+  Arguments* operator,(Arguments* arguments, Arg arg);
+
+}
+
+#endif // Rice__Arg_Operators_hpp_

data/rice/Array.hpp

@@ -0,0 +1,220 @@
+#ifndef Rice__Array__hpp_
+#define Rice__Array__hpp_
+
+#include "Builtin_Object.hpp"
+#include "to_from_ruby_defn.hpp"
+#include "detail/ruby.hpp"
+#include <iterator>
+
+namespace Rice
+{
+
+//! A wrapper for the ruby Array class.
+/*! This class provides a C++-style interface to ruby's Array class and
+ *  its associated rb_ary_* functions.
+ *  Example:
+ *  \code
+ *    Array a;
+ *    a.push(String("some string"));
+ *    a.push(42);
+ *  \endcode
+ */
+class Array
+  : public Builtin_Object<RArray, T_ARRAY>
+{
+public:
+  //! Construct a new array
+  Array();
+
+  //! Wrap an existing array
+  /*! \param v a ruby object, which must be of type T_ARRAY.
+   */
+  Array(Object v);
+
+  //! Wrap an existing array
+  /*! \param v a ruby object, which must be of type T_ARRAY.
+   */
+  Array(VALUE v);
+
+  //! Construct an array from a sequence.
+  /*! \param begin an iterator to the beginning of the sequence.
+   *  \param end an iterator to the end of the sequence.
+   */
+  template<typename Iter_T>
+  Array(Iter_T begin, Iter_T end);
+
+  //! Construct an Array from a C array.
+  /*! \param a a C array of type T and size n.
+   */
+  template<typename T, size_t n>
+  Array(T const (& a)[n]);
+
+public:
+  //! Return the size of the array.
+  size_t size() const;
+
+  //! Return the element at the given index.
+  /*! \param index The index of the desired element.  The index may be
+   *  negative, to indicate an offset from the end of the array.  If the
+   *  index is out of bounds, this function has undefined behavior.
+   *  \return the element at the given index.
+   */
+  Object operator[](ptrdiff_t index) const;
+
+private:
+  //! A helper class so array[index]=value can work.
+  class Proxy;
+
+public:
+  //! Return a reference to the element at the given index.
+  /*! \param index The index of the desired element.  The index may be
+   *  negative, to indicate an offset from the end of the array.  If the
+   *  index is out of bounds, this function has undefined behavior.
+   *  \return the element at the given index.
+   */
+  Proxy operator[](ptrdiff_t index);
+
+  //! Push an element onto the end of the array
+  /*! \param v an object to push onto the array.
+   *  \return the object which was pushed onto the array.
+   */
+  template<typename T>
+  Object push(T const & obj);
+
+  //! Pop an element from the end of the array
+  /*! \return the object which was popped from the array, or Qnil if
+   *  the array was empty.
+   */
+  Object pop();
+
+  //! Unshift an element onto the beginning of the array
+  /*! \param v an object to unshift onto the array.
+   *  \return the object which was unshifted onto the array.
+   */
+  template<typename T>
+  Object unshift(T const & obj);
+
+  //! Shift an element from the beginning of the array
+  /*! \return the object which was shifted from the array.
+   */
+  Object shift();
+
+  //! Return a pointer to the beginning of the underlying C array.
+  //! Use with caution!
+  /*! \return a pointer to the beginning of the array.
+   */
+  VALUE * to_c_array();
+
+private:
+  template<typename Array_Ref_T, typename Value_T>
+  class Iterator;
+
+  size_t position_of(ptrdiff_t index) const;
+
+public:
+  //! An iterator.
+  typedef Iterator<Array &, Proxy> iterator;
+
+  //! A const iterator.
+  typedef Iterator<Array const &, Object> const_iterator;
+
+  //! Return an iterator to the beginning of the array.
+  iterator begin();
+
+  //! Return a const iterator to the beginning of the array.
+  const_iterator begin() const;
+
+  //! Return an iterator to the end of the array.
+  iterator end();
+
+  //! Return a const iterator to the end of the array.
+  const_iterator end() const;
+};
+
+//! A helper class so array[index]=value can work.
+class Array::Proxy
+{
+public:
+  //! Construct a new Proxy
+  Proxy(Array array, size_t index);
+
+  //! Implicit conversion to Object.
+  operator Object() const;
+
+  //! Explicit conversion to VALUE.
+  VALUE value() const;
+
+  //! Assignment operator.
+  template<typename T>
+  Object operator=(T const & value);
+
+private:
+  Array array_;
+  size_t index_;
+};
+
+//! A helper class for implementing iterators for a Array.
+// TODO: This really should be a random-access iterator.
+template<typename Array_Ref_T, typename Value_T>
+class Array::Iterator
+  : public std::iterator<
+      std::forward_iterator_tag,
+      Value_T,            // Type
+      ptrdiff_t,          // Distance type
+      Object *,           // Pointer type
+      Value_T &>          // Reference type
+{
+public:
+  Iterator(Array_Ref_T array, size_t index);
+
+  template<typename Array_Ref_T_, typename Value_T_>
+  Iterator(Iterator<Array_Ref_T_, Value_T_> const & rhs);
+
+  template<typename Array_Ref_T_, typename Value_T_>
+  Iterator & operator=(Iterator<Array_Ref_T_, Value_T_> const & rhs);
+
+  Iterator & operator++();
+  Iterator operator++(int);
+  Value_T operator*();
+  Object * operator->();
+
+  template<typename Array_Ref_T_, typename Value_T_>
+  bool operator==(Iterator<Array_Ref_T_, Value_T_> const & rhs) const;
+
+  template<typename Array_Ref_T_, typename Value_T_>
+  bool operator!=(Iterator<Array_Ref_T_, Value_T_> const & rhs) const;
+
+  // Causes ICE on g++ 3.3.3
+  // template<typename Array_Ref_T_, typename Value_T_>
+  // friend class Iterator;
+
+  Array_Ref_T array() const;
+  size_t index() const;
+
+private:
+  Array_Ref_T array_;
+  size_t index_;
+
+  Object tmp_;
+};
+
+} // namespace Rice
+
+template<>
+inline
+Rice::Array from_ruby<Rice::Array>(Rice::Object x)
+{
+  return Rice::Array(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<Rice::Array>(Rice::Array const & x)
+{
+  return x;
+}
+
+#include "Array.ipp"
+
+#endif // Rice__Array__hpp_
+