rice 3.0.0 → 4.0.3

data/rice/Builtin_Object.hpp

@@ -1,8 +0,0 @@
-#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

@@ -1,50 +0,0 @@
-#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<int Builtin_Type>
-inline Builtin_Object<Builtin_Type>::
-Builtin_Object(Object value)
-  : Object(value)
-  , obj_((RObject*)(value.value()))
-{
-  protect(detail::check_type, value, Builtin_Type);
-}
-
-template<int Builtin_Type>
-inline Builtin_Object<Builtin_Type>::
-Builtin_Object(Builtin_Object<Builtin_Type> const & other)
-  : Object(other.value())
-  , obj_(other.obj_)
-{
-}
-
-template<int Builtin_Type>
-inline void Builtin_Object<Builtin_Type>::
-swap(Builtin_Object<Builtin_Type> & ref)
-{
-  std::swap(obj_, ref.obj_);
-  Object::swap(ref);
-}
-
-} // namespace Rice
-
-#endif // Rice__Builtin_Object__ipp_
-

data/rice/Builtin_Object_defn.hpp

@@ -1,50 +0,0 @@
-#ifndef Rice__Builtin_Object_defn__hpp_
-#define Rice__Builtin_Object_defn__hpp_
-
-#include "Object_defn.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<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);
-
-  RObject & operator*() const { return *obj_; } //!< Return a reference to obj_
-  RObject * operator->() const { return obj_; } //!< Return a pointer to obj_
-  RObject * 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<Builtin_Type> & ref);
-
-private:
-  RObject * obj_;
-};
-
-} // namespace Rice
-
-#endif // Rice__Builtin_Object_defn__hpp_
-

data/rice/Class.cpp

@@ -1,57 +0,0 @@
-#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

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

data/rice/Class.ipp

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

data/rice/Class_defn.hpp

@@ -1,84 +0,0 @@
-#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
- *  \example callbacks/sample_callbacks.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_
-

data/rice/Data_Type.cpp

@@ -1,54 +0,0 @@
-#include "Data_Type.hpp"
-
-Rice::Data_Type_Base::Casters * Rice::Data_Type_Base::casters_ = 0;
-
-Rice::Data_Type_Base::
-Data_Type_Base()
-  : Module_impl<Class, Data_Type_Base>()
-{
-}
-
-Rice::Data_Type_Base::
-Data_Type_Base(VALUE v)
-  : Module_impl<Class, Data_Type_Base>(v)
-{
-}
-
-Rice::Data_Type_Base::
-~Data_Type_Base()
-{
-}
-
-Rice::Data_Type_Base::Casters &
-Rice::Data_Type_Base::
-casters()
-{
-  // Initialize the casters_ if it is null
-  if (!casters_)
-  {
-    // First, see if it has been previously registered with the
-    // interpreter (possibly by another extension)
-    Class object(rb_cObject);
-    Object casters_object(object.attr_get("__rice_casters__"));
-
-    if (casters_object.is_nil())
-    {
-      // If it is unset, then set it for the first time
-      Data_Object<Casters> casters(
-          new Casters,
-          rb_cObject);
-      object.iv_set("__rice_casters__", casters);
-      casters_ = casters.get();
-    }
-    else
-    {
-      // If it is set, then use the existing value
-      Data_Object<Casters> casters(
-          casters_object);
-      casters_ = casters.get();
-    }
-  }
-
-  return *casters_;
-}
-

data/rice/Data_Type_fwd.hpp

@@ -1,12 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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/Exception.cpp

@@ -1,54 +0,0 @@
-#include "Exception.hpp"
-#include "protect.hpp"
-#include "to_from_ruby.hpp"
-#include "detail/ruby.hpp"
-
-#include <stdarg.h>
-#define va_init_list(a,b) va_start(a,b)
-
-Rice::Exception::
-Exception(VALUE e)
-  : Exception_Base(e)
-  , message_(Qnil)
-  , message_guard_(&message_)
-{
-}
-
-Rice::Exception::
-Exception(Exception const & other)
-  : Exception_Base(other)
-  , message_(other.message_)
-  , message_guard_(&message_)
-{
-}
-
-Rice::Exception::
-Exception(Object exc, char const * fmt, ...)
-  : Exception_Base(Qnil)
-  , message_(Qnil)
-  , message_guard_(&message_)
-{
-  va_list args;
-  char buf[BUFSIZ];
-
-  va_init_list(args, fmt);
-  vsnprintf(buf, BUFSIZ, fmt, args);
-  buf[BUFSIZ - 1] = '\0';
-  va_end(args);
-
-  set_value(protect(rb_exc_new2, exc, buf));
-}
-
-Rice::String Rice::Exception::
-message() const
-{
-  return protect(rb_funcall, value(), rb_intern("message"), 0);
-}
-
-char const * Rice::Exception::
-what() const throw()
-{
-  message_ = message();
-  return from_ruby<char const *>(message_);
-}
-

data/rice/Exception_Base.hpp

@@ -1,8 +0,0 @@
-#ifndef Rice__Exception_Base__hpp_
-#define Rice__Exception_Base__hpp_
-
-#include "Exception_Base_defn.hpp"
-#include "Exception_Base.ipp"
-
-#endif // Rice__Exception_Base__hpp_
-

data/rice/Exception_Base.ipp

@@ -1,13 +0,0 @@
-#include "Object.hpp"
-
-inline Rice::Exception_Base::
-Exception_Base(VALUE v)
-  : Object(v)
-{
-}
-
-inline Rice::Exception_Base::
-~Exception_Base() throw()
-{
-}
-

data/rice/Exception_Base_defn.hpp

@@ -1,27 +0,0 @@
-#ifndef Rice__Exception_Base_defn__hpp_
-#define Rice__Exception_Base_defn__hpp_
-
-#include "Object_defn.hpp"
-
-namespace Rice
-{
-
-//! An abstract interface for Exception
-/*! This class exists to prevent a circular reference between
- *  Exception.hpp and ruby_try_catch.hpp
- */
-class Exception_Base
-  : public std::exception
-  , public Object
-{
-public:
-  Exception_Base(VALUE v);
-
-  virtual ~Exception_Base() throw() = 0;
-
-  virtual char const * what() const throw() = 0;
-};
-
-} // Rice
-
-#endif // Rice__Exception_Base_defn__hpp_

data/rice/Hash.hpp

@@ -1,230 +0,0 @@
-#ifndef Rice__Hash__hpp_
-#define Rice__Hash__hpp_
-
-#include "Builtin_Object_defn.hpp"
-#include "Array.hpp"
-#include "to_from_ruby_defn.hpp"
-#include "detail/ruby.hpp"
-#include <iterator>
-#include <type_traits>
-
-namespace Rice
-{
-
-//! A wrapper for the ruby Hash class.
-//! This class provides a C++-style interface to ruby's Hash class and
-//! its associated rb_hash_* functions.
-//! Example:
-//! \code
-//!   Hash h;
-//!   h[42] = String("foo");
-//!   h[10] = String("bar");
-//!   std::cout << String(h[42]) << std::endl;
-//! \endcode
-class Hash
-  : public Builtin_Object<T_HASH>
-{
-public:
-  //! Construct a new hash.
-  Hash();
-
-  //! Wrap an existing hash.
-  /*! \param v the hash to wrap.
-   */
-  Hash(Object v);
-
-  //! Return the number of elements in the hash.
-  size_t size() const;
-
-private:
-  //! A helper class so hash[key]=value can work.
-  class Proxy;
-
-public:
-  //! Get the value for the given key.
-  /*! \param key the key whose value should be retrieved from the hash.
-   *  \return the value associated with the given key.
-   */
-  template<typename Key_T>
-  Proxy const operator[](Key_T const & key) const;
-
-  //! Get the value for the given key.
-  /*! \param key the key whose value should be retrieved from the hash.
-   *  \return the value associated with the given key.
-   */
-  template<typename Key_T>
-  Proxy operator[](Key_T const & key);
-
-  //! Get the value for the given key
-  /*! The returned value is converted to the type given by Value_T.
-   *  \param key the key whose value should be retrieved from the hash.
-   *  \return the value associated with the given key, converted to C++
-   *  type Value_T.
-   */
-  template<typename Value_T, typename Key_T>
-  Value_T get(Key_T const & key);
-
-  //! A helper class for dereferencing iterators
-  class Entry;
-
-  //! A helper class for implementing iterators for a Hash.
-  template<typename Hash_Ref_T, typename Value_T>
-  class Iterator;
-
-public:
-  //! An iterator.
-  typedef Iterator<Hash &, Entry> iterator;
-
-  //! A const iterator.
-  typedef Iterator<Hash const &, Entry const> const_iterator;
-
-public:
-  //! Return an iterator to the beginning of the hash.
-  iterator begin();
-
-  //! Return a const iterator to the beginning of the hash.
-  const_iterator begin() const;
-
-  //! Return an iterator to the end of the hash.
-  iterator end();
-
-  //! Return a const to the end of the hash.
-  const_iterator end() const;
-};
-
-//! A helper class so hash[key]=value can work.
-class Hash::Proxy
-{
-public:
-  //! Construct a new Proxy.
-  Proxy(Hash hash, Object key);
-
-  //! Implicit conversion to Object.
-  operator Object() const;
-
-  //! Explicit conversion to VALUE.
-  VALUE value() const;
-
-  //! Assignment operator.
-  template<typename T>
-  Object operator=(T const & value);
-
-  void swap(Proxy & proxy);
-
-private:
-  Hash hash_;
-  Object key_;
-};
-
-//! A helper class for dereferencing iterators
-/*! This class is intended to look similar to an std::pair.
- */
-class Hash::Entry
-{
-public:
-  //! Construct a new Entry.
-  Entry(Hash hash, Object key);
-
-  //! Copy constructor.
-  Entry(Entry const & entry);
-
-  Object const key;          //!< The key
-  Object const & first;      //!< An alias for the key
-
-  Proxy value;              //!< The value
-  Proxy & second;           //!< An alias for the value
-
-  Entry & operator=(Entry const & rhs);
-
-  void swap(Entry & entry);
-
-  friend bool operator<(Entry const & lhs, Entry const & rhs);
-};
-
-bool operator<(Hash::Entry const & lhs, Hash::Entry const & rhs);
-
-//! A helper class for implementing iterators for a Hash.
-template<typename Hash_Ref_T, typename Value_T>
-class Hash::Iterator
-{
-public:
-  using iterator_category = std::input_iterator_tag;
-  using value_type = Value_T;
-  using difference_type = long;
-  using pointer = Object*;
-  using reference = Value_T&;
-
-  //! Construct a new Iterator.
-  Iterator(Hash_Ref_T hash);
-
-  //! Construct a new Iterator with a given start-at index point
-  Iterator(Hash_Ref_T hash, int start_at);
-
-  //! Copy construct an Iterator.
-  Iterator(Iterator const & iterator);
-
-  //! Construct an Iterator from another Iterator of a different const
-  //! qualification.
-  template<typename Iterator_T>
-  Iterator(Iterator_T const & iterator);
-
-  //! Assignment operator.
-  Iterator & operator=(Iterator const & rhs);
-
-  //! Preincrement operator.
-  Iterator & operator++();
-
-  //! Postincrement operator.
-  Iterator operator++(int);
-
-  //! Dereference operator.
-  Value_T operator*();
-
-  //! Dereference operator.
-  Value_T * operator->();
-
-  //! Equality operator.
-  bool operator==(Iterator const & rhs) const;
-
-  //! Inequality operator.
-  bool operator!=(Iterator const & rhs) const;
-
-  template<typename Hash_Ref_T_, typename Value_T_>
-  friend class Hash::Iterator;
-
-  //! Swap with another iterator of the same type.
-  void swap(Iterator & iterator);
-
-protected:
-  Object current_key();
-
-  Array hash_keys();
-
-private:
-  Hash hash_;
-  size_t current_index_;
-  VALUE keys_;
-
-  mutable typename std::remove_const<Value_T>::type tmp_;
-};
-
-} // namespace Rice
-
-template<>
-inline
-Rice::Hash from_ruby<Rice::Hash>(Rice::Object x)
-{
-  return Rice::Hash(x);
-}
-
-template<>
-inline
-Rice::Object to_ruby<Rice::Hash>(Rice::Hash const & x)
-{
-  return x;
-}
-
-#include "Hash.ipp"
-
-#endif // Rice__Hash__hpp_
-