diff options
Diffstat (limited to 'Rx/v2/src/rxcpp/operators')
36 files changed, 242 insertions, 242 deletions
diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp index 56507d4..b729311 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_count.hpp @@ -17,7 +17,7 @@ namespace detail { template<class T> struct buffer_count { - typedef typename std::decay<T>::type source_value_type; + typedef rxu::decay_t<T> source_value_type; struct buffer_count_values { buffer_count_values(int c, int s) @@ -41,7 +41,7 @@ struct buffer_count { typedef buffer_count_observer<Subscriber> this_type; typedef std::vector<T> value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<value_type, this_type> observer_type; dest_type dest; mutable int cursor; @@ -105,8 +105,8 @@ public: buffer_count_factory(int c, int s) : count(c), skip(s) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<std::vector<typename std::decay<Observable>::type::value_type>>(buffer_count<typename std::decay<Observable>::type::value_type>(count, skip))) { - return source.template lift<std::vector<typename std::decay<Observable>::type::value_type>>(buffer_count<typename std::decay<Observable>::type::value_type>(count, skip)); + -> decltype(source.template lift<std::vector<rxu::value_type_t<rxu::decay_t<Observable>>>>(buffer_count<rxu::value_type_t<rxu::decay_t<Observable>>>(count, skip))) { + return source.template lift<std::vector<rxu::value_type_t<rxu::decay_t<Observable>>>>(buffer_count<rxu::value_type_t<rxu::decay_t<Observable>>>(count, skip)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp index dac1302..5948347 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time.hpp @@ -19,10 +19,10 @@ struct buffer_with_time static_assert(std::is_convertible<Duration, rxsc::scheduler::clock_type::duration>::value, "Duration parameter must convert to rxsc::scheduler::clock_type::duration"); static_assert(is_coordination<Coordination>::value, "Coordination parameter must satisfy the requirements for a Coordination"); - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - typedef typename std::decay<Duration>::type duration_type; + typedef rxu::decay_t<Duration> duration_type; struct buffer_with_time_values { @@ -48,7 +48,7 @@ struct buffer_with_time { typedef buffer_with_time_observer<Subscriber> this_type; typedef std::vector<T> value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<value_type, this_type> observer_type; struct buffer_with_time_subscriber_values : public buffer_with_time_values @@ -131,8 +131,8 @@ struct buffer_with_time template<class Duration, class Coordination> class buffer_with_time_factory { - typedef typename std::decay<Duration>::type duration_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Duration> duration_type; + typedef rxu::decay_t<Coordination> coordination_type; duration_type period; duration_type skip; @@ -141,8 +141,8 @@ public: buffer_with_time_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<std::vector<typename std::decay<Observable>::type::value_type>>(buffer_with_time<typename std::decay<Observable>::type::value_type, Duration, Coordination>(period, skip, coordination))) { - return source.template lift<std::vector<typename std::decay<Observable>::type::value_type>>(buffer_with_time<typename std::decay<Observable>::type::value_type, Duration, Coordination>(period, skip, coordination)); + -> decltype(source.template lift<std::vector<rxu::value_type_t<rxu::decay_t<Observable>>>>(buffer_with_time<rxu::value_type_t<rxu::decay_t<Observable>>, Duration, Coordination>(period, skip, coordination))) { + return source.template lift<std::vector<rxu::value_type_t<rxu::decay_t<Observable>>>>(buffer_with_time<rxu::value_type_t<rxu::decay_t<Observable>>, Duration, Coordination>(period, skip, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp index ea4d608..87b6c2a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-buffer_time_count.hpp @@ -19,10 +19,10 @@ struct buffer_with_time_or_count static_assert(std::is_convertible<Duration, rxsc::scheduler::clock_type::duration>::value, "Duration parameter must convert to rxsc::scheduler::clock_type::duration"); static_assert(is_coordination<Coordination>::value, "Coordination parameter must satisfy the requirements for a Coordination"); - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - typedef typename std::decay<Duration>::type duration_type; + typedef rxu::decay_t<Duration> duration_type; struct buffer_with_time_or_count_values { @@ -48,7 +48,7 @@ struct buffer_with_time_or_count { typedef buffer_with_time_or_count_observer<Subscriber> this_type; typedef std::vector<T> value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<value_type, this_type> observer_type; struct buffer_with_time_or_count_subscriber_values : public buffer_with_time_or_count_values @@ -127,8 +127,8 @@ struct buffer_with_time_or_count template<class Duration, class Coordination> class buffer_with_time_or_count_factory { - typedef typename std::decay<Duration>::type duration_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Duration> duration_type; + typedef rxu::decay_t<Coordination> coordination_type; duration_type period; duration_type skip; @@ -137,8 +137,8 @@ public: buffer_with_time_or_count_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<std::vector<typename std::decay<Observable>::type::value_type>>(buffer_with_time_or_count<typename std::decay<Observable>::type::value_type, Duration, Coordination>(period, skip, coordination))) { - return source.template lift<std::vector<typename std::decay<Observable>::type::value_type>>(buffer_with_time_or_count<typename std::decay<Observable>::type::value_type, Duration, Coordination>(period, skip, coordination)); + -> decltype(source.template lift<std::vector<rxu::value_type_t<rxu::decay_t<Observable>>>>(buffer_with_time_or_count<rxu::value_type_t<rxu::decay_t<Observable>>, Duration, Coordination>(period, skip, coordination))) { + return source.template lift<std::vector<rxu::value_type_t<rxu::decay_t<Observable>>>>(buffer_with_time_or_count<rxu::value_type_t<rxu::decay_t<Observable>>, Duration, Coordination>(period, skip, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp index 3128217..3513dd0 100644 --- a/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-combine_latest.hpp @@ -19,8 +19,8 @@ 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; - typedef typename std::decay<Selector>::type selector_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Selector> selector_type; + typedef rxu::decay_t<Coordination> coordination_type; struct tag_not_valid {}; template<class CS, class... CVN> @@ -34,7 +34,7 @@ struct combine_latest_traits { }; template<class Coordination, class Selector, class... ObservableN> -struct combine_latest : public operator_base<typename combine_latest_traits<Coordination, Selector, ObservableN...>::value_type> +struct combine_latest : public operator_base<rxu::value_type_t<combine_latest_traits<Coordination, Selector, ObservableN...>>> { typedef combine_latest<Coordination, Selector, ObservableN...> this_type; @@ -179,8 +179,8 @@ struct combine_latest : public operator_base<typename combine_latest_traits<Coor template<class Coordination, class Selector, class... ObservableN> class combine_latest_factory { - typedef typename std::decay<Coordination>::type coordination_type; - typedef typename std::decay<Selector>::type selector_type; + typedef rxu::decay_t<Coordination> coordination_type; + typedef rxu::decay_t<Selector> selector_type; typedef std::tuple<ObservableN...> tuple_source_type; coordination_type coordination; @@ -189,9 +189,9 @@ class combine_latest_factory template<class... YObservableN> auto make(std::tuple<YObservableN...> source) - -> observable<typename combine_latest<Coordination, Selector, YObservableN...>::value_type, combine_latest<Coordination, Selector, YObservableN...>> { - return observable<typename combine_latest<Coordination, Selector, YObservableN...>::value_type, combine_latest<Coordination, Selector, YObservableN...>>( - combine_latest<Coordination, Selector, YObservableN...>(coordination, selector, std::move(source))); + -> observable<rxu::value_type_t<combine_latest<Coordination, Selector, YObservableN...>>, combine_latest<Coordination, Selector, YObservableN...>> { + return observable<rxu::value_type_t<combine_latest<Coordination, Selector, YObservableN...>>, combine_latest<Coordination, Selector, YObservableN...>>( + combine_latest<Coordination, Selector, YObservableN...>(coordination, selector, std::move(source))); } public: combine_latest_factory(coordination_type sf, selector_type s, ObservableN... on) diff --git a/Rx/v2/src/rxcpp/operators/rx-concat.hpp b/Rx/v2/src/rxcpp/operators/rx-concat.hpp index 2afe974..01f023d 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat.hpp @@ -15,13 +15,13 @@ namespace detail { template<class T, class Observable, class Coordination> struct concat - : public operator_base<typename std::decay<T>::type::value_type> + : public operator_base<rxu::value_type_t<rxu::decay_t<T>>> { typedef concat<T, Observable, Coordination> this_type; - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; @@ -184,7 +184,7 @@ struct concat template<class Coordination> class concat_factory { - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Coordination> coordination_type; coordination_type coordination; public: @@ -195,9 +195,9 @@ public: template<class Observable> auto operator()(Observable source) - -> observable<typename concat<typename Observable::value_type, Observable, Coordination>::value_type, concat<typename Observable::value_type, Observable, Coordination>> { - return observable<typename concat<typename Observable::value_type, Observable, Coordination>::value_type, concat<typename Observable::value_type, Observable, Coordination>>( - concat<typename Observable::value_type, Observable, Coordination>(std::move(source), coordination)); + -> observable<rxu::value_type_t<concat<rxu::value_type_t<Observable>, Observable, Coordination>>, concat<rxu::value_type_t<Observable>, Observable, Coordination>> { + return observable<rxu::value_type_t<concat<rxu::value_type_t<Observable>, Observable, Coordination>>, concat<rxu::value_type_t<Observable>, Observable, Coordination>>( + concat<rxu::value_type_t<Observable>, Observable, Coordination>(std::move(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp index e5ea951..72280e8 100644 --- a/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-concat_map.hpp @@ -15,10 +15,10 @@ namespace detail { template<class Observable, class CollectionSelector, class ResultSelector, class Coordination> struct concat_traits { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<CollectionSelector>::type collection_selector_type; - typedef typename std::decay<ResultSelector>::type result_selector_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<CollectionSelector> collection_selector_type; + typedef rxu::decay_t<ResultSelector> result_selector_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename source_type::value_type source_value_type; @@ -50,7 +50,7 @@ struct concat_traits { template<class Observable, class CollectionSelector, class ResultSelector, class Coordination> struct concat_map - : public operator_base<typename concat_traits<Observable, CollectionSelector, ResultSelector, Coordination>::value_type> + : public operator_base<rxu::value_type_t<concat_traits<Observable, CollectionSelector, ResultSelector, Coordination>>> { typedef concat_map<Observable, CollectionSelector, ResultSelector, Coordination> this_type; typedef concat_traits<Observable, CollectionSelector, ResultSelector, Coordination> traits; @@ -241,9 +241,9 @@ private: template<class CollectionSelector, class ResultSelector, class Coordination> class concat_map_factory { - typedef typename std::decay<CollectionSelector>::type collection_selector_type; - typedef typename std::decay<ResultSelector>::type result_selector_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<CollectionSelector> collection_selector_type; + typedef rxu::decay_t<ResultSelector> result_selector_type; + typedef rxu::decay_t<Coordination> coordination_type; collection_selector_type selectorCollection; result_selector_type selectorResult; @@ -258,9 +258,9 @@ public: template<class Observable> auto operator()(Observable&& source) - -> observable<typename concat_map<Observable, CollectionSelector, ResultSelector, Coordination>::value_type, concat_map<Observable, CollectionSelector, ResultSelector, Coordination>> { - return observable<typename concat_map<Observable, CollectionSelector, ResultSelector, Coordination>::value_type, concat_map<Observable, CollectionSelector, ResultSelector, Coordination>>( - concat_map<Observable, CollectionSelector, ResultSelector, Coordination>(std::forward<Observable>(source), selectorCollection, selectorResult, coordination)); + -> observable<rxu::value_type_t<concat_map<Observable, CollectionSelector, ResultSelector, Coordination>>, concat_map<Observable, CollectionSelector, ResultSelector, Coordination>> { + return observable<rxu::value_type_t<concat_map<Observable, CollectionSelector, ResultSelector, Coordination>>, concat_map<Observable, CollectionSelector, ResultSelector, Coordination>>( + concat_map<Observable, CollectionSelector, ResultSelector, Coordination>(std::forward<Observable>(source), selectorCollection, selectorResult, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp b/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp index b38aa08..7713c2c 100644 --- a/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-connect_forever.hpp @@ -16,7 +16,7 @@ namespace detail { template<class T, class ConnectableObservable> struct connect_forever : public operator_base<T> { - typedef typename std::decay<ConnectableObservable>::type source_type; + typedef rxu::decay_t<ConnectableObservable> source_type; source_type source; @@ -38,9 +38,9 @@ public: connect_forever_factory() {} template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type, connect_forever<typename std::decay<Observable>::type::value_type, Observable>> { - return observable<typename std::decay<Observable>::type::value_type, connect_forever<typename std::decay<Observable>::type::value_type, Observable>>( - connect_forever<typename std::decay<Observable>::type::value_type, Observable>(std::forward<Observable>(source))); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>, connect_forever<rxu::value_type_t<rxu::decay_t<Observable>>, Observable>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>, connect_forever<rxu::value_type_t<rxu::decay_t<Observable>>, Observable>>( + connect_forever<rxu::value_type_t<rxu::decay_t<Observable>>, Observable>(std::forward<Observable>(source))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp index 910edda..d43c03f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-distinct_until_changed.hpp @@ -16,14 +16,14 @@ namespace detail { template<class T> struct distinct_until_changed { - typedef typename std::decay<T>::type source_value_type; + typedef rxu::decay_t<T> source_value_type; template<class Subscriber> struct distinct_until_changed_observer { typedef distinct_until_changed_observer<Subscriber> this_type; typedef source_value_type value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<value_type, this_type> observer_type; dest_type dest; mutable rxu::detail::maybe<source_value_type> remembered; @@ -62,8 +62,8 @@ class distinct_until_changed_factory public: template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<typename std::decay<Observable>::type::value_type>(distinct_until_changed<typename std::decay<Observable>::type>::value_type)) { - return source.template lift<typename std::decay<Observable>::type::value_type>(distinct_until_changed<typename std::decay<Observable>::type>::value_type); + -> decltype(source.template lift<rxu::value_type_t<rxu::decay_t<Observable>>>(distinct_until_changed<rxu::decay_t<Observable>>::value_type)) { + return source.template lift<rxu::value_type_t<rxu::decay_t<Observable>>>(distinct_until_changed<rxu::decay_t<Observable>>::value_type); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-filter.hpp b/Rx/v2/src/rxcpp/operators/rx-filter.hpp index 775bc16..f5aba00 100644 --- a/Rx/v2/src/rxcpp/operators/rx-filter.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-filter.hpp @@ -16,8 +16,8 @@ namespace detail { template<class T, class Predicate> struct filter { - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<Predicate>::type test_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<Predicate> test_type; test_type test; filter(test_type t) @@ -30,7 +30,7 @@ struct filter { typedef filter_observer<Subscriber> this_type; typedef source_value_type value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<value_type, this_type> observer_type; dest_type dest; test_type test; @@ -73,14 +73,14 @@ struct filter template<class Predicate> class filter_factory { - typedef typename std::decay<Predicate>::type test_type; + typedef rxu::decay_t<Predicate> test_type; test_type predicate; public: filter_factory(test_type p) : predicate(std::move(p)) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<typename std::decay<Observable>::type::value_type>(filter<typename std::decay<Observable>::type::value_type, test_type>(predicate))) { - return source.template lift<typename std::decay<Observable>::type::value_type>(filter<typename std::decay<Observable>::type::value_type, test_type>(predicate)); + -> decltype(source.template lift<rxu::value_type_t<rxu::decay_t<Observable>>>(filter<rxu::value_type_t<rxu::decay_t<Observable>>, test_type>(predicate))) { + return source.template lift<rxu::value_type_t<rxu::decay_t<Observable>>>(filter<rxu::value_type_t<rxu::decay_t<Observable>>, test_type>(predicate)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-finally.hpp b/Rx/v2/src/rxcpp/operators/rx-finally.hpp index 6e2b7ad..cd45d75 100644 --- a/Rx/v2/src/rxcpp/operators/rx-finally.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-finally.hpp @@ -16,8 +16,8 @@ namespace detail { template<class T, class LastCall> struct finally { - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<LastCall>::type last_call_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<LastCall> last_call_type; last_call_type last_call; finally(last_call_type lc) @@ -30,7 +30,7 @@ struct finally { typedef finally_observer<Subscriber> this_type; typedef source_value_type value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<value_type, this_type> observer_type; dest_type dest; @@ -70,14 +70,14 @@ struct finally template<class LastCall> class finally_factory { - typedef typename std::decay<LastCall>::type last_call_type; + typedef rxu::decay_t<LastCall> last_call_type; last_call_type last_call; public: finally_factory(last_call_type lc) : last_call(std::move(lc)) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<typename std::decay<Observable>::type::value_type>(filter<typename std::decay<Observable>::type::value_type, last_call_type>(last_call))) { - return source.template lift<typename std::decay<Observable>::type::value_type>(filter<typename std::decay<Observable>::type::value_type, last_call_type>(last_call)); + -> decltype(source.template lift<rxu::value_type_t<rxu::decay_t<Observable>>>(filter<rxu::value_type_t<rxu::decay_t<Observable>>, last_call_type>(last_call))) { + return source.template lift<rxu::value_type_t<rxu::decay_t<Observable>>>(filter<rxu::value_type_t<rxu::decay_t<Observable>>, last_call_type>(last_call)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp index f50ed43..afe6ae7 100644 --- a/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-flat_map.hpp @@ -15,10 +15,10 @@ namespace detail { template<class Observable, class CollectionSelector, class ResultSelector, class Coordination> struct flat_map_traits { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<CollectionSelector>::type collection_selector_type; - typedef typename std::decay<ResultSelector>::type result_selector_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<CollectionSelector> collection_selector_type; + typedef rxu::decay_t<ResultSelector> result_selector_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename source_type::value_type source_value_type; @@ -48,7 +48,7 @@ struct flat_map_traits { template<class Observable, class CollectionSelector, class ResultSelector, class Coordination> struct flat_map - : public operator_base<typename flat_map_traits<Observable, CollectionSelector, ResultSelector, Coordination>::value_type> + : public operator_base<rxu::value_type_t<flat_map_traits<Observable, CollectionSelector, ResultSelector, Coordination>>> { typedef flat_map<Observable, CollectionSelector, ResultSelector, Coordination> this_type; typedef flat_map_traits<Observable, CollectionSelector, ResultSelector, Coordination> traits; @@ -224,9 +224,9 @@ struct flat_map template<class CollectionSelector, class ResultSelector, class Coordination> class flat_map_factory { - typedef typename std::decay<CollectionSelector>::type collection_selector_type; - typedef typename std::decay<ResultSelector>::type result_selector_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<CollectionSelector> collection_selector_type; + typedef rxu::decay_t<ResultSelector> result_selector_type; + typedef rxu::decay_t<Coordination> coordination_type; collection_selector_type selectorCollection; result_selector_type selectorResult; @@ -241,9 +241,9 @@ public: template<class Observable> auto operator()(Observable&& source) - -> observable<typename flat_map<Observable, CollectionSelector, ResultSelector, Coordination>::value_type, flat_map<Observable, CollectionSelector, ResultSelector, Coordination>> { - return observable<typename flat_map<Observable, CollectionSelector, ResultSelector, Coordination>::value_type, flat_map<Observable, CollectionSelector, ResultSelector, Coordination>>( - flat_map<Observable, CollectionSelector, ResultSelector, Coordination>(std::forward<Observable>(source), selectorCollection, selectorResult, coordination)); + -> observable<rxu::value_type_t<flat_map<Observable, CollectionSelector, ResultSelector, Coordination>>, flat_map<Observable, CollectionSelector, ResultSelector, Coordination>> { + return observable<rxu::value_type_t<flat_map<Observable, CollectionSelector, ResultSelector, Coordination>>, flat_map<Observable, CollectionSelector, ResultSelector, Coordination>>( + flat_map<Observable, CollectionSelector, ResultSelector, Coordination>(std::forward<Observable>(source), selectorCollection, selectorResult, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp index 5ef609b..8afb4b9 100644 --- a/Rx/v2/src/rxcpp/operators/rx-group_by.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-group_by.hpp @@ -16,7 +16,7 @@ namespace detail { template<class T, class Selector> struct is_group_by_selector_for { - typedef typename std::decay<Selector>::type selector_type; + typedef rxu::decay_t<Selector> selector_type; typedef T source_value_type; struct tag_not_valid {}; @@ -33,10 +33,10 @@ template<class T, class Observable, class KeySelector, class MarbleSelector, cla struct group_by_traits { typedef T source_value_type; - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<KeySelector>::type key_selector_type; - typedef typename std::decay<MarbleSelector>::type marble_selector_type; - typedef typename std::decay<BinaryPredicate>::type predicate_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<KeySelector> key_selector_type; + typedef rxu::decay_t<MarbleSelector> marble_selector_type; + typedef rxu::decay_t<BinaryPredicate> predicate_type; static_assert(is_group_by_selector_for<source_value_type, key_selector_type>::value, "group_by KeySelector must be a function with the signature key_type(source_value_type)"); @@ -110,7 +110,7 @@ struct group_by { typedef group_by_observer<Subscriber> this_type; typedef typename traits_type::grouped_observable_type value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<T, this_type> observer_type; dest_type dest; @@ -174,9 +174,9 @@ struct group_by template<class KeySelector, class MarbleSelector, class BinaryPredicate> class group_by_factory { - typedef typename std::decay<KeySelector>::type key_selector_type; - typedef typename std::decay<MarbleSelector>::type marble_selector_type; - typedef typename std::decay<BinaryPredicate>::type predicate_type; + typedef rxu::decay_t<KeySelector> key_selector_type; + typedef rxu::decay_t<MarbleSelector> marble_selector_type; + typedef rxu::decay_t<BinaryPredicate> predicate_type; key_selector_type keySelector; marble_selector_type marbleSelector; predicate_type predicate; @@ -190,7 +190,7 @@ public: template<class Observable> struct group_by_factory_traits { - typedef typename Observable::value_type value_type; + typedef rxu::value_type_t<Observable> value_type; typedef detail::group_by_traits<value_type, Observable, KeySelector, MarbleSelector, BinaryPredicate> traits_type; typedef detail::group_by<value_type, Observable, KeySelector, MarbleSelector, BinaryPredicate> group_by_type; }; diff --git a/Rx/v2/src/rxcpp/operators/rx-lift.hpp b/Rx/v2/src/rxcpp/operators/rx-lift.hpp index 58fa4d6..4e95cb2 100644 --- a/Rx/v2/src/rxcpp/operators/rx-lift.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-lift.hpp @@ -20,8 +20,8 @@ struct is_lift_function_for { template<class CS, class CF> static tag_not_valid check(...); - typedef typename std::decay<S>::type for_type; - typedef typename std::decay<F>::type func_type; + typedef rxu::decay_t<S> for_type; + typedef rxu::decay_t<F> func_type; typedef decltype(check<for_type, func_type>(0)) detail_result; static const bool value = is_subscriber<detail_result>::value && is_subscriber<for_type>::value && std::is_convertible<V, typename rxu::value_type_from<detail_result>::type>::value; }; @@ -35,9 +35,9 @@ namespace detail { template<class ResultType, class SourceOperator, class Operator> struct lift_traits { - typedef typename std::decay<ResultType>::type result_value_type; - typedef typename std::decay<SourceOperator>::type source_operator_type; - typedef typename std::decay<Operator>::type operator_type; + typedef rxu::decay_t<ResultType> result_value_type; + typedef rxu::decay_t<SourceOperator> source_operator_type; + typedef rxu::decay_t<Operator> operator_type; typedef typename source_operator_type::value_type source_value_type; @@ -70,7 +70,7 @@ struct lift_operator : public operator_base<typename lift_traits<ResultType, Sou template<class ResultType, class Operator> class lift_factory { - typedef typename std::decay<Operator>::type operator_type; + typedef rxu::decay_t<Operator> operator_type; operator_type chain; public: lift_factory(operator_type op) : chain(std::move(op)) {} @@ -78,7 +78,7 @@ public: auto operator()(const Observable& source) -> decltype(source.template lift<ResultType>(chain)) { return source.template lift<ResultType>(chain); - static_assert(rxcpp::detail::is_lift_function_for<typename Observable::value_type, subscriber<ResultType>, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber<T, ...>)"); + static_assert(rxcpp::detail::is_lift_function_for<rxu::value_type_t<Observable>, subscriber<ResultType>, Operator>::value, "Function passed for lift() must have the signature subscriber<...>(subscriber<T, ...>)"); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-map.hpp b/Rx/v2/src/rxcpp/operators/rx-map.hpp index 662cf95..855f8eb 100644 --- a/Rx/v2/src/rxcpp/operators/rx-map.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-map.hpp @@ -17,8 +17,8 @@ namespace detail { template<class T, class Selector> struct map { - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<Selector>::type select_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<Selector> select_type; typedef decltype((*(select_type*)nullptr)(*(source_value_type*)nullptr)) value_type; select_type selector; @@ -32,7 +32,7 @@ struct map { typedef map_observer<Subscriber> this_type; typedef decltype((*(select_type*)nullptr)(*(source_value_type*)nullptr)) value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<T, this_type> observer_type; dest_type dest; select_type selector; @@ -75,14 +75,14 @@ struct map template<class Selector> class map_factory { - typedef typename std::decay<Selector>::type select_type; + typedef rxu::decay_t<Selector> select_type; select_type selector; public: map_factory(select_type s) : selector(std::move(s)) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<typename map<typename std::decay<Observable>::type::value_type, select_type>::value_type>(map<typename std::decay<Observable>::type::value_type, select_type>(selector))) { - return source.template lift<typename map<typename std::decay<Observable>::type::value_type, select_type>::value_type>(map<typename std::decay<Observable>::type::value_type, select_type>(selector)); + -> decltype(source.template lift<rxu::value_type_t<map<rxu::value_type_t<rxu::decay_t<Observable>>, select_type>>>(map<rxu::value_type_t<rxu::decay_t<Observable>>, select_type>(selector))) { + return source.template lift<rxu::value_type_t<map<rxu::value_type_t<rxu::decay_t<Observable>>, select_type>>>(map<rxu::value_type_t<rxu::decay_t<Observable>>, select_type>(selector)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-merge.hpp b/Rx/v2/src/rxcpp/operators/rx-merge.hpp index 9faa862..04d5a41 100644 --- a/Rx/v2/src/rxcpp/operators/rx-merge.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-merge.hpp @@ -15,20 +15,20 @@ namespace detail { template<class T, class Observable, class Coordination> struct merge - : public operator_base<typename std::decay<T>::type::value_type> + : public operator_base<rxu::value_type_t<rxu::decay_t<T>>> { //static_assert(is_observable<Observable>::value, "merge requires an observable"); //static_assert(is_observable<T>::value, "merge requires an observable that contains observables"); typedef merge<T, Observable, Coordination> this_type; - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<Observable>::type source_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<Observable> source_type; typedef typename source_type::source_operator_type source_operator_type; typedef typename source_value_type::value_type value_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct values @@ -172,7 +172,7 @@ struct merge template<class Coordination> class merge_factory { - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Coordination> coordination_type; coordination_type coordination; public: @@ -183,9 +183,9 @@ public: template<class Observable> auto operator()(Observable source) - -> observable<typename merge<typename Observable::value_type, Observable, Coordination>::value_type, merge<typename Observable::value_type, Observable, Coordination>> { - return observable<typename merge<typename Observable::value_type, Observable, Coordination>::value_type, merge<typename Observable::value_type, Observable, Coordination>>( - merge<typename Observable::value_type, Observable, Coordination>(std::move(source), coordination)); + -> observable<rxu::value_type_t<merge<rxu::value_type_t<Observable>, Observable, Coordination>>, merge<rxu::value_type_t<Observable>, Observable, Coordination>> { + return observable<rxu::value_type_t<merge<rxu::value_type_t<Observable>, Observable, Coordination>>, merge<rxu::value_type_t<Observable>, Observable, Coordination>>( + merge<rxu::value_type_t<Observable>, Observable, Coordination>(std::move(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-multicast.hpp b/Rx/v2/src/rxcpp/operators/rx-multicast.hpp index 966bfa3..e970bfe 100644 --- a/Rx/v2/src/rxcpp/operators/rx-multicast.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-multicast.hpp @@ -16,8 +16,8 @@ namespace detail { template<class T, class Observable, class Subject> struct multicast : public operator_base<T> { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<Subject>::type subject_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<Subject> subject_type; struct multicast_state : public std::enable_shared_from_this<multicast_state> { @@ -76,9 +76,9 @@ public: } template<class Observable> auto operator()(Observable&& source) - -> connectable_observable<typename std::decay<Observable>::type::value_type, multicast<typename std::decay<Observable>::type::value_type, Observable, Subject>> { - return connectable_observable<typename std::decay<Observable>::type::value_type, multicast<typename std::decay<Observable>::type::value_type, Observable, Subject>>( - multicast<typename std::decay<Observable>::type::value_type, Observable, Subject>(std::forward<Observable>(source), caster)); + -> connectable_observable<rxu::value_type_t<rxu::decay_t<Observable>>, multicast<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Subject>> { + return connectable_observable<rxu::value_type_t<rxu::decay_t<Observable>>, multicast<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Subject>>( + multicast<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Subject>(std::forward<Observable>(source), caster)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp index 4d89044..8f52473 100644 --- a/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-observe_on.hpp @@ -16,9 +16,9 @@ namespace detail { template<class T, class Coordination> struct observe_on { - typedef typename std::decay<T>::type source_value_type; + typedef rxu::decay_t<T> source_value_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; coordination_type coordination; @@ -34,7 +34,7 @@ struct observe_on typedef observe_on_observer<Subscriber> this_type; typedef observer_base<source_value_type> base_type; typedef source_value_type value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<value_type, this_type> observer_type; typedef rxn::notification<T> notification_type; @@ -184,14 +184,14 @@ struct observe_on template<class Coordination> class observe_on_factory { - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Coordination> coordination_type; coordination_type coordination; public: observe_on_factory(coordination_type cn) : coordination(std::move(cn)) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<typename std::decay<Observable>::type::value_type>(observe_on<typename std::decay<Observable>::type::value_type, coordination_type>(coordination))) { - return source.template lift<typename std::decay<Observable>::type::value_type>(observe_on<typename std::decay<Observable>::type::value_type, coordination_type>(coordination)); + -> decltype(source.template lift<rxu::value_type_t<rxu::decay_t<Observable>>>(observe_on<rxu::value_type_t<rxu::decay_t<Observable>>, coordination_type>(coordination))) { + return source.template lift<rxu::value_type_t<rxu::decay_t<Observable>>>(observe_on<rxu::value_type_t<rxu::decay_t<Observable>>, coordination_type>(coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp b/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp index 582aba5..8531e8c 100644 --- a/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-pairwise.hpp @@ -16,7 +16,7 @@ namespace detail { template<class T> struct pairwise { - typedef typename std::decay<T>::type source_value_type; + typedef rxu::decay_t<T> source_value_type; typedef std::tuple<source_value_type, source_value_type> value_type; template<class Subscriber> @@ -24,7 +24,7 @@ struct pairwise { typedef pairwise_observer<Subscriber> this_type; typedef std::tuple<source_value_type, source_value_type> value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<T, this_type> observer_type; dest_type dest; mutable rxu::detail::maybe<source_value_type> remembered; @@ -67,8 +67,8 @@ class pairwise_factory public: template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<typename pairwise<typename std::decay<Observable>::type::value_type>::value_type>(pairwise<typename std::decay<Observable>::type::value_type>())) { - return source.template lift<typename pairwise<typename std::decay<Observable>::type::value_type>::value_type>(pairwise<typename std::decay<Observable>::type::value_type>()); + -> decltype(source.template lift<rxu::value_type_t<pairwise<rxu::value_type_t<rxu::decay_t<Observable>>>>>(pairwise<rxu::value_type_t<rxu::decay_t<Observable>>>())) { + return source.template lift<rxu::value_type_t<pairwise<rxu::value_type_t<rxu::decay_t<Observable>>>>>(pairwise<rxu::value_type_t<rxu::decay_t<Observable>>>()); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-publish.hpp b/Rx/v2/src/rxcpp/operators/rx-publish.hpp index 34de51a..3589cc9 100644 --- a/Rx/v2/src/rxcpp/operators/rx-publish.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-publish.hpp @@ -20,10 +20,10 @@ public: publish_factory() {} template<class Observable> auto operator()(Observable&& source) - -> connectable_observable<typename std::decay<Observable>::type::value_type, multicast<typename std::decay<Observable>::type::value_type, Observable, Subject<typename std::decay<Observable>::type::value_type>>> { - return connectable_observable<typename std::decay<Observable>::type::value_type, multicast<typename std::decay<Observable>::type::value_type, Observable, Subject<typename std::decay<Observable>::type::value_type>>>( - multicast<typename std::decay<Observable>::type::value_type, Observable, Subject<typename std::decay<Observable>::type::value_type>>( - std::forward<Observable>(source), Subject<typename std::decay<Observable>::type::value_type>())); + -> connectable_observable<rxu::value_type_t<rxu::decay_t<Observable>>, multicast<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Subject<rxu::value_type_t<rxu::decay_t<Observable>>>>> { + return connectable_observable<rxu::value_type_t<rxu::decay_t<Observable>>, multicast<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Subject<rxu::value_type_t<rxu::decay_t<Observable>>>>>( + multicast<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Subject<rxu::value_type_t<rxu::decay_t<Observable>>>>( + std::forward<Observable>(source), Subject<rxu::value_type_t<rxu::decay_t<Observable>>>())); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp index 9d3d39b..1c740bc 100644 --- a/Rx/v2/src/rxcpp/operators/rx-reduce.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-reduce.hpp @@ -16,8 +16,8 @@ namespace detail { template<class T, class Seed, class Accumulator> struct is_accumulate_function_for { - typedef typename std::decay<Accumulator>::type accumulator_type; - typedef typename std::decay<Seed>::type seed_type; + typedef rxu::decay_t<Accumulator> accumulator_type; + typedef rxu::decay_t<Seed> seed_type; typedef T source_value_type; struct tag_not_valid {}; @@ -33,8 +33,8 @@ struct is_accumulate_function_for { template<class Seed, class ResultSelector> struct is_result_function_for { - typedef typename std::decay<ResultSelector>::type result_selector_type; - typedef typename std::decay<Seed>::type seed_type; + typedef rxu::decay_t<ResultSelector> result_selector_type; + typedef rxu::decay_t<Seed> seed_type; struct tag_not_valid {}; @@ -50,10 +50,10 @@ struct is_result_function_for { template<class T, class SourceOperator, class Accumulator, class ResultSelector, class Seed> struct reduce_traits { - typedef typename std::decay<SourceOperator>::type source_type; - typedef typename std::decay<Accumulator>::type accumulator_type; - typedef typename std::decay<ResultSelector>::type result_selector_type; - typedef typename std::decay<Seed>::type seed_type; + typedef rxu::decay_t<SourceOperator> source_type; + typedef rxu::decay_t<Accumulator> accumulator_type; + typedef rxu::decay_t<ResultSelector> result_selector_type; + typedef rxu::decay_t<Seed> seed_type; typedef T source_value_type; @@ -65,7 +65,7 @@ struct reduce_traits }; template<class T, class SourceOperator, class Accumulator, class ResultSelector, class Seed> -struct reduce : public operator_base<typename reduce_traits<T, SourceOperator, Accumulator, ResultSelector, Seed>::value_type> +struct reduce : public operator_base<rxu::value_type_t<reduce_traits<T, SourceOperator, Accumulator, ResultSelector, Seed>>> { typedef reduce<T, SourceOperator, Accumulator, ResultSelector, Seed> this_type; typedef reduce_traits<T, SourceOperator, Accumulator, ResultSelector, Seed> traits; @@ -164,9 +164,9 @@ private: template<class Accumulator, class ResultSelector, class Seed> class reduce_factory { - typedef typename std::decay<Accumulator>::type accumulator_type; - typedef typename std::decay<ResultSelector>::type result_selector_type; - typedef typename std::decay<Seed>::type seed_type; + typedef rxu::decay_t<Accumulator> accumulator_type; + typedef rxu::decay_t<ResultSelector> result_selector_type; + typedef rxu::decay_t<Seed> seed_type; accumulator_type accumulator; result_selector_type result_selector; @@ -180,9 +180,9 @@ public: } template<class Observable> auto operator()(const Observable& source) - -> observable<seed_type, reduce<typename Observable::value_type, typename Observable::source_operator_type, Accumulator, ResultSelector, Seed>> { - return observable<seed_type, reduce<typename Observable::value_type, typename Observable::source_operator_type, Accumulator, ResultSelector, Seed>>( - reduce<typename Observable::value_type, typename Observable::source_operator_type, Accumulator, ResultSelector, Seed>(source.source_operator, accumulator, result_selector, seed)); + -> observable<seed_type, reduce<rxu::value_type_t<Observable>, typename Observable::source_operator_type, Accumulator, ResultSelector, Seed>> { + return observable<seed_type, reduce<rxu::value_type_t<Observable>, typename Observable::source_operator_type, Accumulator, ResultSelector, Seed>>( + reduce<rxu::value_type_t<Observable>, typename Observable::source_operator_type, Accumulator, ResultSelector, Seed>(source.source_operator, accumulator, result_selector, seed)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp index 41e4bd9..2d41ef2 100644 --- a/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-ref_count.hpp @@ -16,7 +16,7 @@ namespace detail { template<class T, class ConnectableObservable> struct ref_count : public operator_base<T> { - typedef typename std::decay<ConnectableObservable>::type source_type; + typedef rxu::decay_t<ConnectableObservable> source_type; struct ref_count_state : public std::enable_shared_from_this<ref_count_state> { @@ -65,9 +65,9 @@ public: ref_count_factory() {} template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type, ref_count<typename std::decay<Observable>::type::value_type, Observable>> { - return observable<typename std::decay<Observable>::type::value_type, ref_count<typename std::decay<Observable>::type::value_type, Observable>>( - ref_count<typename std::decay<Observable>::type::value_type, Observable>(std::forward<Observable>(source))); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>, ref_count<rxu::value_type_t<rxu::decay_t<Observable>>, Observable>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>, ref_count<rxu::value_type_t<rxu::decay_t<Observable>>, Observable>>( + ref_count<rxu::value_type_t<rxu::decay_t<Observable>>, Observable>(std::forward<Observable>(source))); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-repeat.hpp b/Rx/v2/src/rxcpp/operators/rx-repeat.hpp index 91f59b8..b9038ac 100644 --- a/Rx/v2/src/rxcpp/operators/rx-repeat.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-repeat.hpp @@ -16,8 +16,8 @@ namespace detail { template<class T, class Observable, class Count> struct repeat : public operator_base<T> { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<Count>::type count_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<Count> count_type; struct values { values(source_type s, count_type t) @@ -94,16 +94,16 @@ struct repeat : public operator_base<T> template<class T> class repeat_factory { - typedef typename std::decay<T>::type count_type; + typedef rxu::decay_t<T> count_type; count_type count; public: repeat_factory(count_type t) : count(std::move(t)) {} template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type, repeat<typename std::decay<Observable>::type::value_type, Observable, count_type>> { - return observable<typename std::decay<Observable>::type::value_type, repeat<typename std::decay<Observable>::type::value_type, Observable, count_type>>( - repeat<typename std::decay<Observable>::type::value_type, Observable, count_type>(std::forward<Observable>(source), count)); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>, repeat<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>, repeat<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>>( + repeat<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>(std::forward<Observable>(source), count)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-retry.hpp b/Rx/v2/src/rxcpp/operators/rx-retry.hpp index 112edef..acfa20b 100644 --- a/Rx/v2/src/rxcpp/operators/rx-retry.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-retry.hpp @@ -15,8 +15,8 @@ namespace rxcpp { template<class T, class Observable, class Count> struct retry : public operator_base<T> { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<Count>::type count_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<Count> count_type; struct values { values(source_type s, count_type t) : source(std::move(s)) @@ -90,16 +90,16 @@ namespace rxcpp { template<class T> class retry_factory { - typedef typename std::decay<T>::type count_type; + typedef rxu::decay_t<T> count_type; count_type count; public: retry_factory(count_type t) : count(std::move(t)) {} template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type, retry<typename std::decay<Observable>::type::value_type, Observable, count_type>> { - return observable<typename std::decay<Observable>::type::value_type, retry<typename std::decay<Observable>::type::value_type, Observable, count_type>>( - retry<typename std::decay<Observable>::type::value_type, Observable, count_type>(std::forward<Observable>(source), count)); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>, retry<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>, retry<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>>( + retry<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>(std::forward<Observable>(source), count)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-scan.hpp b/Rx/v2/src/rxcpp/operators/rx-scan.hpp index 1b45437..7f2a314 100644 --- a/Rx/v2/src/rxcpp/operators/rx-scan.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-scan.hpp @@ -14,11 +14,11 @@ namespace operators { namespace detail { template<class T, class Observable, class Accumulator, class Seed> -struct scan : public operator_base<typename std::decay<Seed>::type> +struct scan : public operator_base<rxu::decay_t<Seed>> { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<Accumulator>::type accumulator_type; - typedef typename std::decay<Seed>::type seed_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<Accumulator> accumulator_type; + typedef rxu::decay_t<Seed> seed_type; struct scan_initial_type { @@ -88,8 +88,8 @@ struct scan : public operator_base<typename std::decay<Seed>::type> template<class Accumulator, class Seed> class scan_factory { - typedef typename std::decay<Accumulator>::type accumulator_type; - typedef typename std::decay<Seed>::type seed_type; + typedef rxu::decay_t<Accumulator> accumulator_type; + typedef rxu::decay_t<Seed> seed_type; accumulator_type accumulator; seed_type seed; @@ -101,9 +101,9 @@ public: } template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Seed>::type, scan<typename std::decay<Observable>::type::value_type, Observable, Accumulator, Seed>> { - return observable<typename std::decay<Seed>::type, scan<typename std::decay<Observable>::type::value_type, Observable, Accumulator, Seed>>( - scan<typename std::decay<Observable>::type::value_type, Observable, Accumulator, Seed>(std::forward<Observable>(source), accumulator, seed)); + -> observable<rxu::decay_t<Seed>, scan<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Accumulator, Seed>> { + return observable<rxu::decay_t<Seed>, scan<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Accumulator, Seed>>( + scan<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Accumulator, Seed>(std::forward<Observable>(source), accumulator, seed)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-skip.hpp b/Rx/v2/src/rxcpp/operators/rx-skip.hpp index 3fa7209..94ebe5a 100644 --- a/Rx/v2/src/rxcpp/operators/rx-skip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-skip.hpp @@ -16,8 +16,8 @@ namespace detail { template<class T, class Observable, class Count> struct skip : public operator_base<T> { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<Count>::type count_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<Count> count_type; struct values { values(source_type s, count_type t) @@ -99,15 +99,15 @@ struct skip : public operator_base<T> template<class T> class skip_factory { - typedef typename std::decay<T>::type count_type; + typedef rxu::decay_t<T> count_type; count_type count; public: skip_factory(count_type t) : count(std::move(t)) {} template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type, skip<typename std::decay<Observable>::type::value_type, Observable, count_type>> { - return observable<typename std::decay<Observable>::type::value_type, skip<typename std::decay<Observable>::type::value_type, Observable, count_type>>( - skip<typename std::decay<Observable>::type::value_type, Observable, count_type>(std::forward<Observable>(source), count)); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>, skip<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>, skip<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>>( + skip<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>(std::forward<Observable>(source), count)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp b/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp index 49441e4..4b4644f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-skip_until.hpp @@ -16,9 +16,9 @@ namespace detail { template<class T, class Observable, class TriggerObservable, class Coordination> struct skip_until : public operator_base<T> { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<TriggerObservable>::type trigger_source_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<TriggerObservable> trigger_source_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct values { @@ -164,8 +164,8 @@ struct skip_until : public operator_base<T> template<class TriggerObservable, class Coordination> class skip_until_factory { - typedef typename std::decay<TriggerObservable>::type trigger_source_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<TriggerObservable> trigger_source_type; + typedef rxu::decay_t<Coordination> coordination_type; trigger_source_type trigger_source; coordination_type coordination; @@ -177,9 +177,9 @@ public: } template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type, skip_until<typename std::decay<Observable>::type::value_type, Observable, trigger_source_type, Coordination>> { - return observable<typename std::decay<Observable>::type::value_type, skip_until<typename std::decay<Observable>::type::value_type, Observable, trigger_source_type, Coordination>>( - skip_until<typename std::decay<Observable>::type::value_type, Observable, trigger_source_type, Coordination>(std::forward<Observable>(source), trigger_source, coordination)); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>, skip_until<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, trigger_source_type, Coordination>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>, skip_until<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, trigger_source_type, Coordination>>( + skip_until<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, trigger_source_type, Coordination>(std::forward<Observable>(source), trigger_source, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-start_with.hpp b/Rx/v2/src/rxcpp/operators/rx-start_with.hpp index d605ceb..16e909f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-start_with.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-start_with.hpp @@ -13,8 +13,8 @@ namespace operators { template<class Observable, class Value0, class... ValueN> auto start_with(Observable o, Value0 v0, ValueN... vn) - -> decltype(rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o)) { - return rxs::from(typename Observable::value_type(v0), typename Observable::value_type(vn)...).concat(o); + -> decltype(rxs::from(rxu::value_type_t<Observable>(v0), rxu::value_type_t<Observable>(vn)...).concat(o)) { + return rxs::from(rxu::value_type_t<Observable>(v0), rxu::value_type_t<Observable>(vn)...).concat(o); } } diff --git a/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp index cc25c1d..af74d2e 100644 --- a/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-subscribe.hpp @@ -77,8 +77,8 @@ class dynamic_factory public: template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type> { - return observable<typename std::decay<Observable>::type::value_type>(std::forward<Observable>(source)); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>>(std::forward<Observable>(source)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp index c1adb2c..4142890 100644 --- a/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-subscribe_on.hpp @@ -16,8 +16,8 @@ namespace detail { template<class T, class Observable, class Coordination> struct subscribe_on : public operator_base<T> { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct subscribe_on_values { @@ -110,7 +110,7 @@ private: template<class Coordination> class subscribe_on_factory { - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Coordination> coordination_type; coordination_type coordination; public: @@ -120,9 +120,9 @@ public: } template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type, subscribe_on<typename std::decay<Observable>::type::value_type, Observable, Coordination>> { - return observable<typename std::decay<Observable>::type::value_type, subscribe_on<typename std::decay<Observable>::type::value_type, Observable, Coordination>>( - subscribe_on<typename std::decay<Observable>::type::value_type, Observable, Coordination>(std::forward<Observable>(source), coordination)); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>, subscribe_on<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Coordination>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>, subscribe_on<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Coordination>>( + subscribe_on<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, Coordination>(std::forward<Observable>(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp index 3403553..a3620b2 100644 --- a/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-switch_on_next.hpp @@ -15,22 +15,22 @@ namespace detail { template<class T, class Observable, class Coordination> struct switch_on_next - : public operator_base<typename std::decay<T>::type::value_type> + : public operator_base<rxu::value_type_t<rxu::decay_t<T>>> { //static_assert(is_observable<Observable>::value, "switch_on_next requires an observable"); //static_assert(is_observable<T>::value, "switch_on_next requires an observable that contains observables"); typedef switch_on_next<T, Observable, Coordination> this_type; - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<Observable>::type source_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<Observable> source_type; typedef typename source_type::source_operator_type source_operator_type; typedef source_value_type collection_type; typedef typename collection_type::value_type collection_value_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct values @@ -183,7 +183,7 @@ struct switch_on_next template<class Coordination> class switch_on_next_factory { - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Coordination> coordination_type; coordination_type coordination; public: @@ -194,9 +194,9 @@ public: template<class Observable> auto operator()(Observable source) - -> observable<typename switch_on_next<typename Observable::value_type, Observable, Coordination>::value_type, switch_on_next<typename Observable::value_type, Observable, Coordination>> { - return observable<typename switch_on_next<typename Observable::value_type, Observable, Coordination>::value_type, switch_on_next<typename Observable::value_type, Observable, Coordination>>( - switch_on_next<typename Observable::value_type, Observable, Coordination>(std::move(source), coordination)); + -> observable<rxu::value_type_t<switch_on_next<rxu::value_type_t<Observable>, Observable, Coordination>>, switch_on_next<rxu::value_type_t<Observable>, Observable, Coordination>> { + return observable<rxu::value_type_t<switch_on_next<rxu::value_type_t<Observable>, Observable, Coordination>>, switch_on_next<rxu::value_type_t<Observable>, Observable, Coordination>>( + switch_on_next<rxu::value_type_t<Observable>, Observable, Coordination>(std::move(source), coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-take.hpp b/Rx/v2/src/rxcpp/operators/rx-take.hpp index 5043385..182a20f 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take.hpp @@ -16,8 +16,8 @@ namespace detail { template<class T, class Observable, class Count> struct take : public operator_base<T> { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<Count>::type count_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<Count> count_type; struct values { values(source_type s, count_type t) @@ -103,15 +103,15 @@ struct take : public operator_base<T> template<class T> class take_factory { - typedef typename std::decay<T>::type count_type; + typedef rxu::decay_t<T> count_type; count_type count; public: take_factory(count_type t) : count(std::move(t)) {} template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type, take<typename std::decay<Observable>::type::value_type, Observable, count_type>> { - return observable<typename std::decay<Observable>::type::value_type, take<typename std::decay<Observable>::type::value_type, Observable, count_type>>( - take<typename std::decay<Observable>::type::value_type, Observable, count_type>(std::forward<Observable>(source), count)); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>, take<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>, take<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>>( + take<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, count_type>(std::forward<Observable>(source), count)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp index b1fb8ff..e4109cd 100644 --- a/Rx/v2/src/rxcpp/operators/rx-take_until.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-take_until.hpp @@ -16,9 +16,9 @@ namespace detail { template<class T, class Observable, class TriggerObservable, class Coordination> struct take_until : public operator_base<T> { - typedef typename std::decay<Observable>::type source_type; - typedef typename std::decay<TriggerObservable>::type trigger_source_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Observable> source_type; + typedef rxu::decay_t<TriggerObservable> trigger_source_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; struct values { @@ -162,8 +162,8 @@ struct take_until : public operator_base<T> template<class TriggerObservable, class Coordination> class take_until_factory { - typedef typename std::decay<TriggerObservable>::type trigger_source_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<TriggerObservable> trigger_source_type; + typedef rxu::decay_t<Coordination> coordination_type; trigger_source_type trigger_source; coordination_type coordination; @@ -175,9 +175,9 @@ public: } template<class Observable> auto operator()(Observable&& source) - -> observable<typename std::decay<Observable>::type::value_type, take_until<typename std::decay<Observable>::type::value_type, Observable, trigger_source_type, Coordination>> { - return observable<typename std::decay<Observable>::type::value_type, take_until<typename std::decay<Observable>::type::value_type, Observable, trigger_source_type, Coordination>>( - take_until<typename std::decay<Observable>::type::value_type, Observable, trigger_source_type, Coordination>(std::forward<Observable>(source), trigger_source, coordination)); + -> observable<rxu::value_type_t<rxu::decay_t<Observable>>, take_until<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, trigger_source_type, Coordination>> { + return observable<rxu::value_type_t<rxu::decay_t<Observable>>, take_until<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, trigger_source_type, Coordination>>( + take_until<rxu::value_type_t<rxu::decay_t<Observable>>, Observable, trigger_source_type, Coordination>(std::forward<Observable>(source), trigger_source, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window.hpp b/Rx/v2/src/rxcpp/operators/rx-window.hpp index c2bf220..57d04f0 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window.hpp @@ -16,7 +16,7 @@ namespace detail { template<class T> struct window { - typedef typename std::decay<T>::type source_value_type; + typedef rxu::decay_t<T> source_value_type; struct window_values { window_values(int c, int s) @@ -41,7 +41,7 @@ struct window typedef window_observer<Subscriber> this_type; typedef observer_base<observable<T>> base_type; typedef typename base_type::value_type value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<T, this_type> observer_type; dest_type dest; mutable int cursor; @@ -107,8 +107,8 @@ public: window_factory(int c, int s) : count(c), skip(s) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<observable<typename std::decay<Observable>::type::value_type>>(window<typename std::decay<Observable>::type::value_type>(count, skip))) { - return source.template lift<observable<typename std::decay<Observable>::type::value_type>>(window<typename std::decay<Observable>::type::value_type>(count, skip)); + -> decltype(source.template lift<observable<rxu::value_type_t<rxu::decay_t<Observable>>>>(window<rxu::value_type_t<rxu::decay_t<Observable>>>(count, skip))) { + return source.template lift<observable<rxu::value_type_t<rxu::decay_t<Observable>>>>(window<rxu::value_type_t<rxu::decay_t<Observable>>>(count, skip)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp index aca16de..734520e 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time.hpp @@ -16,10 +16,10 @@ namespace detail { template<class T, class Duration, class Coordination> struct window_with_time { - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - typedef typename std::decay<Duration>::type duration_type; + typedef rxu::decay_t<Duration> duration_type; struct window_with_time_values { @@ -46,7 +46,7 @@ struct window_with_time typedef window_with_time_observer<Subscriber> this_type; typedef observer_base<observable<T>> base_type; typedef typename base_type::value_type value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<T, this_type> observer_type; struct window_with_time_subscriber_values : public window_with_time_values @@ -128,8 +128,8 @@ struct window_with_time template<class Duration, class Coordination> class window_with_time_factory { - typedef typename std::decay<Duration>::type duration_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Duration> duration_type; + typedef rxu::decay_t<Coordination> coordination_type; duration_type period; duration_type skip; @@ -138,8 +138,8 @@ public: window_with_time_factory(duration_type p, duration_type s, coordination_type c) : period(p), skip(s), coordination(c) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<observable<typename std::decay<Observable>::type::value_type>>(window_with_time<typename std::decay<Observable>::type::value_type, Duration, Coordination>(period, skip, coordination))) { - return source.template lift<observable<typename std::decay<Observable>::type::value_type>>(window_with_time<typename std::decay<Observable>::type::value_type, Duration, Coordination>(period, skip, coordination)); + -> decltype(source.template lift<observable<rxu::value_type_t<rxu::decay_t<Observable>>>>(window_with_time<rxu::value_type_t<rxu::decay_t<Observable>>, Duration, Coordination>(period, skip, coordination))) { + return source.template lift<observable<rxu::value_type_t<rxu::decay_t<Observable>>>>(window_with_time<rxu::value_type_t<rxu::decay_t<Observable>>, Duration, Coordination>(period, skip, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp index a3e45f4..fa50a57 100644 --- a/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-window_time_count.hpp @@ -16,10 +16,10 @@ namespace detail { template<class T, class Duration, class Coordination> struct window_with_time_or_count { - typedef typename std::decay<T>::type source_value_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<T> source_value_type; + typedef rxu::decay_t<Coordination> coordination_type; typedef typename coordination_type::coordinator_type coordinator_type; - typedef typename std::decay<Duration>::type duration_type; + typedef rxu::decay_t<Duration> duration_type; struct window_with_time_or_count_values { @@ -46,7 +46,7 @@ struct window_with_time_or_count typedef window_with_time_or_count_observer<Subscriber> this_type; typedef observer_base<observable<T>> base_type; typedef typename base_type::value_type value_type; - typedef typename std::decay<Subscriber>::type dest_type; + typedef rxu::decay_t<Subscriber> dest_type; typedef observer<T, this_type> observer_type; struct window_with_time_or_count_subscriber_values : public window_with_time_or_count_values @@ -133,8 +133,8 @@ struct window_with_time_or_count template<class Duration, class Coordination> class window_with_time_or_count_factory { - typedef typename std::decay<Duration>::type duration_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Duration> duration_type; + typedef rxu::decay_t<Coordination> coordination_type; duration_type period; int count; @@ -143,8 +143,8 @@ public: window_with_time_or_count_factory(duration_type p, int n, coordination_type c) : period(p), count(n), coordination(c) {} template<class Observable> auto operator()(Observable&& source) - -> decltype(source.template lift<observable<typename std::decay<Observable>::type::value_type>>(window_with_time_or_count<typename std::decay<Observable>::type::value_type, Duration, Coordination>(period, count, coordination))) { - return source.template lift<observable<typename std::decay<Observable>::type::value_type>>(window_with_time_or_count<typename std::decay<Observable>::type::value_type, Duration, Coordination>(period, count, coordination)); + -> decltype(source.template lift<observable<rxu::value_type_t<rxu::decay_t<Observable>>>>(window_with_time_or_count<rxu::value_type_t<rxu::decay_t<Observable>>, Duration, Coordination>(period, count, coordination))) { + return source.template lift<observable<rxu::value_type_t<rxu::decay_t<Observable>>>>(window_with_time_or_count<rxu::value_type_t<rxu::decay_t<Observable>>, Duration, Coordination>(period, count, coordination)); } }; diff --git a/Rx/v2/src/rxcpp/operators/rx-zip.hpp b/Rx/v2/src/rxcpp/operators/rx-zip.hpp index a391c48..19e03f6 100644 --- a/Rx/v2/src/rxcpp/operators/rx-zip.hpp +++ b/Rx/v2/src/rxcpp/operators/rx-zip.hpp @@ -18,8 +18,8 @@ struct zip_traits { typedef std::tuple<ObservableN...> tuple_source_type; typedef std::tuple<std::list<typename ObservableN::value_type>...> tuple_source_values_type; - typedef typename std::decay<Selector>::type selector_type; - typedef typename std::decay<Coordination>::type coordination_type; + typedef rxu::decay_t<Selector> selector_type; + typedef rxu::decay_t<Coordination> coordination_type; struct tag_not_valid {}; template<class CS, class... CVN> @@ -33,7 +33,7 @@ struct zip_traits { }; template<class Coordination, class Selector, class... ObservableN> -struct zip : public operator_base<typename zip_traits<Coordination, Selector, ObservableN...>::value_type> +struct zip : public operator_base<rxu::value_type_t<zip_traits<Coordination, Selector, ObservableN...>>> { typedef zip<Coordination, Selector, ObservableN...> this_type; @@ -171,8 +171,8 @@ struct zip : public operator_base<typename zip_traits<Coordination, Selector, Ob template<class Coordination, class Selector, class... ObservableN> class zip_factory { - typedef typename std::decay<Coordination>::type coordination_type; - typedef typename std::decay<Selector>::type selector_type; + typedef rxu::decay_t<Coordination> coordination_type; + typedef rxu::decay_t<Selector> selector_type; typedef std::tuple<ObservableN...> tuple_source_type; coordination_type coordination; @@ -181,9 +181,9 @@ class zip_factory template<class... YObservableN> auto make(std::tuple<YObservableN...> source) - -> observable<typename zip<Coordination, Selector, YObservableN...>::value_type, zip<Coordination, Selector, YObservableN...>> { - return observable<typename zip<Coordination, Selector, YObservableN...>::value_type, zip<Coordination, Selector, YObservableN...>>( - zip<Coordination, Selector, YObservableN...>(coordination, selector, std::move(source))); + -> observable<rxu::value_type_t<zip<Coordination, Selector, YObservableN...>>, zip<Coordination, Selector, YObservableN...>> { + return observable<rxu::value_type_t<zip<Coordination, Selector, YObservableN...>>, zip<Coordination, Selector, YObservableN...>>( + zip<Coordination, Selector, YObservableN...>(coordination, selector, std::move(source))); } public: zip_factory(coordination_type sf, selector_type s, ObservableN... on) |