rice 4.5.0 → 4.6.0

data/rice/stl/shared_ptr.hpp

@@ -0,0 +1,28 @@
+#ifndef Rice__stl__shared_ptr__hpp_
+#define Rice__stl__shared_ptr__hpp_
+
+namespace Rice::detail
+{
+  template<typename T>
+  class Wrapper<std::shared_ptr<T>> : public WrapperBase
+  {
+  public:
+    Wrapper(const std::shared_ptr<T>& data);
+    ~Wrapper();
+    void* get() override;
+    std::shared_ptr<T>& data();
+
+  private:
+    std::shared_ptr<T> data_;
+  };
+}
+
+namespace Rice
+{
+  template<typename T>
+  Data_Type<std::shared_ptr<T>> define_shared_ptr(std::string klassName = "");
+}
+
+#include "shared_ptr.ipp"
+
+#endif // Rice__stl__shared_ptr__hpp_

data/rice/stl/shared_ptr.ipp

@@ -0,0 +1,224 @@
+#include <memory>
+
+// --------- Enable creation of std::shared_ptr from Ruby ---------
+namespace Rice
+{
+  template<typename T>
+  Data_Type<std::shared_ptr<T>> define_shared_ptr(std::string klassName)
+  {
+    using SharedPtr_T = std::shared_ptr<T>;
+    using Data_Type_T = Data_Type<SharedPtr_T>;
+
+    if (klassName.empty())
+    {
+      std::string typeName = detail::typeName(typeid(SharedPtr_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<SharedPtr_T>>(rb_mStd, id).
+      define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+
+    return result;
+  }
+}
+
+// --------- Wrapper ---------
+namespace Rice::detail
+{
+  template<typename T>
+  inline Wrapper<std::shared_ptr<T>>::Wrapper(const std::shared_ptr<T>& data)
+    : data_(data)
+  {
+  }
+
+  template<typename T>
+  inline Wrapper<std::shared_ptr<T>>::~Wrapper()
+  {
+    Registries::instance.instances.remove(this->get());
+  }
+
+  template<typename T>
+  inline void* Wrapper<std::shared_ptr<T>>::get()
+  {
+    return (void*)this->data_.get();
+  }
+
+  template<typename T>
+  inline std::shared_ptr<T>& Wrapper<std::shared_ptr<T>>::data()
+  {
+    return data_;
+  }
+}
+
+// --------- Type/To_Ruby/From_Ruby ---------
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type<std::shared_ptr<T>>
+  {
+    static bool verify()
+    {
+      return Type<T>::verify();
+    }
+  };
+
+  template <typename T>
+  class To_Ruby<std::shared_ptr<T>>
+  {
+  public:
+    VALUE convert(std::shared_ptr<T>& data)
+    {
+      if constexpr (std::is_fundamental_v<T>)
+      {
+        return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+      }
+      else
+      {
+        return detail::wrap<std::shared_ptr<T>>(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+      }
+    }
+
+    VALUE convert(std::shared_ptr<T>&& data)
+    {
+      if constexpr (std::is_fundamental_v<T>)
+      {
+        return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+      }
+      else
+      {
+        return detail::wrap<std::shared_ptr<T>>(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+      }
+    }
+  };
+
+  template <typename T>
+  class From_Ruby<std::shared_ptr<T>>
+  {
+  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 Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::shared_ptr<T> convert(VALUE value)
+    {
+      // Get the wrapper
+      WrapperBase* wrapperBase = detail::getWrapper(value);
+
+      // Was this shared_ptr created by the user from Ruby? If so it will
+      // be wrapped as a pointer, std::shared_ptr<T>*. In the case just
+      // return the shared pointer
+      if (dynamic_cast<Wrapper<std::shared_ptr<T>*>*>(wrapperBase))
+      {
+        // Use unwrap to validate the underlying wrapper is the correct type
+        std::shared_ptr<T>* ptr = unwrap<std::shared_ptr<T>>(value, Data_Type<std::shared_ptr<T>>::ruby_data_type(), false);
+        return *ptr;
+      }
+      else if constexpr (std::is_fundamental_v<T>)
+      {
+        // Get the wrapper again to validate T's type
+        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
+        return wrapper->data();
+      }
+      else
+      {
+        // Get the wrapper again to validate T's type
+        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
+        return wrapper->data();
+      }
+    }
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template <typename T>
+  class To_Ruby<std::shared_ptr<T>&>
+  {
+  public:
+    VALUE convert(std::shared_ptr<T>& data)
+    {
+      if constexpr (std::is_fundamental_v<T>)
+      {
+        return detail::wrap(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+      }
+      else
+      {
+        return detail::wrap<std::shared_ptr<T>>(Data_Type<T>::klass(), Data_Type<T>::ruby_data_type(), data, true);
+      }
+    }
+  };
+
+  template <typename T>
+  class From_Ruby<std::shared_ptr<T>&>
+  {
+  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 Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::shared_ptr<T>& convert(VALUE value)
+    {
+      // Get the wrapper
+      WrapperBase* wrapperBase = detail::getWrapper(value);
+
+      // Was this shared_ptr created by the user from Ruby? If so it will
+      // be wrapped as a pointer, std::shared_ptr<T>*. In the case just
+      // return the shared pointer
+      if (dynamic_cast<Wrapper<std::shared_ptr<T>*>*>(wrapperBase))
+      {
+        // Use unwrap to validate the underlying wrapper is the correct type
+        std::shared_ptr<T>* ptr = unwrap<std::shared_ptr<T>>(value, Data_Type<std::shared_ptr<T>>::ruby_data_type(), false);
+        return *ptr;
+      }
+      else if constexpr (std::is_fundamental_v<T>)
+      {
+        // Get the wrapper again to validate T's type
+        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
+        return wrapper->data();
+      }
+      else
+      {
+        // Get the wrapper again to validate T's type
+        Wrapper<std::shared_ptr<T>>* wrapper = getWrapper<Wrapper<std::shared_ptr<T>>>(value, Data_Type<T>::ruby_data_type());
+        return wrapper->data();
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+}

data/rice/stl/string.hpp

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

data/rice/stl/string.ipp

@@ -0,0 +1,158 @@
+#include <string>
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::string>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class To_Ruby<std::string>
+  {
+  public:
+    VALUE convert(const std::string& x)
+    {
+      return detail::protect(rb_external_str_new, x.data(), (long)x.size());
+    }
+  };
+
+  template<>
+  class To_Ruby<std::string&>
+  {
+  public:
+    VALUE convert(const std::string& x)
+    {
+      return detail::protect(rb_external_str_new, x.data(), (long)x.size());
+    }
+  };
+
+  template<>
+  class To_Ruby<std::string*>
+  {
+  public:
+    VALUE convert(const std::string* x)
+    {
+      return detail::protect(rb_external_str_new, x->data(), (long)x->size());
+    }
+  };
+
+  template<>
+  class To_Ruby<std::string*&>
+  {
+  public:
+    VALUE convert(const std::string* x)
+    {
+      return detail::protect(rb_external_str_new, x->data(), (long)x->size());
+    }
+  };
+
+  template<>
+  class To_Ruby<std::string**>
+  {
+  public:
+    VALUE convert(std::string** data)
+    {
+      Buffer<std::string*> buffer(data);
+      Data_Object<Buffer<std::string*>> dataObject(std::move(buffer));
+      return dataObject.value();
+    }
+  };
+
+  template<>
+  class From_Ruby<std::string>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_STRING:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::string convert(VALUE value)
+    {
+      detail::protect(rb_check_type, value, (int)T_STRING);
+      return std::string(RSTRING_PTR(value), RSTRING_LEN(value));
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class From_Ruby<std::string&>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_STRING:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::string& convert(VALUE value)
+    {
+      detail::protect(rb_check_type, value, (int)T_STRING);
+      this->converted_ = std::string(RSTRING_PTR(value), RSTRING_LEN(value));
+      return this->converted_;
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    std::string converted_ = "";
+  };
+
+  template<>
+  class From_Ruby<std::string*>
+  {
+  public:
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_STRING:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::string* convert(VALUE value)
+    {
+      detail::protect(rb_check_type, value, (int)T_STRING);
+      this->converted_ = std::string(RSTRING_PTR(value), RSTRING_LEN(value));
+      return &this->converted_;
+    }
+
+  private:
+    std::string converted_;
+  };
+}

data/rice/stl/string_view.hpp

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

data/rice/stl/string_view.ipp

@@ -0,0 +1,65 @@
+#include <string_view>
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::string_view>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class To_Ruby<std::string_view>
+  {
+  public:
+    VALUE convert(std::string_view const& x)
+    {
+      return detail::protect(rb_external_str_new, x.data(), (long)x.size());
+    }
+  };
+
+  template<>
+  class To_Ruby<std::string_view&>
+  {
+  public:
+    VALUE convert(std::string_view const& x)
+    {
+      return detail::protect(rb_external_str_new, x.data(), (long)x.size());
+    }
+  };
+
+  template<>
+  class From_Ruby<std::string_view>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_STRING:
+          return Convertible::Exact;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+
+    std::string_view convert(VALUE value)
+    {
+      detail::protect(rb_check_type, value, (int)T_STRING);
+      return std::string_view(RSTRING_PTR(value), RSTRING_LEN(value));
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+}

data/rice/stl/tuple.hpp

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

data/rice/stl/tuple.ipp

@@ -0,0 +1,128 @@
+#include <tuple>
+
+namespace Rice::detail
+{
+  template<typename...Types>
+  struct Type<std::tuple<Types...>>
+  {
+    using Tuple_T = std::tuple<Types...>;
+
+    template<std::size_t... I>
+    constexpr static bool verifyTypes(std::index_sequence<I...>& indices)
+    {
+      return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
+    }
+
+    template<std::size_t... I>
+    constexpr static bool verify()
+    {
+      auto indices = std::make_index_sequence<std::tuple_size_v<std::tuple<Types...>>>{};
+      return verifyTypes(indices);
+    }
+  };
+
+  template<typename...Types>
+  class To_Ruby<std::tuple<Types...>>
+  {
+  public:
+    static VALUE convert(const std::tuple<Types...>& data, bool takeOwnership = false)
+    {
+      Array result;
+
+      for_each_tuple(data, [&](auto element)
+      {
+        using Element_T = decltype(element);
+        result.push<Element_T>((Element_T)element);
+      });
+
+      return result.value();
+    }
+  };
+
+  template<typename...Types>
+  class To_Ruby<std::tuple<Types...>&>
+  {
+  public:
+    static VALUE convert(const std::tuple<Types...>& data, bool takeOwnership = false)
+    {
+      Array result;
+
+      for_each_tuple(data, [&](auto& value)
+        {
+          VALUE element = detail::To_Ruby<decltype(value)>().convert(value);
+          result.push(element);
+        });
+
+      return result.value();
+    }
+  };
+
+  template<typename...Types>
+  class From_Ruby<std::tuple<Types...>>
+  {
+  public:
+    using Tuple_T = std::tuple<Types...>;
+
+    template<std::size_t... I>
+    constexpr static bool verifyTypes(Array& array, std::index_sequence<I...>& indices)
+    {
+      return (Type<std::tuple_element_t<I, Tuple_T>>::verify() && ...);
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      Convertible result = Convertible::None;
+
+      // The ruby value must be an array of the correct size
+      if (rb_type(value) != RUBY_T_ARRAY || Array(value).size() != std::tuple_size_v<Tuple_T>)
+      {
+        return result;
+      }
+      
+      // Now check that each tuple type is convertible
+      Array array(value);
+      int i = 0;
+      for_each_tuple(this->fromRubys_,
+        [&](auto& fromRuby)
+        {
+          result = result | fromRuby.is_convertible(array[i].value());
+          i++;
+        });
+
+      return result;
+    }
+
+    template <std::size_t... I>
+    std::tuple<Types...> convertInternal(Array array, std::index_sequence<I...>& indices)
+    {
+      return std::forward_as_tuple(std::get<I>(this->fromRubys_).convert(array[I].value())...);
+    }
+
+    std::tuple<Types...> convert(VALUE value)
+    {
+      Array array(value);
+      auto indices = std::make_index_sequence<std::tuple_size_v<Tuple_T>>{};
+      return convertInternal(array, indices);
+    }
+
+  private:
+    // Possible converters we could use for this variant
+    using From_Ruby_Ts = std::tuple<From_Ruby<Types>...>;
+    From_Ruby_Ts fromRubys_;
+  };
+
+/*  template<typename...Types>
+  class From_Ruby<std::tuple<Types...>&> : public From_Ruby<std::tuple<Types...>>
+  {
+  public:
+    std::tuple<Types...>& convert(VALUE value)
+    {
+      int index = this->figureIndex(value);
+      this->converted_ = this->convertInternal(value, index);
+      return this->converted_;
+    }
+
+  private:
+    std::tuple<Types...> converted_;
+  };*/
+}

data/rice/stl/type_index.hpp

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

data/rice/stl/type_index.ipp

@@ -0,0 +1,30 @@
+#include <typeindex>
+
+namespace Rice::stl
+{
+  inline Data_Type<std::type_index> define_type_index()
+  {
+    Module rb_mStd = define_module("Std");
+    return define_class_under<std::type_index>(rb_mStd, "TypeIndex").
+      define_constructor(Constructor<std::type_index, const std::type_info&>()).
+      define_method("hash_code", &std::type_index::hash_code).
+      define_method("name", &std::type_index::name);
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::type_index>
+  {
+    static bool verify()
+    {
+      if (!detail::Registries::instance.types.isDefined<std::type_index>())
+      {
+        stl::define_type_index();
+      }
+
+      return true;
+    }
+  };
+}

data/rice/stl/type_info.hpp

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

data/rice/stl/type_info.ipp

@@ -0,0 +1,29 @@
+#include <typeinfo>
+
+namespace Rice::stl
+{
+  inline Data_Type<std::type_info> define_type_info()
+  {
+    Module rb_mStd = define_module("Std");
+    return define_class_under<std::type_info>(rb_mStd, "TypeInfo").
+      define_method("hash_code", &std::type_info::hash_code).
+      define_method("name", &std::type_info::name);
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::type_info>
+  {
+    static inline bool verify()
+    {
+      if (!detail::Registries::instance.types.isDefined<std::type_info>())
+      {
+        stl::define_type_info();
+      }
+
+      return true;
+    }
+  };
+}