rice 4.5.0 → 4.6.0

data/rice/stl/unique_ptr.hpp

@@ -0,0 +1,22 @@
+#ifndef Rice__stl__unique_ptr__hpp_
+#define Rice__stl__unique_ptr__hpp_
+
+namespace Rice::detail
+{
+  template<typename T>
+  class Wrapper<std::unique_ptr<T>> : public WrapperBase
+  {
+  public:
+    Wrapper(std::unique_ptr<T>&& data);
+    ~Wrapper();
+    void* get() override;
+    std::unique_ptr<T>& data();
+
+  private:
+    std::unique_ptr<T> data_;
+  };
+}
+
+#include "unique_ptr.ipp"
+
+#endif // Rice__stl__unique_ptr__hpp_

data/rice/stl/unique_ptr.ipp

@@ -0,0 +1,139 @@
+#include <memory>
+
+namespace Rice::detail
+{
+  template<typename T>
+  inline Wrapper<std::unique_ptr<T>>::Wrapper(std::unique_ptr<T>&& data)
+    : data_(std::move(data))
+  {
+  }
+
+  template<typename T>
+  inline Wrapper<std::unique_ptr<T>>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get());
+  }
+
+  template<typename T>
+  inline void* Wrapper<std::unique_ptr<T>>::get()
+  {
+    return (void*)this->data_.get();
+  }
+
+  template<typename T>
+  inline std::unique_ptr<T>& Wrapper<std::unique_ptr<T>>::data()
+  {
+    return data_;
+  }
+
+  template <typename T>
+  class To_Ruby<std::unique_ptr<T>>
+  {
+  public:
+    VALUE convert(std::unique_ptr<T>& data)
+    {
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
+      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+    }
+
+    VALUE convert(std::unique_ptr<T>&& data)
+    {
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
+      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, data, true);
+    }
+  };
+
+  template <typename T>
+  class To_Ruby<std::unique_ptr<T>&>
+  {
+  public:
+    VALUE convert(std::unique_ptr<T>& data)
+    {
+      std::pair<VALUE, rb_data_type_t*> rubyTypeInfo = detail::Registries::instance.types.figureType<T>(*data);
+      return detail::wrap<std::unique_ptr<T>>(rubyTypeInfo.first, rubyTypeInfo.second, std::move(data), true);
+    }
+  };
+
+  template <typename T>
+  class From_Ruby<std::unique_ptr<T>>
+  {
+  public:
+    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
+    {
+      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (!is_same_smart_ptr(value))
+        return Convertible::None;
+
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::unique_ptr<T> convert(VALUE value)
+    {
+      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
+      if (!wrapper)
+      {
+        std::string message = "Invalid smart pointer wrapper";
+        throw std::runtime_error(message.c_str());
+      }
+      return std::move(wrapper->data());
+    }
+  };
+
+  template <typename T>
+  class From_Ruby<std::unique_ptr<T>&>
+  {
+  public:
+    Wrapper<std::unique_ptr<T>>* is_same_smart_ptr(VALUE value)
+    {
+      WrapperBase* wrapper = detail::getWrapper(value, Data_Type<T>::ruby_data_type());
+      return dynamic_cast<Wrapper<std::unique_ptr<T>>*>(wrapper);
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (!is_same_smart_ptr(value))
+        return Convertible::None;
+
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::unique_ptr<T>& convert(VALUE value)
+    {
+      Wrapper<std::unique_ptr<T>>* wrapper = is_same_smart_ptr(value);
+      if (!wrapper)
+      {
+        std::string message = "Invalid smart pointer wrapper";
+        throw std::runtime_error(message.c_str());
+      }
+      return wrapper->data();
+    }
+  };
+
+  template<typename T>
+  struct Type<std::unique_ptr<T>>
+  {
+    static bool verify()
+    {
+      return Type<T>::verify();
+    }
+  };
+}

data/rice/stl/unordered_map.hpp

@@ -0,0 +1,12 @@
+#ifndef Rice__stl__unordered_map__hpp_
+#define Rice__stl__unordered_map__hpp_
+
+namespace Rice
+{
+  template<typename Key, typename T>
+  Data_Type<std::unordered_map<Key, T>> define_unordered_map(std::string name = "");
+}
+
+#include "unordered_map.ipp"
+
+#endif // Rice__stl__unordered_map__hpp_

data/rice/stl/unordered_map.ipp

@@ -0,0 +1,469 @@
+#include <unordered_map>
+
+namespace Rice
+{
+  namespace stl
+  {
+    template<typename T>
+    class UnorderedMapHelper
+    {
+      using Key_T = typename T::key_type;
+      using Mapped_T = typename T::mapped_type;
+      using Value_T = typename T::value_type;
+      using Reference_T = typename T::reference;
+      using Size_T = typename T::size_type;
+      using Difference_T = typename T::difference_type;
+      using To_Ruby_T = typename detail::remove_cv_recursive_t<Mapped_T>;
+
+    public:
+      UnorderedMapHelper(Data_Type<T> klass) : klass_(klass)
+      {
+        this->register_pair();
+        this->define_constructor();
+        this->define_copyable_methods();
+        this->define_capacity_methods();
+        this->define_access_methods();
+        this->define_comparable_methods();
+        this->define_modify_methods();
+        this->define_enumerable();
+        this->define_to_s();
+        this->define_to_hash();
+      }
+
+    private:
+
+      void register_pair()
+      {
+        define_pair<const Key_T, T>();
+      }
+
+      void define_constructor()
+      {
+        klass_.define_constructor(Constructor<T>());
+      }
+
+      void define_copyable_methods()
+      {
+        if constexpr (std::is_copy_constructible_v<Value_T>)
+        {
+          klass_.define_method("copy", [](T& unordered_map) -> T
+            {
+              return unordered_map;
+            });
+        }
+        else
+        {
+          klass_.define_method("copy", [](T& unordered_map) -> T
+            {
+              throw std::runtime_error("Cannot copy unordered_maps with non-copy constructible types");
+              return unordered_map;
+            });
+        }
+      }
+
+      void define_capacity_methods()
+      {
+        klass_.define_method("empty?", &T::empty)
+          .define_method("max_size", &T::max_size)
+          .define_method("size", &T::size);
+        
+        rb_define_alias(klass_, "count", "size");
+        rb_define_alias(klass_, "length", "size");
+      }
+
+      void define_access_methods()
+      {
+        // Access methods
+        klass_.define_method("[]", [](const T& unordered_map, const Key_T& key) -> std::optional<Mapped_T>
+          {
+            auto iter = unordered_map.find(key);
+
+            if (iter != unordered_map.end())
+            {
+              return iter->second;
+            }
+            else
+            {
+              return std::nullopt;
+            }
+          })
+          .define_method("include?", [](T& unordered_map, Key_T& key) -> bool
+          {
+              return unordered_map.find(key) != unordered_map.end();
+          })
+          .define_method("keys", [](T& unordered_map) -> std::vector<Key_T>
+            {
+              std::vector<Key_T> result;
+              std::transform(unordered_map.begin(), unordered_map.end(), std::back_inserter(result),
+                [](const auto& pair)
+                {
+                  return pair.first;
+                });
+
+              return result;
+            })
+          .define_method("values", [](T& unordered_map) -> std::vector<Mapped_T>
+            {
+              std::vector<Mapped_T> result;
+              std::transform(unordered_map.begin(), unordered_map.end(), std::back_inserter(result),
+                [](const auto& pair)
+                {
+                  return pair.second;
+                });
+
+              return result;
+            });
+
+            rb_define_alias(klass_, "has_key", "include?");
+      }
+
+      // Methods that require Value_T to support operator==
+      void define_comparable_methods()
+      {
+        if constexpr (detail::is_comparable_v<Mapped_T>)
+        {
+          klass_.define_method("value?", [](T& unordered_map, Mapped_T& value) -> bool
+            {
+              auto it = std::find_if(unordered_map.begin(), unordered_map.end(),
+              [&value](auto& pair)
+                {
+                  return pair.second == value;
+                });
+
+              return it != unordered_map.end();
+          });
+        }
+        else
+        {
+          klass_.define_method("value?", [](T& unordered_map, Mapped_T& value) -> bool
+          {
+              return false;
+          });
+        }
+
+        rb_define_alias(klass_, "has_value", "value?");
+      }
+
+      void define_modify_methods()
+      {
+        klass_.define_method("clear", &T::clear)
+          .define_method("delete", [](T& unordered_map, Key_T& key) -> std::optional<Mapped_T>
+            {
+              auto iter = unordered_map.find(key);
+
+              if (iter != unordered_map.end())
+              {
+                Mapped_T result = iter->second;
+                unordered_map.erase(iter);
+                return result;
+              }
+              else
+              {
+                return std::nullopt;
+              }
+            })
+          .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_T& value) -> Mapped_T
+            {
+              unordered_map[key] = value;
+              return value;
+            });
+
+          rb_define_alias(klass_, "store", "[]=");
+      }
+
+      void define_enumerable()
+      {
+        // Add enumerable support
+        klass_.template define_iterator<typename T::iterator (T::*)()>(&T::begin, &T::end);
+      }
+
+      void define_to_hash()
+      {
+        // Add enumerable support
+        klass_.define_method("to_h", [](T& unordered_map)
+        {
+          VALUE result = rb_hash_new();
+          std::for_each(unordered_map.begin(), unordered_map.end(), [&result](const Reference_T& pair)
+          {
+            VALUE key = detail::To_Ruby<Key_T&>().convert(pair.first);
+            VALUE value = detail::To_Ruby<To_Ruby_T&>().convert(pair.second);
+            rb_hash_aset(result, key, value);
+          });
+
+          return result;
+        }, Return().setValue());
+      }
+
+      void define_to_s()
+      {
+        if constexpr (detail::is_ostreamable_v<Key_T> && detail::is_ostreamable_v<Mapped_T>)
+        {
+          klass_.define_method("to_s", [](const T& unordered_map)
+            {
+              auto iter = unordered_map.begin();
+
+              std::stringstream stream;
+              stream << "{";
+
+              for (; iter != unordered_map.end(); iter++)
+              {
+                if (iter != unordered_map.begin())
+                {
+                  stream << ", ";
+                }
+                stream << iter->first << " => " << iter->second;
+              }
+
+              stream << "}";
+              return stream.str();
+            });
+        }
+        else
+        {
+          klass_.define_method("to_s", [](const T& unordered_map)
+            {
+              return "[Not printable]";
+            });
+        }
+      }
+
+      private:
+        Data_Type<T> klass_;
+    };
+  } // namespace
+
+  template<typename Key, typename T>
+  Data_Type<std::unordered_map<Key, T>> define_unordered_map(std::string klassName)
+  {
+    using UnorderedMap_T = std::unordered_map<Key, T>;
+    using Data_Type_T = Data_Type<UnorderedMap_T>;
+
+    if (klassName.empty())
+    {
+      std::string typeName = detail::typeName(typeid(UnorderedMap_T));
+      klassName = detail::rubyClassName(typeName);
+    }
+
+    Module rb_mStd = define_module("Std");
+    if (Data_Type_T::check_defined(klassName, rb_mStd))
+    {
+      return Data_Type_T();
+    }
+
+    Identifier id(klassName);
+    Data_Type_T result = define_class_under<detail::intrinsic_type<UnorderedMap_T>>(rb_mStd, id);
+    stl::UnorderedMapHelper helper(result);
+    return result;
+  }
+
+  namespace detail
+  {
+    template<typename Key_T, typename T>
+    struct Type<std::unordered_map<Key_T, T>>
+    {
+      static bool verify()
+      {
+        Type<Key_T>::verify();
+        Type<T>::verify();
+
+        if (!Data_Type<std::unordered_map<Key_T, T>>::is_defined())
+        {
+          define_unordered_map<Key_T, T>();
+        }
+
+        return true;
+      }
+    };
+
+    template<typename T, typename U>
+    struct UnorderedMapFromHash
+    {
+      static int convertPair(VALUE key, VALUE value, VALUE user_data)
+      {
+        std::unordered_map<T, U>* result = (std::unordered_map<T, U>*)(user_data);
+
+        // This method is being called from Ruby so we cannot let any C++ 
+        // exceptions propogate back to Ruby
+        return cpp_protect([&]
+        {
+          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          return ST_CONTINUE;
+        });
+      }
+
+      static std::unordered_map<T, U> convert(VALUE value)
+      {
+        std::unordered_map<T, U> result;
+        VALUE user_data = (VALUE)(&result);
+
+        // MSVC needs help here, but g++ does not
+        using Rb_Hash_ForEach_T = void(*)(VALUE, int(*)(VALUE, VALUE, VALUE), VALUE);
+        detail::protect<Rb_Hash_ForEach_T>(rb_hash_foreach, value, convertPair, user_data);
+
+        return result;
+      }
+    };
+
+    template<typename T, typename U>
+    class From_Ruby<std::unordered_map<T, U>>
+    {
+    public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg * arg) : arg_(arg)
+      {
+      }
+
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::unordered_map<T, U> convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped unordered_map (hopefully!)
+            return *detail::unwrap<std::unordered_map<T, U>>(value, Data_Type<std::unordered_map<T, U>>::ruby_data_type(), false);
+          }
+          case RUBY_T_HASH:
+          {
+            // If this an Ruby hash and the unordered_mapped type is copyable
+            if constexpr (std::is_default_constructible_v<U>)
+            {
+              return UnorderedMapFromHash<T, U>::convert(value);
+            }
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::unordered_map");
+          }
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
+    template<typename T, typename U>
+    class From_Ruby<std::unordered_map<T, U>&>
+    {
+    public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg * arg) : arg_(arg)
+      {
+      }
+
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::unordered_map<T, U>& convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped unordered_map (hopefully!)
+            return *detail::unwrap<std::unordered_map<T, U>>(value, Data_Type<std::unordered_map<T, U>>::ruby_data_type(), false);
+          }
+          case RUBY_T_HASH:
+          {
+            // If this an Ruby array and the unordered_map type is copyable
+            if constexpr (std::is_default_constructible_v<std::unordered_map<T, U>>)
+            {
+              this->converted_ = UnorderedMapFromHash<T, U>::convert(value);
+              return this->converted_;
+            }
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::unordered_map");
+          }
+        }
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+      std::unordered_map<T, U> converted_;
+    };
+
+    template<typename T, typename U>
+    class From_Ruby<std::unordered_map<T, U>*>
+    {
+    public:
+      Convertible is_convertible(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+            return Data_Type<std::unordered_map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+            break;
+          case RUBY_T_NIL:
+            return Convertible::Exact;
+            break;
+          case RUBY_T_HASH:
+            return Convertible::Cast;
+            break;
+          default:
+            return Convertible::None;
+        }
+      }
+
+      std::unordered_map<T, U>* convert(VALUE value)
+      {
+        switch (rb_type(value))
+        {
+          case RUBY_T_DATA:
+          {
+            // This is a wrapped unordered_map (hopefully!)
+            return detail::unwrap<std::unordered_map<T, U>>(value, Data_Type<std::unordered_map<T, U>>::ruby_data_type(), false);
+          }
+          case RUBY_T_HASH:
+          {
+            // If this an Ruby array and the unordered_map type is copyable
+            if constexpr (std::is_default_constructible_v<U>)
+            {
+              this->converted_ = UnorderedMapFromHash<T, U>::convert(value);
+              return &this->converted_;
+            }
+          }
+          default:
+          {
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+              detail::protect(rb_obj_classname, value), "std::unordered_map");
+          }
+        }
+      }
+
+    private:
+      std::unordered_map<T, U> converted_;
+    };
+  }
+}

data/rice/stl/variant.hpp

@@ -0,0 +1,6 @@
+#ifndef Rice__stl__variant__hpp_
+#define Rice__stl__variant__hpp_
+
+#include "variant.ipp"
+
+#endif // Rice__stl__variant__hpp_