rice 4.3.3 → 4.6.0

data/rice/cpp_api/Class.ipp

@@ -0,0 +1,97 @@
+
+namespace Rice
+{
+  inline Class::Class(VALUE value) : Module(value)
+  {
+    detail::protect(rb_check_type, value, (int)T_CLASS);
+  }
+
+  inline Class& Class::undef_creation_funcs()
+  {
+    detail::protect(rb_undef_alloc_func, value());
+    detail::protect(rb_undef_method, value(), "initialize");
+    return *this;
+  }
+
+  template<typename ...Arg_Ts>
+  inline Object Class::create(Arg_Ts ...args)
+  {
+    return this->call("new", args...);
+  }
+
+  inline const std::string Class::name() const
+  {
+    const char* buffer = rb_class2name(this->value());
+    return std::string(buffer);
+  }
+
+  inline const std::string Class::base_name() const
+  {
+    std::string name = this->name();
+    auto regex = std::regex("^.*::");
+    std::string result = std::regex_replace(name, regex, "");
+    return result;
+  }
+
+  inline Class define_class_under(Object parent, Identifier id, const Class& superclass)
+  {
+    VALUE klass = detail::protect(rb_define_class_id_under, parent.value(), id, superclass.value());
+
+    // We MUST reset the instance registry in case the user just redefined a class which resets it
+    detail::Registries::instance.natives.reset(klass);
+
+    return klass;
+  }
+
+  inline Class define_class_under(Object parent, char const* name, const Class& superclass)
+  {
+    Identifier id(name);
+    return define_class_under(parent, id, superclass);
+  }
+
+  inline Class define_class(char const* name, const Class& superclass)
+  {
+    VALUE klass = detail::protect(rb_define_class, name, superclass.value());
+
+    // We MUST reset the instance registry in case the user just redefined a class which resets it
+    detail::Registries::instance.natives.reset(klass);
+
+    return klass;
+  }
+
+  inline Class anonymous_class()
+  {
+    VALUE klass = detail::protect(rb_class_new, rb_cObject);
+    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<>
+  class To_Ruby<Class>
+  {
+  public:
+    static VALUE convert(Class const& x)
+    {
+      return x.value();
+    }
+  };
+
+  template<>
+  class From_Ruby<Class>
+  {
+  public:
+    Class convert(VALUE value)
+    {
+      return Class(value);
+    }
+  };
+}

data/rice/cpp_api/Encoding.hpp

@@ -0,0 +1,32 @@
+#ifndef Rice__Encoding__hpp_
+#define Rice__Encoding__hpp_
+
+namespace Rice
+{
+  //! A wrapper for a Ruby encoding
+  class Encoding
+  {
+  public:
+    static Encoding utf8();
+
+    //! Wrap an existing encoding.
+    Encoding(rb_encoding* encoding);
+
+    //! Implicit conversion to VALUE.
+    operator rb_encoding* () const
+    {
+      return this->encoding_;
+    }
+
+    operator VALUE () const
+    {
+      return detail::protect(rb_enc_from_encoding, this->encoding_);
+    }
+
+  private:
+    rb_encoding* encoding_;
+  };
+} // namespace Rice
+
+#endif // Rice__Encoding__hpp_
+

data/rice/cpp_api/Encoding.ipp

@@ -0,0 +1,59 @@
+namespace Rice
+{
+  inline Encoding Encoding::utf8()
+  {
+    return Encoding(rb_utf8_encoding());
+  }
+
+  inline Encoding::Encoding(rb_encoding* encoding) : encoding_(encoding)
+  {
+  }
+}
+
+/*namespace Rice::detail
+{
+  template<>
+  struct Type<Encoding>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+  
+  template<>
+  class To_Ruby<Encoding>
+  {
+  public:
+    VALUE convert(const Encoding& encoding)
+    {
+    //  return x.value();
+    }
+  };
+
+  template<>
+  class From_Ruby<Encoding>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_SYMBOL:
+          return Convertible::Exact;
+          break;
+      case RUBY_T_STRING:
+          return Convertible::Cast;
+          break;
+        default:
+          return Convertible::None;
+        }
+    }
+
+    Encoding convert(VALUE value)
+    {
+     // return Symbol(value);
+    }
+  };
+}
+*/

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/{Identifier.hpp → cpp_api/Identifier.hpp}

@@ -1,8 +1,6 @@
 #ifndef Rice__Identifier__hpp_
 #define Rice__Identifier__hpp_
 
-#include <string>
-
 namespace Rice
 {
   class Symbol;
@@ -20,10 +18,10 @@ namespace Rice
     Identifier(Symbol const& symbol);
 
     //! Construct a new Identifier from a c string.
-    Identifier(char const* s);
+    Identifier(char const* s, Encoding encoding = Encoding::utf8());
 
     //! Construct a new Identifier from a string.
-    Identifier(std::string const& string);
+    Identifier(std::string const& string, Encoding encoding = Encoding::utf8());
 
     //! Return a string representation of the Identifier.
     char const* c_str() const;
@@ -45,6 +43,4 @@ namespace Rice
   };
 } // namespace Rice
 
-#include "Identifier.ipp"
-
 #endif // Rice__Identifier__hpp_

data/rice/{Identifier.ipp → cpp_api/Identifier.ipp}

@@ -4,12 +4,14 @@ namespace Rice
   {
   }
 
-  inline Identifier::Identifier(char const* s) : id_(rb_intern(s))
+  inline Identifier::Identifier(char const* name, Encoding encoding)
   {
+    this->id_ = detail::protect(rb_intern3, name, (long)strlen(name), encoding);
   }
 
-  inline Identifier::Identifier(std::string const& s) : id_(rb_intern2(s.c_str(), s.size()))
+  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