rice2 2.2.0

data/rice/Exception.cpp

@@ -0,0 +1,59 @@
+#include "Exception.hpp"
+#include "protect.hpp"
+#include "to_from_ruby.hpp"
+#include "detail/ruby.hpp"
+
+#ifdef HAVE_STDARG_PROTOTYPES
+#include <stdarg.h>
+#define va_init_list(a,b) va_start(a,b)
+#else
+#include <varargs.h>
+#define va_init_list(a,b) va_start(a)
+#endif
+
+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<std::string>(message_).c_str();
+}
+

data/rice/Exception.hpp

@@ -0,0 +1,13 @@
+#ifndef Rice__Exception__hpp_
+#define Rice__Exception__hpp_
+
+namespace Rice {
+  class Exception;
+}
+
+#include "Exception_defn.hpp"
+#include "Exception_Base.hpp"
+#include "Address_Registration_Guard.hpp"
+
+#endif // Rice__Exception__hpp_
+

data/rice/Exception_Base.hpp

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

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

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

data/rice/Exception_defn.hpp

@@ -0,0 +1,69 @@
+#ifndef Rice__Exception_defn__hpp_
+#define Rice__Exception_defn__hpp_
+
+#include "Exception_Base_defn.hpp"
+#include "String.hpp"
+#include "Address_Registration_Guard_defn.hpp"
+
+#include <stdexcept>
+#include "detail/ruby.hpp"
+
+namespace Rice
+{
+
+//! A placeholder for Ruby exceptions.
+/*! You can use this to safely throw a Ruby exception using C++ syntax:
+ *  \code
+ *    VALUE foo(VALUE self) {
+ *      RUBY_TRY {
+ *        throw Rice::Exception(rb_eMyException, "uh oh!");
+ *      RUBY_CATCH
+ *    }
+ *  \endcode
+ */
+class Exception
+  : public Exception_Base
+{
+public:
+  //! Construct a Exception with the exception e.
+  explicit Exception(VALUE e);
+
+  //! Copy constructor.
+  Exception(Exception const & other);
+
+  //! Construct a Exception with printf-style formatting.
+  /*! \param exc either an exception object or a class that inherits
+   *  from Exception.
+   *  \param fmt a printf-style format string
+   *  \param ... the arguments to the format string.
+   */
+  Exception(Object exc, char const * fmt, ...);
+
+  //! Destructor
+  virtual ~Exception() throw() { }
+
+  //! Get the message the exception holds
+  /*! \return the result of calling message() on the underlying
+   *  exception object.
+   */
+  String message() const;
+
+  //! Get message as a char const *.
+  /*! If message is a non-string object, then this function will attempt
+   *  to throw an exception (which it can't do because of the no-throw
+   *  specification).
+   *  \return the underlying C pointer of the underlying message object.
+   */
+  virtual char const * what() const throw();
+
+private:
+  // Keep message around in case someone calls what() and then the GC
+  // gets invoked.
+  mutable VALUE message_;
+  Address_Registration_Guard message_guard_;
+};
+
+} // namespace Rice
+
+#endif // Rice__Exception_defn__hpp_
+

data/rice/Hash.hpp

@@ -0,0 +1,227 @@
+#ifndef Rice__Hash__hpp_
+#define Rice__Hash__hpp_
+
+#include "Builtin_Object_defn.hpp"
+#include "Array.hpp"
+#include "to_from_ruby_defn.hpp"
+#include "detail/ruby.hpp"
+#include "detail/traits.hpp"
+#include <iterator>
+
+namespace Rice
+{
+
+//! A wrapper for the ruby Hash class.
+//! This class provides a C++-style interface to ruby's Hash class and
+//! its associated rb_hash_* functions.
+//! Example:
+//! \code
+//!   Hash h;
+//!   h[42] = String("foo");
+//!   h[10] = String("bar");
+//!   std::cout << String(h[42]) << std::endl;
+//! \endcode
+class Hash
+  : public Builtin_Object<T_HASH>
+{
+public:
+  //! Construct a new hash.
+  Hash();
+
+  //! Wrap an existing hash.
+  /*! \param v the hash to wrap.
+   */
+  Hash(Object v);
+
+  //! Return the number of elements in the hash.
+  size_t size() const;
+
+private:
+  //! A helper class so hash[key]=value can work.
+  class Proxy;
+
+public:
+  //! Get the value for the given key.
+  /*! \param key the key whose value should be retrieved from the hash.
+   *  \return the value associated with the given key.
+   */
+  template<typename Key_T>
+  Proxy const operator[](Key_T const & key) const;
+
+  //! Get the value for the given key.
+  /*! \param key the key whose value should be retrieved from the hash.
+   *  \return the value associated with the given key.
+   */
+  template<typename Key_T>
+  Proxy operator[](Key_T const & key);
+
+  //! Get the value for the given key
+  /*! The returned value is converted to the type given by Value_T.
+   *  \param key the key whose value should be retrieved from the hash.
+   *  \return the value associated with the given key, converted to C++
+   *  type Value_T.
+   */
+  template<typename Value_T, typename Key_T>
+  Value_T get(Key_T const & key);
+
+  //! A helper class for dereferencing iterators
+  class Entry;
+
+  //! A helper class for implementing iterators for a Hash.
+  template<typename Hash_Ref_T, typename Value_T>
+  class Iterator;
+
+public:
+  //! An iterator.
+  typedef Iterator<Hash &, Entry> iterator;
+
+  //! A const iterator.
+  typedef Iterator<Hash const &, Entry const> const_iterator;
+
+public:
+  //! Return an iterator to the beginning of the hash.
+  iterator begin();
+
+  //! Return a const iterator to the beginning of the hash.
+  const_iterator begin() const;
+
+  //! Return an iterator to the end of the hash.
+  iterator end();
+
+  //! Return a const to the end of the hash.
+  const_iterator end() const;
+};
+
+//! A helper class so hash[key]=value can work.
+class Hash::Proxy
+{
+public:
+  //! Construct a new Proxy.
+  Proxy(Hash hash, Object key);
+
+  //! Implicit conversion to Object.
+  operator Object() const;
+
+  //! Explicit conversion to VALUE.
+  VALUE value() const;
+
+  //! Assignment operator.
+  template<typename T>
+  Object operator=(T const & value);
+
+  void swap(Proxy & proxy);
+
+private:
+  Hash hash_;
+  Object key_;
+};
+
+//! A helper class for dereferencing iterators
+/*! This class is intended to look similar to an std::pair.
+ */
+class Hash::Entry
+{
+public:
+  //! Construct a new Entry.
+  Entry(Hash hash, Object key);
+
+  //! Copy constructor.
+  Entry(Entry const & entry);
+
+  Object const key;          //!< The key
+  Object const & first;      //!< An alias for the key
+
+  Proxy value;              //!< The value
+  Proxy & second;           //!< An alias for the value
+
+  Entry & operator=(Entry const & rhs);
+
+  void swap(Entry & entry);
+
+  friend bool operator<(Entry const & lhs, Entry const & rhs);
+};
+
+bool operator<(Hash::Entry const & lhs, Hash::Entry const & rhs);
+
+//! A helper class for implementing iterators for a Hash.
+template<typename Hash_Ref_T, typename Value_T>
+class Hash::Iterator
+  : public std::iterator<
+      std::input_iterator_tag,
+      Value_T>
+{
+public:
+  //! Construct a new Iterator.
+  Iterator(Hash_Ref_T hash);
+
+  //! Construct a new Iterator with a given start-at index point
+  Iterator(Hash_Ref_T hash, int start_at);
+
+  //! Copy construct an Iterator.
+  Iterator(Iterator const & iterator);
+
+  //! Construct an Iterator from another Iterator of a different const
+  //! qualification.
+  template<typename Iterator_T>
+  Iterator(Iterator_T const & iterator);
+
+  //! Assignment operator.
+  Iterator & operator=(Iterator const & rhs);
+
+  //! Preincrement operator.
+  Iterator & operator++();
+
+  //! Postincrement operator.
+  Iterator operator++(int);
+
+  //! Dereference operator.
+  Value_T operator*();
+
+  //! Dereference operator.
+  Value_T * operator->();
+
+  //! Equality operator.
+  bool operator==(Iterator const & rhs) const;
+
+  //! Inequality operator.
+  bool operator!=(Iterator const & rhs) const;
+
+  template<typename Hash_Ref_T_, typename Value_T_>
+  friend class Hash::Iterator;
+
+  //! Swap with another iterator of the same type.
+  void swap(Iterator & iterator);
+
+protected:
+  Object current_key();
+
+  Array hash_keys();
+
+private:
+  Hash hash_;
+  size_t current_index_;
+  VALUE keys_;
+
+  mutable typename detail::remove_const<Value_T>::Type tmp_;
+};
+
+} // namespace Rice
+
+template<>
+inline
+Rice::Hash from_ruby<Rice::Hash>(Rice::Object x)
+{
+  return Rice::Hash(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<Rice::Hash>(Rice::Hash const & x)
+{
+  return x;
+}
+
+#include "Hash.ipp"
+
+#endif // Rice__Hash__hpp_
+

data/rice/Hash.ipp

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