rice 1.0.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<char const *>(message_);
+}
+

data/rice/Exception.hpp

@@ -0,0 +1,69 @@
+#ifndef Rice__Exception__hpp_
+#define Rice__Exception__hpp_
+
+#include "Exception_Base.hpp"
+#include "String.hpp"
+#include "Address_Registration_Guard.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__hpp_
+

data/rice/Exception_Base.hpp

@@ -0,0 +1,30 @@
+#ifndef Rice__Exception_Base__hpp_
+#define Rice__Exception_Base__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
+
+#include "Exception_Base.ipp"
+#include "Object.hpp"
+
+#endif // Rice__Exception_Base__hpp_

data/rice/Exception_Base.ipp

@@ -0,0 +1,11 @@
+inline Rice::Exception_Base::
+Exception_Base(VALUE v)
+  : Object(v)
+{
+}
+
+inline Rice::Exception_Base::
+~Exception_Base() throw()
+{
+}
+

data/rice/Hash.hpp

@@ -0,0 +1,206 @@
+#ifndef Rice__Hash__hpp_
+#define Rice__Hash__hpp_
+
+#include "Builtin_Object_defn.hpp"
+#include "to_from_ruby_defn.hpp"
+#include "detail/ruby.hpp"
+#include "detail/st.hpp"
+#include "detail/remove_const.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<RHash, 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, size_t bin, st_table_entry * ptr);
+
+  //! 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);
+
+private:
+  Hash hash_;
+  st_table * tbl_;
+  int bin_;
+  st_table_entry * ptr_;
+
+  mutable typename detail::remove_const<Value_T>::Type tmp_;
+};
+
+} // namespace Rice
+
+#include "Hash.ipp"
+
+#endif // Rice__Hash__hpp_
+

data/rice/Hash.ipp

@@ -0,0 +1,336 @@
+#ifndef Rice__Hash__ipp_
+#define Rice__Hash__ipp_
+
+#include "protect.hpp"
+#include "to_from_ruby.hpp"
+#include "Exception.hpp"
+#include <algorithm>
+
+// TODO: Evil hack
+struct st_table_entry {
+  unsigned int hash;
+  st_data_t key;
+  st_data_t record;
+  st_table_entry *next;
+};
+
+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 (*this)->tbl->num_entries;
+}
+
+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, size_t bin, st_table_entry * ptr)
+  : hash_(hash)
+  , tbl_(RHASH(hash.value())->tbl)
+  , bin_(bin)
+  , ptr_(ptr)
+  , tmp_(hash, Qnil)
+{
+  // If we aren't already at the end, then use the increment operator to
+  // point to the first element
+  if(!ptr_ && bin_ < tbl_->num_bins)
+  {
+    operator++();
+  }
+}
+
+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())
+  , tbl_(iterator.tbl_)
+  , bin_(iterator.bin_)
+  , ptr_(iterator.ptr_)
+  , 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())
+  , tbl_(iterator.tbl_)
+  , bin_(iterator.bin_)
+  , ptr_(iterator.ptr_)
+  , 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++()
+{
+  // Go to the next element in the bin; this will be a no-op if we were
+  // called from the constructor, because ptr_ will be 0 (and if its
+  // not, this function won't get called).
+  if(ptr_)
+  {
+    ptr_ = ptr_->next;
+  }
+
+  // If we've reached the end of the bin, then try the next bin until
+  // we have run out of bins
+  while(ptr_ == 0)
+  {
+    ++bin_;
+    if(bin_ == tbl_->num_bins)
+    {
+      // At the end..
+      return *this;
+    }
+    ptr_ = tbl_->bins[bin_];
+  }
+
+  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_, ptr_->key);
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Value_T *
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator->()
+{
+  Entry tmp(hash_, ptr_->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()
+    && tbl_ == rhs.tbl_
+    && bin_ == rhs.bin_
+    && ptr_ == rhs.ptr_;
+}
+
+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(tbl_, iterator.tbl_);
+  swap(bin_, iterator.bin_);
+  swap(ptr_, iterator.ptr_);
+}
+
+inline Rice::Hash::iterator Rice::Hash::
+begin()
+{
+  st_table * tbl(RHASH(value())->tbl);
+  return iterator(*this, 0, tbl->bins[0]);
+}
+
+inline Rice::Hash::const_iterator Rice::Hash::
+begin() const
+{
+  st_table * tbl(RHASH(value())->tbl);
+  return const_iterator(*this, 0, tbl->bins[0]);
+}
+
+inline Rice::Hash::iterator Rice::Hash::
+end()
+{
+  st_table * tbl(RHASH(value())->tbl);
+  return iterator(*this, tbl->num_bins, 0);
+}
+
+inline Rice::Hash::const_iterator Rice::Hash::
+end() const
+{
+  st_table * tbl(RHASH(value())->tbl);
+  return const_iterator(*this, tbl->num_bins, 0);
+}
+
+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_
+