feat add rxcpp

3party/rxcpp/operators/rx-subscribe.hpp

@@ -0,0 +1,154 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#pragma once
+
+/*! \file rx-subscribe.hpp
+
+    \brief Subscribe will cause the source observable to emit values to the provided subscriber.
+
+    \tparam ArgN  types of the subscriber parameters
+
+    \param an  the parameters for making a subscriber
+
+    \return  A subscription with which the observer can stop receiving items before the observable has finished sending them.
+
+    The arguments of subscribe are forwarded to rxcpp::make_subscriber function. Some possible alternatives are:
+
+    - Pass an already composed rxcpp::subscriber:
+    \snippet subscribe.cpp subscribe by subscriber
+    \snippet output.txt subscribe by subscriber
+
+    - Pass an rxcpp::observer. This allows subscribing the same subscriber to several observables:
+    \snippet subscribe.cpp subscribe by observer
+    \snippet output.txt subscribe by observer
+
+    - Pass an `on_next` handler:
+    \snippet subscribe.cpp subscribe by on_next
+    \snippet output.txt subscribe by on_next
+
+    - Pass `on_next` and `on_error` handlers:
+    \snippet subscribe.cpp subscribe by on_next and on_error
+    \snippet output.txt subscribe by on_next and on_error
+
+    - Pass `on_next` and `on_completed` handlers:
+    \snippet subscribe.cpp subscribe by on_next and on_completed
+    \snippet output.txt subscribe by on_next and on_completed
+
+    - Pass `on_next`, `on_error`, and `on_completed` handlers:
+    \snippet subscribe.cpp subscribe by on_next, on_error, and on_completed
+    \snippet output.txt subscribe by on_next, on_error, and on_completed
+    .
+
+    All the alternatives above also support passing rxcpp::composite_subscription instance. For example:
+    \snippet subscribe.cpp subscribe by subscription, on_next, and on_completed
+    \snippet output.txt subscribe by subscription, on_next, and on_completed
+
+    If neither subscription nor subscriber are provided, then a new subscription is created and returned as a result:
+    \snippet subscribe.cpp subscribe unsubscribe
+    \snippet output.txt subscribe unsubscribe
+
+    For more details, see rxcpp::make_subscriber function description.
+*/
+
+#if !defined(RXCPP_OPERATORS_RX_SUBSCRIBE_HPP)
+#define RXCPP_OPERATORS_RX_SUBSCRIBE_HPP
+
+#include "../rx-includes.hpp"
+
+namespace rxcpp {
+
+namespace operators {
+
+namespace detail {
+
+template<class Subscriber>
+class subscribe_factory;
+
+template<class T, class I>
+class subscribe_factory<subscriber<T, I>>
+{
+    subscriber<T, I> scrbr;
+public:
+    subscribe_factory(subscriber<T, I> s)
+        : scrbr(std::move(s))
+    {}
+    template<class Observable>
+    auto operator()(Observable&& source)
+        -> decltype(std::forward<Observable>(source).subscribe(std::move(scrbr))) {
+        return      std::forward<Observable>(source).subscribe(std::move(scrbr));
+    }
+};
+
+}
+
+/*! @copydoc rx-subscribe.hpp
+*/
+template<class T, class... ArgN>
+auto subscribe(ArgN&&... an)
+    ->      detail::subscribe_factory<decltype  (make_subscriber<T>(std::forward<ArgN>(an)...))> {
+    return  detail::subscribe_factory<decltype  (make_subscriber<T>(std::forward<ArgN>(an)...))>
+                                                (make_subscriber<T>(std::forward<ArgN>(an)...));
+}
+
+namespace detail {
+
+class dynamic_factory
+{
+public:
+    template<class Observable>
+    auto operator()(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));
+    }
+};
+
+}
+
+/*! Return a new observable that performs type-forgetting conversion of this observable.
+
+    \return  The source observable converted to observable<T>.
+
+    \note This operator could be useful to workaround lambda deduction bug on msvc 2013.
+
+    \sample
+    \snippet as_dynamic.cpp as_dynamic sample
+    \snippet output.txt as_dynamic sample
+*/
+inline auto as_dynamic()
+    ->      detail::dynamic_factory {
+    return  detail::dynamic_factory();
+}
+
+namespace detail {
+
+class blocking_factory
+{
+public:
+    template<class Observable>
+    auto operator()(Observable&& source)
+        -> decltype(std::forward<Observable>(source).as_blocking()) {
+        return      std::forward<Observable>(source).as_blocking();
+    }
+};
+
+}
+
+/*! Return a new observable that contains the blocking methods for this observable.
+
+    \return  An observable that contains the blocking methods for this observable.
+
+    \sample
+    \snippet from.cpp threaded from sample
+    \snippet output.txt threaded from sample
+*/
+inline auto as_blocking()
+    ->      detail::blocking_factory {
+    return  detail::blocking_factory();
+}
+
+
+}
+
+}
+
+#endif