keyme-rice 1.5.1.keyme

data/rice/Hash.ipp

@@ -0,0 +1,330 @@
+#ifndef Rice__Hash__ipp_
+#define Rice__Hash__ipp_
+
+#include "protect.hpp"
+#include "to_from_ruby.hpp"
+#include "Builtin_Object.hpp"
+#include "Exception.hpp"
+#include "Builtin_Object.hpp"
+#include "detail/st.hpp"
+#include <algorithm>
+
+inline Rice::Hash::
+Hash()
+  : Builtin_Object<RHash, T_HASH>(protect(rb_hash_new))
+{
+}
+
+inline Rice::Hash::
+Hash(Object v)
+  : Builtin_Object<RHash, T_HASH>(v)
+{
+}
+
+inline size_t Rice::Hash::
+size() const
+{
+  return RHASH_SIZE(this->value());
+}
+
+inline Rice::Hash::Proxy::
+Proxy(Hash hash, Object key)
+  : hash_(hash)
+  , key_(key)
+{
+}
+
+/*
+inline Rice::Hash::Proxy::
+operator VALUE() const
+{
+  return value();
+}
+*/
+
+inline Rice::Hash::Proxy::
+operator Rice::Object() const
+{
+  return value();
+}
+
+inline VALUE Rice::Hash::Proxy::
+value() const
+{
+  return protect(rb_hash_aref, hash_, key_);
+}
+
+template<typename T>
+inline Rice::Object Rice::Hash::Proxy::
+operator=(T const & value)
+{
+  return protect(rb_hash_aset, hash_, key_, to_ruby(value));
+}
+
+inline void Rice::Hash::Proxy::
+swap(Proxy & proxy)
+{
+  hash_.swap(proxy.hash_);
+  key_.swap(proxy.key_);
+}
+
+template<typename Key_T>
+inline Rice::Hash::Proxy const Rice::Hash::
+operator[](Key_T const & key) const
+{
+  return Proxy(*this, to_ruby(key));
+}
+
+template<typename Key_T>
+inline Rice::Hash::Proxy Rice::Hash::
+operator[](Key_T const & key)
+{
+  return Proxy(*this, to_ruby(key));
+}
+
+template<typename Value_T, typename Key_T>
+inline Value_T Rice::Hash::
+get(Key_T const & key)
+{
+  Object ruby_key(to_ruby(key));
+  Object value = operator[](ruby_key);
+  try
+  {
+    return from_ruby<Value_T>(value);
+  }
+  catch(Exception const & ex)
+  {
+    String s_key(ruby_key.to_s());
+    throw Exception(
+        ex,
+        "%s while converting value for key %s",
+        ex.what(),
+        s_key.c_str());
+  }
+}
+
+inline Rice::Hash::Entry::
+Entry(Hash hash, Object key)
+  : key(key)
+  , first(Hash::Entry::key)
+  , value(hash, key)
+  , second(Hash::Entry::value)
+{
+}
+
+inline Rice::Hash::Entry::
+Entry(Entry const & entry)
+  : key(entry.key)
+  , first(Hash::Entry::key)
+  , value(entry.value)
+  , second(Hash::Entry::value)
+{
+}
+
+inline Rice::Hash::Entry & Rice::Hash::Entry::
+operator=(Rice::Hash::Entry const & rhs)
+{
+  Entry tmp(rhs);
+  swap(tmp);
+  return *this;
+}
+
+inline void Rice::Hash::Entry::
+swap(Rice::Hash::Entry & entry)
+{
+  const_cast<Object &>(key).swap(const_cast<Object &>(entry.key));
+  value.swap(entry.value);
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+Iterator(Hash_Ref_T hash)
+  : hash_(hash)
+  , current_index_(0)
+  , keys_(Qnil)
+  , tmp_(hash, Qnil)
+{
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+Iterator(Hash_Ref_T hash, int start_at)
+  : hash_(hash)
+  , current_index_(start_at)
+  , keys_(Qnil)
+  , tmp_(hash, Qnil)
+{
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+Iterator(Iterator const & iterator)
+  : hash_(iterator.hash_.value())
+  , current_index_(iterator.current_index_)
+  , keys_(Qnil)
+  , tmp_(iterator.hash_, Qnil)
+{
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+template<typename Iterator_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+Iterator(Iterator_T const & iterator)
+  : hash_(iterator.hash_.value())
+  , current_index_(iterator.current_index_)
+  , keys_(Qnil)
+  , tmp_(iterator.hash_, Qnil)
+{
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T> &
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator=(Iterator const & iterator)
+{
+  Iterator tmp(iterator);
+
+  this->swap(tmp);
+
+  return *this;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T> &
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator++()
+{
+  // Ensure we're within the range
+  if(current_index_ < hash_keys().size()) {
+    current_index_++;
+  }
+
+  return *this;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator++(int)
+{
+  Iterator copy(*this);
+  ++(*this);
+  return copy;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Value_T
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator*()
+{
+  return Value_T(hash_, current_key());
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Value_T *
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator->()
+{
+  Entry tmp(hash_, current_key());
+  this->tmp_.swap(tmp);
+  return &tmp_;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline bool Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator==(Iterator const & rhs) const
+{
+  return hash_.value() == rhs.hash_.value()
+    && current_index_ == rhs.current_index_;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline bool Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator!=(Iterator const & rhs) const
+{
+  return !(*this == rhs);
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline void
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+swap(Iterator& iterator)
+{
+  using namespace std;
+
+  hash_.swap(iterator.hash_);
+  swap(keys_, iterator.keys_);
+  swap(current_index_, iterator.current_index_);
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Object
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+current_key()
+{
+  return hash_keys()[current_index_];
+}
+
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Array
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+hash_keys()
+{
+  if(NIL_P(keys_)) {
+    keys_ = rb_funcall(hash_, rb_intern("keys"), 0, 0);
+  }
+
+  return Rice::Array(keys_);
+}
+
+inline Rice::Hash::iterator Rice::Hash::
+begin()
+{
+  return iterator(*this);
+}
+
+inline Rice::Hash::const_iterator Rice::Hash::
+begin() const
+{
+  return const_iterator(*this);
+}
+
+inline Rice::Hash::iterator Rice::Hash::
+end()
+{
+  return iterator(*this, size());
+}
+
+inline Rice::Hash::const_iterator Rice::Hash::
+end() const
+{
+  return const_iterator(*this, size());
+}
+
+inline bool Rice::
+operator<(
+    Hash::Entry const & lhs, Hash::Entry const & rhs)
+{
+  Object lhs_key(lhs.key);
+  Object rhs_key(rhs.key);
+  if(lhs_key < rhs_key)
+  {
+    return true;
+  }
+  else if(lhs_key > rhs_key)
+  {
+    return false;
+  }
+  else if(Object(lhs.value.value()) < Object(rhs.value.value()))
+  {
+    return true;
+  }
+  else
+  {
+    return false;
+  }
+}
+
+#endif // Rice__Hash__ipp_
+

data/rice/Identifier.cpp

@@ -0,0 +1,8 @@
+#include "Symbol.hpp"
+
+Rice::Identifier::
+Identifier(Symbol const & symbol)
+  : id_(SYM2ID(symbol.value()))
+{
+}
+

data/rice/Identifier.hpp

@@ -0,0 +1,50 @@
+#ifndef Rice__Identifier__hpp_
+#define Rice__Identifier__hpp_
+
+#include "detail/ruby.hpp"
+#include <string>
+
+namespace Rice
+{
+
+class Symbol;
+
+//! A wrapper for the ID type
+/*! An ID is ruby's internal representation of a Symbol object.
+ */
+class Identifier
+{
+public:
+  //! Construct a new Identifier from an ID.
+  Identifier(ID id);
+
+  //! Construct a new Identifier from a Symbol.
+  Identifier(Symbol const & symbol);
+
+  //! Construct a new Identifier from a string.
+  Identifier(char const * s = "");
+
+  //! Return a string representation of the Identifier.
+  char const * c_str() const;
+
+  //! Return a string representation of the Identifier.
+  std::string str() const;
+
+  //! Return the underlying ID
+  ID id() const { return id_; }
+
+  //! Return the underlying ID
+  operator ID() const { return id_; }
+
+  //! Return the ID as a Symbol
+  VALUE to_sym() const;
+
+private:
+  ID id_;
+};
+
+} // namespace Rice
+
+#include "Identifier.ipp"
+
+#endif // Rice__Identifier__hpp_

data/rice/Identifier.ipp

@@ -0,0 +1,33 @@
+inline Rice::Identifier::
+Identifier(ID id)
+  : id_(id)
+{
+}
+
+inline Rice::Identifier::
+Identifier(char const * s)
+  : id_(rb_intern(s))
+{
+}
+
+inline char const *
+Rice::Identifier::
+c_str() const
+{
+  return rb_id2name(id_);
+}
+
+inline std::string
+Rice::Identifier::
+str() const
+{
+  return c_str();
+}
+
+inline VALUE
+Rice::Identifier::
+to_sym() const
+{
+  return ID2SYM(id_);
+}
+

data/rice/Jump_Tag.hpp

@@ -0,0 +1,24 @@
+#ifndef Rice__Jump_Tag__hpp_
+#define Rice__Jump_Tag__hpp_
+
+namespace Rice
+{
+
+//! A placeholder for Ruby longjmp data.
+/*! When a Ruby exception is caught, the tag used for the longjmp is stored in
+ *  a Jump_Tag, then later passed to rb_jump_tag() when there is no more
+ *  C++ code to pass over.
+ */
+struct Jump_Tag
+{
+  //! Construct a Jump_Tag with tag t.
+  Jump_Tag(int t) : tag(t) { }
+
+  //! The tag being held.
+  int tag;
+};
+
+} // namespace Rice
+
+#endif // Rice__Jump_Tag__hpp_
+

data/rice/Makefile.am

@@ -0,0 +1,129 @@
+lib_LIBRARIES = librice.a
+
+librice_a_SOURCES = \
+Class.cpp \
+Data_Type.cpp \
+Director.cpp \
+Exception.cpp \
+Identifier.cpp \
+Module.cpp \
+Object.cpp \
+String.cpp \
+Struct.cpp \
+Symbol.cpp \
+VM.cpp \
+Arg_operators.cpp \
+Address_Registration_Guard.cpp \
+detail/check_ruby_type.cpp \
+detail/demangle.cpp \
+detail/method_data.cpp \
+detail/protect.cpp
+
+nobase_include_HEADERS = \
+Address_Registration_Guard.hpp \
+Address_Registration_Guard.ipp \
+Address_Registration_Guard_defn.hpp \
+Array.hpp \
+Array.ipp \
+Arg.hpp \
+Arg_impl.hpp \
+Arg_operators.hpp \
+Builtin_Object.hpp \
+Builtin_Object.ipp \
+Builtin_Object_defn.hpp \
+Class.hpp \
+Class.ipp \
+Class_defn.hpp \
+Constructor.hpp \
+Critical_Guard.hpp \
+Critical_Guard.ipp \
+Data_Object.hpp \
+Data_Object.ipp \
+Data_Object_defn.hpp \
+Data_Type.hpp \
+Data_Type.ipp \
+Data_Type_defn.hpp \
+Data_Type_fwd.hpp \
+Director.hpp \
+Enum.hpp \
+Enum.ipp \
+Exception.hpp \
+Exception_defn.hpp \
+Exception_Base.hpp \
+Exception_Base.ipp \
+Exception_Base_defn.hpp \
+Hash.hpp \
+Hash.ipp \
+Identifier.hpp \
+Identifier.ipp \
+Jump_Tag.hpp \
+Makefile \
+Module.hpp \
+Module.ipp \
+Module_defn.hpp \
+Module_impl.hpp \
+Module_impl.ipp \
+Object.hpp \
+Object.ipp \
+Object_defn.hpp \
+Require_Guard.hpp \
+String.hpp \
+Struct.hpp \
+Struct.ipp \
+Symbol.hpp \
+Symbol.ipp \
+VM.hpp \
+global_function.hpp \
+global_function.ipp \
+protect.hpp \
+protect.ipp \
+ruby_try_catch.hpp \
+to_from_ruby.hpp \
+to_from_ruby.ipp \
+to_from_ruby_defn.hpp \
+ruby_mark.hpp \
+detail/Auto_Function_Wrapper.hpp \
+detail/Auto_Function_Wrapper.ipp \
+detail/Auto_Member_Function_Wrapper.hpp \
+detail/Auto_Member_Function_Wrapper.ipp \
+detail/Arguments.hpp \
+detail/Caster.hpp \
+detail/Exception_Handler.hpp \
+detail/Exception_Handler.ipp \
+detail/Exception_Handler_defn.hpp \
+detail/Iterator.hpp \
+detail/Not_Copyable.hpp \
+detail/Wrapped_Function.hpp \
+detail/check_ruby_type.hpp \
+detail/creation_funcs.hpp \
+detail/creation_funcs.ipp \
+detail/default_allocation_func.hpp \
+detail/default_allocation_func.ipp \
+detail/define_method_and_auto_wrap.hpp \
+detail/define_method_and_auto_wrap.ipp \
+detail/demangle.hpp \
+detail/env.hpp \
+detail/from_ruby.hpp \
+detail/from_ruby.ipp \
+detail/method_data.hpp \
+detail/node.hpp \
+detail/object_call.hpp \
+detail/object_call.ipp \
+detail/protect.hpp \
+detail/ruby.hpp \
+detail/rubysig.hpp \
+detail/st.hpp \
+detail/traits.hpp \
+detail/to_ruby.hpp \
+detail/to_ruby.ipp \
+detail/win32.hpp \
+detail/wrap_function.hpp \
+detail/wrap_function.ipp \
+detail/ruby_version_code.hpp
+
+includedir = ${prefix}/include/rice
+
+AM_CPPFLAGS = @RUBY_CPPFLAGS@
+
+AM_CXXFLAGS = @RUBY_CXXFLAGS@
+