rice 3.0.0 → 4.0.0

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_