replace C-style pointer cast type deduction by 'std::declval<>()' (#572)

* updated Catch2 to v2.13.8 (216713a)

... previous version does not compile on more modern Linux OSes

* replaced C-style pointer cast type deduction by 'std::declval<>()'

addresses issue #570

* replaced C-style typedef type aliasing by 'using type = '

see also [C++ Core Guidelines - T.43](
http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rt-using)

N.B. this should make later refactoring (and possible introduction of 'concepts') a bit easier ...

* replaced 'std::is_same<...>::value' by 'std::is_same_v<...>'

* replaced 'std::conditional<...>::type' by 'std::conditional_t<...>'

Author: RalphSteinhagen

Rx/v2/src/rxcpp/operators/rx-all.hpp

@@ -42,11 +42,11 @@ using all_invalid_t = typename all_invalid<AN...>::type;
 template<class T, class Predicate>
 struct all
 {
-    typedef rxu::decay_t<T> source_value_type;
-    typedef rxu::decay_t<Predicate> test_type;
+    using source_value_type = rxu::decay_t<T>;
+    using test_type = rxu::decay_t<Predicate>;
     test_type test;
 
-    typedef bool value_type;
+    using value_type = bool;
 
     all(test_type t)
         : test(std::move(t))
@@ -56,10 +56,10 @@ struct all
     template<class Subscriber>
     struct all_observer
     {
-        typedef all_observer<Subscriber> this_type;
-        typedef source_value_type value_type;
-        typedef rxu::decay_t<Subscriber> dest_type;
-        typedef observer<value_type, this_type> observer_type;
+        using this_type = all_observer<Subscriber>;
+        using value_type = source_value_type;
+        using dest_type = rxu::decay_t<Subscriber>;
+        using observer_type = observer<value_type, this_type>;
         dest_type dest;
         test_type test;
         mutable bool done;

Rx/v2/src/rxcpp/operators/rx-amb.hpp

@@ -64,16 +64,16 @@ struct amb
     //static_assert(is_observable<Observable>::value, "amb requires an observable");
     //static_assert(is_observable<T>::value, "amb requires an observable that contains observables");
 
-    typedef amb<T, Observable, Coordination> this_type;
+    using this_type = amb<T, Observable, Coordination>;
 
-    typedef rxu::decay_t<T> source_value_type;
-    typedef rxu::decay_t<Observable> source_type;
+    using source_value_type = rxu::decay_t<T>;
+    using source_type = rxu::decay_t<Observable>;
 
-    typedef typename source_type::source_operator_type source_operator_type;
-    typedef typename source_value_type::value_type value_type;
+    using source_operator_type = typename source_type::source_operator_type;
+    using value_type = typename source_value_type::value_type;
 
-    typedef rxu::decay_t<Coordination> coordination_type;
-    typedef typename coordination_type::coordinator_type coordinator_type;
+    using coordination_type = rxu::decay_t<Coordination>;
+    using coordinator_type = typename coordination_type::coordinator_type;
 
     struct values
     {
@@ -96,7 +96,7 @@ struct amb
     void on_subscribe(Subscriber scbr) const {
         static_assert(is_subscriber<Subscriber>::value, "subscribe must be passed a subscriber");
 
-        typedef Subscriber output_type;
+        using output_type = Subscriber;
 
         struct amb_state_type
             : public std::enable_shared_from_this<amb_state_type>

Rx/v2/src/rxcpp/operators/rx-any.hpp

@@ -50,9 +50,9 @@ using any_invalid_t = typename any_invalid<AN...>::type;
 template<class T, class Predicate>
 struct any
 {
-    typedef rxu::decay_t<T> source_value_type;
-    typedef bool value_type;
-    typedef rxu::decay_t<Predicate> test_type;
+    using source_value_type = rxu::decay_t<T>;
+    using value_type = bool;
+    using test_type = rxu::decay_t<Predicate>;
     test_type test;
 
     any(test_type t)
@@ -63,10 +63,10 @@ struct any
     template<class Subscriber>
     struct any_observer
     {
-        typedef any_observer<Subscriber> this_type;
-        typedef source_value_type value_type;
-        typedef rxu::decay_t<Subscriber> dest_type;
-        typedef observer<value_type, this_type> observer_type;
+        using this_type = any_observer<Subscriber>;
+        using value_type = source_value_type;
+        using dest_type = rxu::decay_t<Subscriber>;
+        using observer_type = observer<value_type, this_type>;
         dest_type dest;
         test_type test;
         mutable bool done;

Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp

@@ -46,8 +46,8 @@ using buffer_count_invalid_t = typename buffer_count_invalid<AN...>::type;
 template<class T>
 struct buffer_count
 {
-    typedef rxu::decay_t<T> source_value_type;
-    typedef std::vector<source_value_type> value_type;
+    using source_value_type = rxu::decay_t<T>;
+    using value_type = std::vector<source_value_type>;
 
     struct buffer_count_values
     {
@@ -70,10 +70,10 @@ struct buffer_count
     template<class Subscriber>
     struct buffer_count_observer : public buffer_count_values
     {
-        typedef buffer_count_observer<Subscriber> this_type;
-        typedef std::vector<T> value_type;
-        typedef rxu::decay_t<Subscriber> dest_type;
-        typedef observer<value_type, this_type> observer_type;
+        using this_type = buffer_count_observer<Subscriber>;
+        using value_type = std::vector<T>;
+        using dest_type = rxu::decay_t<Subscriber>;
+        using observer_type = observer<value_type, this_type>;
         dest_type dest;
         mutable int cursor;
         mutable std::deque<value_type> chunks;

Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp

@@ -66,11 +66,11 @@ using buffer_with_time_invalid_t = typename buffer_with_time_invalid<AN...>::typ
 template<class T, class Duration, class Coordination>
 struct buffer_with_time
 {
-    typedef rxu::decay_t<T> source_value_type;
-    typedef std::vector<source_value_type> value_type;
-    typedef rxu::decay_t<Coordination> coordination_type;
-    typedef typename coordination_type::coordinator_type coordinator_type;
-    typedef rxu::decay_t<Duration> duration_type;
+    using source_value_type = rxu::decay_t<T>;
+    using value_type = std::vector<source_value_type>;
+    using coordination_type = rxu::decay_t<Coordination>;
+    using coordinator_type = typename coordination_type::coordinator_type;
+    using duration_type = rxu::decay_t<Duration>;
 
     struct buffer_with_time_values
     {
@@ -94,10 +94,10 @@ struct buffer_with_time
     template<class Subscriber>
     struct buffer_with_time_observer
     {
-        typedef buffer_with_time_observer<Subscriber> this_type;
-        typedef std::vector<T> value_type;
-        typedef rxu::decay_t<Subscriber> dest_type;
-        typedef observer<value_type, this_type> observer_type;
+        using this_type = buffer_with_time_observer<Subscriber>;
+        using value_type = std::vector<T>;
+        using dest_type = rxu::decay_t<Subscriber>;
+        using observer_type = observer<value_type, this_type>;
 
         struct buffer_with_time_subscriber_values : public buffer_with_time_values
         {

Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp

@@ -48,11 +48,11 @@ using buffer_with_time_or_count_invalid_t = typename buffer_with_time_or_count_i
 template<class T, class Duration, class Coordination>
 struct buffer_with_time_or_count
 {
-    typedef rxu::decay_t<T> source_value_type;
-    typedef std::vector<source_value_type> value_type;
-    typedef rxu::decay_t<Coordination> coordination_type;
-    typedef typename coordination_type::coordinator_type coordinator_type;
-    typedef rxu::decay_t<Duration> duration_type;
+    using source_value_type = rxu::decay_t<T>;
+    using value_type = std::vector<source_value_type>;
+    using coordination_type = rxu::decay_t<Coordination>;
+    using coordinator_type = typename coordination_type::coordinator_type;
+    using duration_type = rxu::decay_t<Duration>;
 
     struct buffer_with_time_or_count_values
     {
@@ -76,10 +76,10 @@ struct buffer_with_time_or_count
     template<class Subscriber>
     struct buffer_with_time_or_count_observer
     {
-        typedef buffer_with_time_or_count_observer<Subscriber> this_type;
-        typedef std::vector<T> value_type;
-        typedef rxu::decay_t<Subscriber> dest_type;
-        typedef observer<value_type, this_type> observer_type;
+        using this_type = buffer_with_time_or_count_observer<Subscriber>;
+        using value_type = std::vector<T>;
+        using dest_type = rxu::decay_t<Subscriber>;
+        using observer_type = observer<value_type, this_type>;
 
         struct buffer_with_time_or_count_subscriber_values : public buffer_with_time_or_count_values
         {
@@ -99,7 +99,8 @@ struct buffer_with_time_or_count
             mutable int chunk_id;
             mutable value_type chunk;
         };
-        typedef std::shared_ptr<buffer_with_time_or_count_subscriber_values> state_type;
+
+        using state_type = std::shared_ptr<buffer_with_time_or_count_subscriber_values>;
         state_type state;
 
         buffer_with_time_or_count_observer(composite_subscription cs, dest_type d, buffer_with_time_or_count_values v, coordinator_type c)

Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp

@@ -58,17 +58,17 @@ using combine_latest_invalid_t = typename combine_latest_invalid<AN...>::type;
 
 template<class Selector, class... ObservableN>
 struct is_combine_latest_selector_check {
-    typedef rxu::decay_t<Selector> selector_type;
+    using selector_type = rxu::decay_t<Selector>;
 
     struct tag_not_valid;
     template<class CS, class... CON>
-    static auto check(int) -> decltype((*(CS*)nullptr)((*(typename CON::value_type*)nullptr)...));
+    static auto check(int) -> decltype(std::declval<CS>()((std::declval<typename CON::value_type>())...));
     template<class CS, class... CON>
     static tag_not_valid check(...);
 
     using type = decltype(check<selector_type, rxu::decay_t<ObservableN>...>(0));
 
-    static const bool value = !std::is_same<type, tag_not_valid>::value;
+    static const bool value = !std::is_same_v<type, tag_not_valid>;
 };
 
 template<class Selector, class... ObservableN>
@@ -77,10 +77,10 @@ struct invalid_combine_latest_selector {
 };
 
 template<class Selector, class... ObservableN>
-struct is_combine_latest_selector : public std::conditional<
+struct is_combine_latest_selector : public std::conditional_t<
     is_combine_latest_selector_check<Selector, ObservableN...>::value, 
     is_combine_latest_selector_check<Selector, ObservableN...>, 
-    invalid_combine_latest_selector<Selector, ObservableN...>>::type {
+    invalid_combine_latest_selector<Selector, ObservableN...>> {
 };
 
 template<class Selector, class... ON>
@@ -89,29 +89,29 @@ using result_combine_latest_selector_t = typename is_combine_latest_selector<Sel
 template<class Coordination, class Selector, class... ObservableN>
 struct combine_latest_traits {
 
-    typedef std::tuple<ObservableN...> tuple_source_type;
-    typedef std::tuple<rxu::detail::maybe<typename ObservableN::value_type>...> tuple_source_value_type;
+    using tuple_source_type = std::tuple<ObservableN...>;
+    using tuple_source_value_type = std::tuple<rxu::detail::maybe < typename ObservableN::value_type>...>;
 
-    typedef rxu::decay_t<Selector> selector_type;
-    typedef rxu::decay_t<Coordination> coordination_type;
+    using selector_type = rxu::decay_t<Selector>;
+    using coordination_type = rxu::decay_t<Coordination>;
 
-    typedef typename is_combine_latest_selector<selector_type, ObservableN...>::type value_type;
+    using value_type = typename is_combine_latest_selector<selector_type, ObservableN...>::type;
 };
 
 template<class Coordination, class Selector, class... ObservableN>
 struct combine_latest : public operator_base<rxu::value_type_t<combine_latest_traits<Coordination, Selector, ObservableN...>>>
 {
-    typedef combine_latest<Coordination, Selector, ObservableN...> this_type;
+    using this_type = combine_latest<Coordination, Selector, ObservableN...>;
 
-    typedef combine_latest_traits<Coordination, Selector, ObservableN...> traits;
+    using traits = combine_latest_traits<Coordination, Selector, ObservableN...>;
 
-    typedef typename traits::tuple_source_type tuple_source_type;
-    typedef typename traits::tuple_source_value_type tuple_source_value_type;
+    using tuple_source_type = typename traits::tuple_source_type;
+    using tuple_source_value_type = typename traits::tuple_source_value_type;
 
-    typedef typename traits::selector_type selector_type;
+    using selector_type = typename traits::selector_type;
 
-    typedef typename traits::coordination_type coordination_type;
-    typedef typename coordination_type::coordinator_type coordinator_type;
+    using coordination_type = typename traits::coordination_type;
+    using coordinator_type = typename coordination_type::coordinator_type;
 
     struct values
     {
@@ -135,7 +135,7 @@ struct combine_latest : public operator_base<rxu::value_type_t<combine_latest_tr
     template<int Index, class State>
     void subscribe_one(std::shared_ptr<State> state) const {
 
-        typedef typename std::tuple_element<Index, tuple_source_type>::type::value_type source_value_type;
+        using source_value_type = typename std::tuple_element<Index, tuple_source_type>::type::value_type;
 
         composite_subscription innercs;
 
@@ -200,7 +200,7 @@ struct combine_latest : public operator_base<rxu::value_type_t<combine_latest_tr
     void on_subscribe(Subscriber scbr) const {
         static_assert(is_subscriber<Subscriber>::value, "subscribe must be passed a subscriber");
 
-        typedef Subscriber output_type;
+        using output_type = Subscriber;
 
         struct combine_latest_state_type
             : public std::enable_shared_from_this<combine_latest_state_type>

Rx/v2/src/rxcpp/operators/rx-concat.hpp

@@ -63,17 +63,17 @@ template<class T, class Observable, class Coordination>
 struct concat
     : public operator_base<rxu::value_type_t<rxu::decay_t<T>>>
 {
-    typedef concat<T, Observable, Coordination> this_type;
+    using this_type = concat<T, Observable, Coordination>;
 
-    typedef rxu::decay_t<T> source_value_type;
-    typedef rxu::decay_t<Observable> source_type;
-    typedef rxu::decay_t<Coordination> coordination_type;
+    using source_value_type = rxu::decay_t<T>;
+    using source_type = rxu::decay_t<Observable>;
+    using coordination_type = rxu::decay_t<Coordination>;
 
-    typedef typename coordination_type::coordinator_type coordinator_type;
+    using coordinator_type = typename coordination_type::coordinator_type;
 
-    typedef typename source_type::source_operator_type source_operator_type;
-    typedef source_value_type collection_type;
-    typedef typename collection_type::value_type value_type;
+    using source_operator_type = typename source_type::source_operator_type;
+    using collection_type = source_value_type;
+    using value_type = typename collection_type::value_type;
 
     struct values
     {
@@ -96,7 +96,7 @@ struct concat
     void on_subscribe(Subscriber scbr) const {
         static_assert(is_subscriber<Subscriber>::value, "subscribe must be passed a subscriber");
 
-        typedef Subscriber output_type;
+        using output_type = Subscriber;
 
         struct concat_state_type
             : public std::enable_shared_from_this<concat_state_type>