rice 4.5.0 → 4.6.0

data/rice/cpp_api/Hash.hpp

@@ -0,0 +1,194 @@
+#ifndef Rice__Hash__hpp_
+#define Rice__Hash__hpp_
+
+#include <iterator>
+#include <type_traits>
+
+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_Ptr_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);
+
+  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);
+
+    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_Ptr_T, typename Value_T>
+  class Hash::Iterator
+  {
+  public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = Value_T;
+    using difference_type = long;
+    using pointer = Object*;
+    using reference = Value_T&;
+
+    //! Construct a new Iterator.
+    Iterator(Hash_Ptr_T hash);
+
+    //! Construct a new Iterator with a given start-at index point
+    Iterator(Hash_Ptr_T hash, int start_at);
+
+    //! Construct an Iterator from another Iterator of a different const
+    //! qualification.
+    template<typename Iterator_T>
+    Iterator(Iterator_T const& iterator);
+
+    //! 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_Ptr_T_, typename Value_T_>
+    friend class Hash::Iterator;
+
+  protected:
+    Object current_key();
+
+    Array hash_keys();
+
+  private:
+    Hash_Ptr_T hash_;
+    long current_index_;
+    VALUE keys_;
+
+    mutable typename std::remove_const<Value_T>::type tmp_;
+  };
+} // namespace Rice
+
+#endif // Rice__Hash__hpp_
+

data/rice/cpp_api/Hash.ipp

@@ -0,0 +1,257 @@
+#include <algorithm>
+
+namespace Rice
+{
+  inline Hash::Hash() : Builtin_Object<T_HASH>(detail::protect(rb_hash_new))
+  {
+  }
+
+  inline Hash::Hash(Object v) : Builtin_Object<T_HASH>(v)
+  {
+  }
+
+  inline size_t Hash::size() const
+  {
+    return RHASH_SIZE(this->value());
+  }
+
+  inline Hash::Proxy::Proxy(Hash* hash, Object key) : hash_(hash), key_(key)
+  {
+  }
+
+  inline Hash::Proxy::operator Object() const
+  {
+    return value();
+  }
+
+  inline VALUE Hash::Proxy::value() const
+  {
+    return detail::protect(rb_hash_aref, hash_->value(), key_.value());
+  }
+
+  template<typename T>
+  inline Object Hash::Proxy::operator=(T const& value)
+  {
+    return detail::protect(rb_hash_aset, hash_->value(), key_.value(), detail::To_Ruby<T>().convert(value));
+  }
+
+  template<typename Key_T>
+  inline Hash::Proxy const Hash::operator[](Key_T const& key) const
+  {
+    return Proxy(*this, detail::To_Ruby<Key_T>().convert(key));
+  }
+
+  template<typename Key_T>
+  inline Hash::Proxy Hash::operator[](Key_T const& key)
+  {
+    return Proxy(this, detail::To_Ruby<Key_T>().convert(key));
+  }
+
+  template<typename Value_T, typename Key_T>
+  inline Value_T Hash::get(Key_T const& key)
+  {
+    Object ruby_key(detail::To_Ruby<Key_T>().convert(key));
+    Object value = operator[](ruby_key);
+    try
+    {
+      return detail::From_Ruby<Value_T>().convert(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 Hash::Entry::Entry(Hash* hash, Object key) :
+    key(key), first(Hash::Entry::key), value(hash, key), second(Hash::Entry::value)
+  {
+  }
+
+  inline Hash::Entry::Entry(Entry const& entry) :
+    key(entry.key), first(Hash::Entry::key), value(entry.value), second(Hash::Entry::value)
+  {
+  }
+
+  inline Hash::Entry& Hash::Entry::operator=(Hash::Entry const& other)
+  {
+    const_cast<Object&>(key) = const_cast<Object&>(other.key);
+
+    this->value = other.value;
+    this->second = this->value;
+
+    return *this;
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline Hash::Iterator<Hash_Ptr_T, Value_T>::Iterator(Hash_Ptr_T hash)
+    : hash_(hash), current_index_(0), keys_(Qnil), tmp_(const_cast<Hash*>(hash), Qnil)
+  {
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline Hash::Iterator<Hash_Ptr_T, Value_T>::Iterator(Hash_Ptr_T hash, int start_at)
+    : hash_(hash), current_index_(start_at), keys_(Qnil), tmp_(const_cast<Hash*>(hash), Qnil)
+  {
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  template<typename Iterator_T>
+  inline Hash::Iterator<Hash_Ptr_T, Value_T>::Iterator(Iterator_T const& iterator) :
+    hash_(iterator.hash_), current_index_(iterator.current_index_), keys_(Qnil), tmp_(iterator.hash_, Qnil)
+  {
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline Hash::Iterator<Hash_Ptr_T, Value_T>& Hash::Iterator<Hash_Ptr_T, Value_T>::operator++()
+  {
+    // Ensure we're within the range
+    if (current_index_ < hash_keys().size())
+    {
+      current_index_++;
+    }
+
+    return *this;
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline Hash::Iterator<Hash_Ptr_T, Value_T> Hash::Iterator<Hash_Ptr_T, Value_T>::operator++(int)
+  {
+    Iterator copy(*this);
+    ++(*this);
+    return copy;
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline Value_T Hash::Iterator<Hash_Ptr_T, Value_T>::operator*()
+  {
+    return Value_T(const_cast<Hash*>(hash_), current_key());
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline Value_T* Hash::Iterator<Hash_Ptr_T, Value_T>::operator->()
+  {
+    this->tmp_ = Entry(const_cast<Hash*>(hash_), current_key());
+    return &tmp_;
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline bool Hash::Iterator<Hash_Ptr_T, Value_T>::operator==(Iterator const& rhs) const
+  {
+    return hash_->value() == rhs.hash_->value()
+      && current_index_ == rhs.current_index_;
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline bool Hash::Iterator<Hash_Ptr_T, Value_T>::operator!=(Iterator const& rhs) const
+  {
+    return !(*this == rhs);
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline Object Hash::Iterator<Hash_Ptr_T, Value_T>::current_key()
+  {
+    return hash_keys()[current_index_];
+  }
+
+  template<typename Hash_Ptr_T, typename Value_T>
+  inline Array Hash::Iterator<Hash_Ptr_T, Value_T>::hash_keys()
+  {
+    if (NIL_P(keys_))
+    {
+      keys_ = rb_funcall(hash_->value(), rb_intern("keys"), 0, 0);
+    }
+
+    return Array(keys_);
+  }
+
+  inline Hash::iterator Hash::begin()
+  {
+    return iterator(this);
+  }
+
+  inline Hash::const_iterator Hash::begin() const
+  {
+    return const_iterator(this);
+  }
+
+  inline Hash::iterator Hash::end()
+  {
+    return iterator(this, (int)size());
+  }
+
+  inline Hash::const_iterator Hash::end() const
+  {
+    return const_iterator(this, (int)size());
+  }
+
+  inline bool operator<(Rice::Hash::Entry const& lhs, Rice::Hash::Entry const& rhs)
+  {
+    Rice::Object lhs_key(lhs.key);
+    Rice::Object rhs_key(rhs.key);
+    if (lhs_key < rhs_key)
+    {
+      return true;
+    }
+    else if (lhs_key > rhs_key)
+    {
+      return false;
+    }
+    else if (Rice::Object(lhs.value.value()) < Rice::Object(rhs.value.value()))
+    {
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<Hash>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class To_Ruby<Hash>
+  {
+  public:
+    VALUE convert(Hash const& x)
+    {
+      return x.value();
+    }
+  };
+
+  template<>
+  class From_Ruby<Hash>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_HASH:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    Hash convert(VALUE value)
+    {
+      return Hash(value);
+    }
+  };
+}

data/rice/cpp_api/Identifier.hpp

@@ -0,0 +1,46 @@
+#ifndef Rice__Identifier__hpp_
+#define Rice__Identifier__hpp_
+
+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 c string.
+    Identifier(char const* s, Encoding encoding = Encoding::utf8());
+
+    //! Construct a new Identifier from a string.
+    Identifier(std::string const& string, Encoding encoding = Encoding::utf8());
+
+    //! 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
+
+#endif // Rice__Identifier__hpp_

data/rice/cpp_api/Identifier.ipp

@@ -0,0 +1,31 @@
+namespace Rice
+{
+  inline Identifier::Identifier(ID id) : id_(id)
+  {
+  }
+
+  inline Identifier::Identifier(char const* name, Encoding encoding)
+  {
+    this->id_ = detail::protect(rb_intern3, name, (long)strlen(name), encoding);
+  }
+
+  inline Identifier::Identifier(const std::string& name, Encoding encoding)
+  {
+    this->id_ = detail::protect(rb_intern3, name.c_str(), (long)name.size(), encoding);
+  }
+
+  inline char const* Identifier::c_str() const
+  {
+    return detail::protect(rb_id2name, id_);
+  }
+
+  inline std::string Identifier::str() const
+  {
+    return c_str();
+  }
+
+  inline VALUE Identifier::to_sym() const
+  {
+    return ID2SYM(id_);
+  }
+}

data/rice/cpp_api/Module.hpp

@@ -0,0 +1,72 @@
+#ifndef Rice__Module__hpp_
+#define Rice__Module__hpp_
+
+namespace Rice
+{
+  template <typename T>
+  void validateType();
+
+  //! A helper for defining a Module and its methods.
+  /*! This class provides a C++-style interface to ruby's Module class and
+   *  for defining methods on that module.
+   *
+   *  Many of the methods are defined in Module_impl.hpp so that they can
+   *  return a reference to the most derived type.
+   */
+   // TODO: we can't inherit from Builtin_Object, because Class needs
+   // type T_CLASS and Module needs type T_MODULE
+  class Module : public Object
+  {
+  public:
+    //! Default construct a Module and initialize it to rb_cObject.
+    Module();
+
+    //! Construct a Module from an existing Module object.
+    Module(VALUE v);
+
+    //! Construct a Module from an string that references a Module
+    Module(std::string name, Object under = rb_cObject);
+
+    //! Return the name of the module.
+    String name() const;
+
+    //! Return an array containing the Module's ancestors.
+    /*! You will need to include Array.hpp to use this function.
+     */
+    Array ancestors() const;
+
+    //! Return the module's singleton class.
+    /*! You will need to include Class.hpp to use this function.
+     */
+    Class singleton_class() const;
+
+    //! Evaluate the given string in the context of the module.
+    /*! This is equivalant to calling obj.module_eval(s) from inside the
+     *  interpreter.
+     *  \return the result of the expression.
+     */
+    Object module_eval(String const& s);
+
+    #include "shared_methods.hpp"
+  protected:
+    template<bool IsMethod, typename Function_T>
+    void wrap_native_call(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
+  };
+
+  //! Define a new module in the namespace given by module.
+  /*! \param module the module in which to define the new module.
+   *  \param name the name of the new module.
+   */
+  Module define_module_under(Object module, char const * name);
+
+  //! Define a new module in the default namespace.
+  /*! \param name the name of the new module.
+   */
+  Module define_module(char const * name);
+
+  //! Create a new anonymous module.
+  /*! \return the new module.
+   */
+  Module anonymous_module();
+}
+#endif // Rice__Module__hpp_

data/rice/cpp_api/Module.ipp

@@ -0,0 +1,101 @@
+
+namespace Rice
+{
+  inline Module::Module() : Object(rb_cObject)
+  {
+  }
+
+  inline Module::Module(VALUE value) : Object(value)
+  {
+    if (::rb_type(value) != T_CLASS && ::rb_type(value) != T_MODULE)
+    {
+      throw Exception(
+        rb_eTypeError,
+        "Expected a Module but got a %s",
+        detail::protect(rb_obj_classname, value)); // TODO: might raise an exception
+    }
+  }
+
+  //! Construct a Module from an string that references a Module
+  inline Module::Module(std::string name, Object under)
+  {
+    VALUE result = under.const_get(name);
+
+    if (::rb_type(result) != T_MODULE)
+    {
+      throw Exception(
+        rb_eTypeError,
+        "Expected a Module but got a %s",
+        detail::protect(rb_obj_classname, result)); // TODO: might raise an exception
+    }
+
+    this->set_value(result);
+  }
+
+  template<bool IsMethod, typename Function_T>
+  inline void Module::wrap_native_call(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo)
+  {
+    // Make sure the return type and arguments have been previously seen by Rice
+    using traits = detail::method_traits<Function_T, IsMethod>;
+    detail::verifyType<typename traits::Return_T>();
+    detail::verifyTypes<typename traits::Arg_Ts>();
+
+    // Define a NativeFunction to bridge Ruby to C++
+    detail::NativeFunction<VALUE, Function_T, IsMethod>::define(klass, name, std::forward<Function_T>(function), methodInfo);
+  }
+
+  inline Module define_module_under(Object module, char const* name)
+  {
+    return detail::protect(rb_define_module_under, module.value(), name);
+  }
+
+  inline Module define_module(char const* name)
+  {
+    return detail::protect(rb_define_module, name);
+  }
+
+  inline Module anonymous_module()
+  {
+    VALUE klass = detail::protect(rb_module_new);
+    VALUE singleton = detail::protect(rb_singleton_class, klass);
+
+    // Ruby will reuse addresses previously assigned to other modules
+    // that have subsequently been garbage collected
+    detail::Registries::instance.natives.reset(klass);
+    detail::Registries::instance.natives.reset(singleton);
+
+    return klass;
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<Module>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class To_Ruby<Module>
+  {
+  public:
+    VALUE convert(Module const& x)
+    {
+      return x.value();
+    }
+  };
+
+  template<>
+  class From_Ruby<Module>
+  {
+  public:
+    Module convert(VALUE value)
+    {
+      return Module(value);
+    }
+  };
+}