rice 3.0.0 → 4.0.3

data/rice/Module_impl.ipp

@@ -1,345 +0,0 @@
-#include "detail/define_method_and_auto_wrap.hpp"
-#include "Object.hpp"
-#include "Address_Registration_Guard.hpp"
-#include "Data_Object.hpp"
-#include "Data_Type.hpp"
-#include "Symbol.hpp"
-#include "protect.hpp"
-
-#include "Module.hpp"
-#include "Class.hpp"
-#include "Data_Type.hpp"
-
-#include "detail/ruby.hpp"
-#include "detail/method_data.hpp"
-#include "detail/Iterator.hpp"
-
-
-inline
-Rice::Module_base::
-Module_base(VALUE v)
-  : Object(v)
-  , handler_(Qnil)
-  , handler_guard_(&handler_)
-{
-}
-
-inline
-Rice::Module_base::
-Module_base(Module_base const & other)
-  : Object(other)
-  , handler_(other.handler_)
-  , handler_guard_(&handler_)
-{
-}
-
-inline
-Rice::Module_base &
-Rice::Module_base::
-operator=(Module_base const & other)
-{
-  Module_base tmp(other);
-  swap(tmp);
-  return *this;
-}
-
-inline
-void
-Rice::Module_base::
-swap(Module_base & other)
-{
-  std::swap(handler_, other.handler_);
-  Object::swap(other);
-}
-
-template<typename Exception_T, typename Functor_T>
-inline
-void
-Rice::Module_base::
-add_handler(Functor_T functor)
-{
-  Data_Object<detail::Exception_Handler> handler(
-      new detail::
-      Functor_Exception_Handler<Exception_T, Functor_T>(
-          functor,
-          this->handler()),
-      rb_cObject);
-  this->handler_.swap(handler);
-}
-
-inline
-Rice::Object
-Rice::Module_base::
-handler() const
-{
-  if(!handler_.test())
-  {
-    Data_Object<Rice::detail::Default_Exception_Handler> handler(
-        new Rice::detail::Default_Exception_Handler,
-        rb_cObject);
-    handler_.swap(handler);
-  }
-
-  return handler_;
-}
-
-template<typename Base_T, typename Derived_T>
-inline
-Rice::Module_impl<Base_T, Derived_T>::
-Module_impl()
-  : Base_T()
-{
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename T>
-inline
-Rice::Module_impl<Base_T, Derived_T>::
-Module_impl(T const & arg)
-  : Base_T(arg)
-{
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename Exception_T, typename Functor_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-add_handler(
-    Functor_T functor)
-{
-  Module_base::add_handler<Exception_T>(functor);
-  return (Derived_T &)*this;
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename Func_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-define_method(
-    Identifier name,
-    Func_T func,
-    Arguments* arguments)
-{
-  detail::define_method_and_auto_wrap(
-      *this, name, func, this->handler(), arguments);
-  return (Derived_T &)*this;
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename Func_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-define_method(
-    Identifier name,
-    Func_T func,
-    Arg const& arg)
-{
-  Arguments* args = new Arguments();
-  args->add(arg);
-  return define_method(name, func, args);
-}
-
-
-template<typename Base_T, typename Derived_T>
-template<typename Func_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-define_singleton_method(
-    Identifier name,
-    Func_T func,
-    Arguments* arguments)
-{
-  detail::define_method_and_auto_wrap(
-      rb_singleton_class(*this), name, func, this->handler(), arguments);
-  return (Derived_T &)*this;
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename Func_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-define_singleton_method(
-    Identifier name,
-    Func_T func,
-    Arg const& arg)
-{
-  Arguments* args = new Arguments();
-  args->add(arg);
-  return define_singleton_method(name, func, args);
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename Func_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-define_module_function(
-    Identifier name,
-    Func_T func,
-    Arguments* arguments)
-{
-  if(this->rb_type() != T_MODULE)
-  {
-    throw std::runtime_error("can only define module functions for modules");
-  }
-
-  define_method(name, func, arguments);
-  define_singleton_method(name, func, arguments);
-  return (Derived_T &)*this;
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename Func_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-define_module_function(
-    Identifier name,
-    Func_T func,
-    Arg const& arg)
-{
-  Arguments* args = new Arguments();
-  args->add(arg);
-  return define_module_function(name, func, args);
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename T, typename Iterator_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-define_iterator(
-    Iterator_T (T::*begin)(),
-    Iterator_T (T::*end)(),
-    Identifier name)
-{
-  detail::define_iterator(*this, name, begin, end);
-  return (Derived_T &)*this;
-}
-
-namespace Rice
-{
-
-namespace detail
-{
-
-inline VALUE
-  include_module(VALUE mod, VALUE inc)
-{
-  rb_include_module(mod, inc);
-  return Qnil;
-}
-
-inline VALUE
-const_set(VALUE mod, ID name, VALUE value)
-{
-  rb_const_set(mod, name, value);
-  return Qnil;
-}
-
-} // namespace detail
-
-} // namespace Rice
-
-template<typename Base_T, typename Derived_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-include_module(
-    Module const & inc)
-{
-  protect(detail::include_module, *this, inc);
-  return (Derived_T &)*this;
-}
-
-template<typename Base_T, typename Derived_T>
-inline
-Derived_T &
-Rice::Module_impl<Base_T, Derived_T>::
-const_set(
-    Identifier name,
-    Object value)
-{
-  protect(detail::const_set, *this, name, value);
-  return (Derived_T &)*this;
-}
-
-template<typename Base_T, typename Derived_T>
-inline
-Rice::Object
-Rice::Module_impl<Base_T, Derived_T>::
-const_get(
-    Identifier name) const
-{
-  return protect(rb_const_get, *this, name);
-}
-
-template<typename Base_T, typename Derived_T>
-inline
-bool
-Rice::Module_impl<Base_T, Derived_T>::
-const_defined(Identifier name) const
-{
-  size_t result = protect(rb_const_defined, *this, name);
-  return bool(result);
-}
-
-template<typename Base_T, typename Derived_T>
-inline
-void
-Rice::Module_impl<Base_T, Derived_T>::
-remove_const(Identifier name)
-{
-  protect(rb_mod_remove_const, *this, name.to_sym());
-}
-
-template<typename Base_T, typename Derived_T>
-inline
-Rice::Module
-Rice::Module_impl<Base_T, Derived_T>::
-define_module(
-    char const * name)
-{
-  return Rice::define_module_under(*this, name);
-}
-
-template<typename Base_T, typename Derived_T>
-inline
-Rice::Class
-Rice::Module_impl<Base_T, Derived_T>::
-define_class(
-    char const * name,
-    Object superclass)
-{
-  return Rice::define_class_under(*this, name, superclass);
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename T>
-inline
-Rice::Data_Type<T>
-Rice::Module_impl<Base_T, Derived_T>::
-define_class_with_object_as_base(
-    char const * name)
-{
-  return Rice::define_class_under<T>(*this, name);
-}
-
-template<typename Base_T, typename Derived_T>
-template<typename T, typename T_Base_T>
-inline
-Rice::Data_Type<T>
-Rice::Module_impl<Base_T, Derived_T>::
-define_class(
-    char const * name)
-{
-  return Rice::define_class_under<T, T_Base_T>(
-      *this,
-      name);
-}
-

data/rice/Object.cpp

@@ -1,169 +0,0 @@
-#include "Object.hpp"
-#include "Class.hpp"
-#include "String.hpp"
-#include "Array.hpp"
-
-#include <algorithm>
-#include <iostream>
-
-namespace Rice
-{
-
-Object const Nil(Qnil);
-Object const True(Qtrue);
-Object const False(Qfalse);
-Object const Undef(Qundef);
-
-}
-
-Rice::Class Rice::Object::
-class_of() const {
-  return rb_class_of(value_);
-}
-
-int Rice::Object::
-compare(Object const & other) const
-{
-  Object result = call("<=>", other);
-  return from_ruby<int>(result);
-}
-
-void Rice::Object::
-freeze()
-{
-  protect(rb_obj_freeze, value());
-}
-
-bool Rice::Object::
-is_frozen() const
-{
-  return bool(OBJ_FROZEN(value()));
-}
-
-Rice::String Rice::Object::
-to_s() const {
-  return call("to_s");
-}
-
-Rice::String Rice::Object::
-inspect() const {
-  return call("inspect");
-}
-
-void Rice::Object::
-swap(Rice::Object & other)
-{
-  std::swap(value_, other.value_);
-}
-
-Rice::Object Rice::Object::
-instance_eval(String const & s)
-{
-  VALUE argv[] = { s.value() };
-  return protect(rb_obj_instance_eval, 1, &argv[0], *this);
-}
-
-int Rice::Object::
-rb_type() const
-{
-  return ::rb_type(*this);
-}
-
-bool Rice::Object::
-is_a(Object klass) const
-{
-  Object result = protect(rb_obj_is_kind_of, *this, klass);
-  return result.test();
-}
-
-bool Rice::Object::
-respond_to(Identifier id) const
-{
-  return bool(rb_respond_to(*this, id));
-}
-
-bool Rice::Object::
-is_instance_of(Object klass) const
-{
-  Object result = protect(rb_obj_is_instance_of, *this, klass);
-  return result.test();
-}
-
-Rice::Object Rice::Object::
-iv_get(
-    Identifier name) const
-{
-  return protect(rb_ivar_get, *this, name.id());
-}
-
-Rice::Object Rice::Object::
-attr_get(
-    Identifier name) const
-{
-  return protect(rb_attr_get, *this, name.id());
-}
-
-Rice::Object Rice::Object::
-vcall(
-    Identifier id,
-    Array args)
-{
-  std::vector<VALUE> a(args.size());
-
-  Array::const_iterator it  = args.begin();
-  Array::const_iterator end = args.end();
-
-  for(int i = 0 ;it != end; i++, ++it) {
-    a[i] = it->value();
-  }
-
-  return protect(rb_funcall3, *this, id, (int)args.size(), a.data());
-}
-
-void Rice::Object::
-mark() const
-{
-  rb_gc_mark(*this);
-}
-
-void Rice::Object::
-set_value(VALUE v)
-{
-  value_ = v;
-}
-
-std::ostream & Rice::
-operator<<(std::ostream & out, Rice::Object const & obj)
-{
-  String s(obj.to_s());
-  out << s.c_str();
-  return out;
-}
-
-bool Rice::
-operator==(Rice::Object const & lhs, Rice::Object const & rhs)
-{
-  Object result = lhs.call("==", rhs);
-  return result.test();
-}
-
-bool Rice::
-operator!=(Rice::Object const & lhs, Rice::Object const & rhs)
-{
-  return !(lhs == rhs);
-}
-
-bool Rice::
-operator<(Rice::Object const & lhs, Rice::Object const & rhs)
-{
-  Object result = lhs.call("<", rhs);
-  return result.test();
-}
-
-bool Rice::
-operator>(Rice::Object const & lhs, Rice::Object const & rhs)
-{
-  Object result = lhs.call(">", rhs);
-  return result.test();
-}
-

data/rice/Object.hpp

@@ -1,8 +0,0 @@
-#ifndef Rice__Object__hpp_
-#define Rice__Object__hpp_
-
-#include "Object_defn.hpp"
-#include "Object.ipp"
-
-#endif // Rice__Object__hpp_
-

data/rice/Object.ipp

@@ -1,33 +0,0 @@
-#ifndef Rice__Object__ipp_
-#define Rice__Object__ipp_
-
-#include "protect.hpp"
-#include "detail/ruby.hpp"
-#include "to_from_ruby.hpp"
-
-#include <vector>
-
-template<typename ...ArgT>
-inline Rice::Object Rice::Object::
-call(Identifier id, ArgT... args) const
-{
-  auto asList = this->convert_args<ArgT...>(args...);
-  return protect(rb_funcall2, value(), id, (int)asList.size(), asList.data());
-}
-
-template<typename ...ArgT>
-std::vector<VALUE> Rice::Object::convert_args(ArgT&... args) const {
-  return std::vector<VALUE>{ to_ruby(args)... };
-}
-
-template<typename T>
-void Rice::Object::
-iv_set(
-    Identifier name,
-    T const & value)
-{
-  protect(rb_ivar_set, *this, name.id(), to_ruby(value));
-}
-
-#endif // Rice__Object__ipp_
-