keyme-rice 1.5.1.keyme

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,9 @@
+#ifndef Rice__Exception__hpp_
+#define Rice__Exception__hpp_
+
+#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<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);
+
+  //! 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_;
+  int 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_
+