keyme-rice 1.5.1.keyme

data/rice/Module_impl.ipp

@@ -0,0 +1,348 @@
+#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 "Exception.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 Rice::Exception(
+        rb_eTypeError,
+        "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
+{
+  int 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

@@ -0,0 +1,160 @@
+#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)
+{
+  return protect(rb_funcall3, *this, id, args.size(), args.to_c_array());
+}
+
+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

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

data/rice/Object.ipp

@@ -0,0 +1,19 @@
+#ifndef Rice__Object__ipp_
+#define Rice__Object__ipp_
+
+#include "protect.hpp"
+#include "detail/ruby.hpp"
+
+#include "detail/object_call.ipp"
+
+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_
+

data/rice/Object_defn.hpp

@@ -0,0 +1,191 @@
+#ifndef Rice__Object_defn__hpp_
+#define Rice__Object_defn__hpp_
+
+/*! \file Object.hpp
+ */
+
+#include "Identifier.hpp"
+#include "detail/ruby.hpp"
+
+#include <iosfwd>
+
+namespace Rice
+{
+
+class Class;
+class String;
+class Array;
+
+//! The base class for all Objects
+/*! Perhaps the name "Object" is a misnomer, because this class really
+ *  holds an object reference, not an object.
+ */
+class Object
+{
+public:
+  //! Encapsulate an existing ruby object.
+  Object(VALUE value = Qnil) : value_(value) { }
+
+  //! Copy constructor
+  Object(Object const & other) : value_(other.value()) { }
+
+  //! Destructor
+  virtual ~Object() { }
+
+  //! Returns false if the object is nil or false; returns true
+  //! otherwise.
+  // Having this conversion also prevents accidental conversion to
+  // undesired integral types (e.g. long or int) by making the
+  // conversion ambiguous.
+  bool test() const { return RTEST(value_); }
+
+  //! Returns false if the object is nil or false; returns true
+  //! otherwise.
+  operator bool() const { return test(); }
+
+  //! Returns true if the object is nil, false otherwise.
+  bool is_nil() const { return NIL_P(value_); }
+
+  //! Implicit conversion to VALUE.
+  operator VALUE() const { return value_; }
+
+  //! Explicitly get the encapsulated VALUE.
+  // Returns a const ref so that Address_Registration_Guard can access
+  // the address where the VALUE is stored
+  VALUE const volatile & value() const { return value_; }
+
+  //! Get the class of an object.
+  /*! \return the object's Class.
+   */
+  Class class_of() const;
+
+  //! Compare this object to another object.
+  /*! Gets the result of self <=> other and returns the result.  The
+   *  result will be less than zero if self < other, greater than zero
+   *  if self > other, and equal to zero if self == other.
+   */
+  int compare(Object const & other) const;
+
+  //! Return a string representation of an object.
+  /*! \return the result of calling to_s on the object.  A String is not
+   *  returned, because it is not possible to return an instance of a
+   *  derived class.
+   */
+  String to_s() const;
+
+  //! Inspect the object.
+  /*! \return the result of calling inspect on the object.  A String is
+   *  not returned, because it is not possible to return an instance of
+   *  a derived class.
+   */
+  String inspect() const;
+
+  //! Freeze the object.
+  void freeze();
+
+  //! Determine if the object is frozen.
+  /*! \return true if the object is frozen, false otherwise.
+   */
+  bool is_frozen() const;
+
+  //! Swap with another Object.
+  void swap(Object & other);
+
+  //! Evaluate the given string in the context of the object.
+  /*! This is equivalant to calling obj.instance_eval(s) from inside the
+   *  interpreter.
+   *  \return the result of the expression.
+   */
+  Object instance_eval(String const & s);
+
+  //! Return the type of the underlying C object.
+  /*! This is equivalent to calling rb_type(obj).
+   * \return the type of the underlying C object (e.g. T_DATA, T_ARRAY,
+   * etc.).
+   */
+  int rb_type() const;
+
+  //! Determine whether the object is an instance of a class/module.
+  /*! \param klass a class or module.
+   *  \return true if the object is an instance of the given
+   *  class/module or one of its descendants.
+   */
+  bool is_a(Object klass) const;
+
+  //! Determine if the objects responds to a method.
+  /*! \param id the name of the method
+   *  \return true if the objects responds to the method, false
+   *  otherwise.
+   */
+  bool respond_to(Identifier id) const;
+
+  //! Determine whether class is the object's class.
+  /*! \param klass a class.
+   *  \return true if the object is an instance of the given class.
+   */
+  bool is_instance_of(Object klass) const;
+
+  //! Set an instance variable.
+  /*! \param name the name of the instance variable to set (including
+   *  the leading @ sign)
+   *  \param value the value of the variable, which will be converted to
+   *  a Ruby type if necessary.
+   */
+  template<typename T>
+  void iv_set(
+      Identifier name,
+      T const & value);
+
+  //! Get the value of an instance variable.
+  /*! \param name the name of the instance variable to get
+   *  \return the value of the instance variable
+   */
+  Object iv_get(
+      Identifier name) const;
+
+  //! Get the value of an instance variable, but don't warn if it is
+  //unset.
+  /*! \param name the name of the instance variable to get
+   *  \return the value of the instance variable
+   */
+  Object attr_get(
+      Identifier name) const;
+
+#include "detail/object_call.hpp"
+
+  //! Vectorized call.
+  /*! Calls the method identified by id with the list of arguments
+   *  identified by args.
+   *  \param id the name of the method to call
+   *  \param args the arguments to the method
+   *  \return the return value of the method call
+   */
+  Object vcall(Identifier id, Array args);
+
+  //! Mark the object with the garbage collector.
+  void mark() const;
+
+protected:
+  //! Set the encapsulated value.
+  void set_value(VALUE v);
+
+private:
+  volatile VALUE value_;
+};
+
+std::ostream & operator<<(std::ostream & out, Object const & obj);
+
+bool operator==(Object const & lhs, Object const & rhs);
+bool operator!=(Object const & lhs, Object const & rhs);
+bool operator<(Object const & lhs, Object const & rhs);
+bool operator>(Object const & lhs, Object const & rhs);
+
+extern Object const Nil;
+extern Object const True;
+extern Object const False;
+extern Object const Undef;
+
+} // namespace Rice
+
+#endif // Rice__Object_defn__hpp_
+