rice 4.0.3 → 4.1.0

data/rice/detail/rice_traits.hpp

@@ -1,116 +0,0 @@
-#ifndef Rice__detail__traits__hpp_
-#define Rice__detail__traits__hpp_
-
-#include <ostream>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-namespace Rice
-{
-  namespace detail
-  {
-    // Get the base_type of T - without pointer, reference, const or volatile
-    template<typename T>
-    using intrinsic_type = typename std::remove_cv_t<std::remove_reference_t<std::remove_pointer_t<T>>>;
-
-    // Recursively remove const/volatilr
-    template<typename T>
-    struct remove_cv_recursive
-    {
-      using type = T;
-    };
-
-    template<typename T>
-    struct remove_cv_recursive<T const volatile>
-    {
-      using type = typename remove_cv_recursive<T>::type;
-    };
-
-    template<typename T>
-    struct remove_cv_recursive<T volatile>
-    {
-      using type = typename remove_cv_recursive<T>::type;
-    };
-
-    template<typename T>
-    struct remove_cv_recursive<T const>
-    {
-      using type = typename remove_cv_recursive<T>::type;
-    };
-
-    template<typename T>
-    struct remove_cv_recursive<T&>
-    {
-      using type = typename remove_cv_recursive<T>::type&;
-    };
-
-   /* template<typename T>
-    struct remove_cv_recursive<T&&>
-    {
-      using type = typename remove_cv_recursive<T>::type&&;
-    };*/
-
-    template<typename T>
-    struct remove_cv_recursive<T*>
-    {
-      using type = typename remove_cv_recursive<T>::type*;
-    };
-
-    template<typename T>
-    using remove_cv_recursive_t = typename remove_cv_recursive<T>::type;
-
-    // Does the Type work with ostreams? This is used to implement #to_s
-    template<typename T, typename = void>
-    struct is_ostreamable : std::false_type {};
-
-    template<typename T>
-    struct is_ostreamable<T, std::void_t<decltype(std::declval<std::ostream&>() << std::declval<T>())>> : std::true_type {};
-
-    template<typename T>
-    constexpr bool is_ostreamable_v = is_ostreamable<T>::value;
-
-    // Is the type comparable?
-    template<typename T, typename SFINAE = void>
-    struct is_comparable : std::false_type {};
-
-    template<typename T>
-    struct is_comparable<T, std::void_t<decltype(std::declval<T>() == std::declval<T>())>> : std::true_type {};
-
-    template<typename T>
-    constexpr bool is_comparable_v = is_comparable<T>::value;
-
-    template <typename U, typename V>
-    struct is_comparable<std::pair<U, V>>
-    {
-      static const bool value = is_comparable_v<U> && is_comparable_v<V>;
-    };
-
-    template <typename T>
-    struct is_comparable<std::vector<T>>
-    {
-      static const bool value = is_comparable_v<T>;
-    };
-
-    // -- Tuple Helpers ---
-    template<typename T>
-    struct tuple_shift;
-
-    template<typename T, typename...Arg_Ts>
-    struct tuple_shift<std::tuple<T, Arg_Ts...>>
-    {
-      using type = std::tuple<Arg_Ts...>;
-    };
-     
-    template<template<typename, typename...> typename T, typename...Arg_Ts>
-    struct tuple_map;
-
-    template<template<typename, typename...> typename T, typename...Arg_Ts>
-    struct tuple_map<T, std::tuple<Arg_Ts...>>
-    {
-      using type = std::tuple<T<remove_cv_recursive_t<Arg_Ts>>...>;
-    };
-  } // detail
-} // Rice
-
-#endif // Rice__detail__traits__hpp_

data/rice/ruby_try_catch.hpp

@@ -1,86 +0,0 @@
-#ifndef Rice__ruby_try_catch__hpp_
-#define Rice__ruby_try_catch__hpp_
-
-#include <stdexcept>
-
-#include "detail/Jump_Tag.hpp"
-#include "Exception_defn.hpp"
-
-/*! \def RUBY_TRY
- *  \brief Start a block to catch Ruby exceptions and rethrow them.
- */
-// Goto is used here to avoid having to use a second try/catch block (we
-// can't rb_exc_raise directly out of the catch blocks below, since the
-// exceptions will not get properly cleaned up).
-// The labels are located before the try and not after it so the function can't
-// "fall through" into the exception-handling code accidentally.
-#define RUBY_TRY \
-  VALUE Rice__ruby_exc = Qnil; \
-  int Rice__ruby_jump_tag = 0; \
-  \
-  goto start_of_RUBY_TRY; \
-  \
-  Rice__ruby_exception: \
-    rb_exc_raise(Rice__ruby_exc); \
-  Rice__ruby_jump_tag: \
-    rb_jump_tag(Rice__ruby_jump_tag); \
-  \
-  start_of_RUBY_TRY: \
-  try
-
-/*! \def RUBY_RETHROW(ex)
- *  \brief Given a Ruby exception as a VALUE, safely raise the exception as a
- *         Ruby exception.  This should be used inside a RUBY_TRY/RUBY_CATCH
- *         block.
- */
-#define RUBY_RETHROW(ex) \
-  Rice__ruby_exc = ex; \
-  goto Rice__ruby_exception;
-
-/*! \def RUBY_CATCH
- *  \brief End a RUBY_TRY block.
- */
-#define RUBY_CATCH \
-  catch(::Rice::Exception const & ex) \
-  { \
-    RUBY_RETHROW(ex.value()); \
-  } \
-  catch(::Rice::Jump_Tag const & ex) \
-  { \
-    Rice__ruby_jump_tag = ex.tag; \
-    goto Rice__ruby_jump_tag; \
-  } \
-  catch(std::bad_alloc const & ex) \
-  { \
-    /* This won't work quite right if the rb_exc_new2 fails; not    */ \
-    /* much we can do about that, since Ruby doesn't give us access */ \
-    /* to a pre-allocated NoMemoryError object                      */ \
-    RUBY_RETHROW(rb_exc_new2(rb_eNoMemError, ex.what())); \
-  } \
-  catch(std::invalid_argument const & ex) \
-  { \
-    /* This can raise a NoMemoryError in VERY rare circumstances    */ \
-    RUBY_RETHROW(rb_exc_new2(rb_eArgError, ex.what())); \
-  } \
-  catch(std::domain_error const & ex) \
-  { \
-    /* This can raise a NoMemoryError in VERY rare circumstances    */ \
-    RUBY_RETHROW(rb_exc_new2(rb_eFloatDomainError, ex.what())); \
-  } \
-  catch(std::out_of_range const & ex) \
-  { \
-    /* This can raise a NoMemoryError in VERY rare circumstances    */ \
-    RUBY_RETHROW(rb_exc_new2(rb_eRangeError, ex.what())); \
-  } \
-  catch(std::exception const & ex) \
-  { \
-    /* This can raise a NoMemoryError in VERY rare circumstances    */ \
-    RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, ex.what())); \
-  } \
-  catch(...) \
-  { \
-    RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, "unknown C++ exception thrown")); \
-  } \
-
-#endif // Rice__ruby_try_catch__hpp_
-