rice 3.0.0 → 4.0.3

data/rice/Hash.ipp

@@ -1,329 +0,0 @@
-#ifndef Rice__Hash__ipp_
-#define Rice__Hash__ipp_
-
-#include "protect.hpp"
-#include "to_from_ruby.hpp"
-#include "Exception.hpp"
-#include "Builtin_Object.hpp"
-#include "detail/st.hpp"
-#include <algorithm>
-
-inline Rice::Hash::
-Hash()
-  : Builtin_Object<T_HASH>(protect(rb_hash_new))
-{
-}
-
-inline Rice::Hash::
-Hash(Object v)
-  : Builtin_Object<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, (int)size());
-}
-
-inline Rice::Hash::const_iterator Rice::Hash::
-end() const
-{
-  return const_iterator(*this, (int)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

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

data/rice/Jump_Tag.hpp

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

@@ -1,121 +0,0 @@
-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 \
-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 \
-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 \
-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 \
-config.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/protect.hpp \
-detail/ruby.hpp \
-detail/st.hpp \
-detail/to_ruby.hpp \
-detail/to_ruby.ipp \
-detail/win32.hpp \
-detail/wrap_function.hpp \
-detail/ruby_version_code.hpp
-
-includedir = ${prefix}/include/rice
-
-AM_CPPFLAGS = @RUBY_CPPFLAGS@
-
-AM_CXXFLAGS = @RUBY_CXXFLAGS@
-