rx-subscribe.hpp File Reference

Subscribe will cause the source observable to emit values to the provided subscriber. More...

#include "../rx-includes.hpp"

Include dependency graph for rx-subscribe.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
	rxcpp
	rxcpp::operators

Macros
#define	RXCPP_OPERATORS_RX_SUBSCRIBE_HPP

Functions
template<class T , class... ArgN>
auto	rxcpp::operators::subscribe (ArgN &&...an) -> detail::subscribe_factory< decltype(make_subscriber< T >(std::forward< ArgN >(an)...))>
	Subscribe will cause the source observable to emit values to the provided subscriber. More...
auto	rxcpp::operators::as_dynamic () -> detail::dynamic_factory
auto	rxcpp::operators::as_blocking () -> detail::blocking_factory

Detailed Description

Subscribe will cause the source observable to emit values to the provided subscriber.

Template Parameters

ArgN	types of the subscriber parameters

Parameters

an	the parameters for making a subscriber

Returns

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:

      auto subscriber = rxcpp::make_subscriber<int>(
          [](int v){printf("OnNext: %d\n", v);},
          [](){printf("OnCompleted\n");});
      auto values = rxcpp::observable<>::range(1, 3);
      values.subscribe(subscriber);

  OnNext: 1
  OnNext: 2
  OnNext: 3
  OnCompleted

• Pass an rxcpp::observer. This allows subscribing the same subscriber to several observables:

      auto subscriber = rxcpp::make_subscriber<int>(
          [](int v){printf("OnNext: %d\n", v);},
          [](){printf("OnCompleted\n");});
      auto values1 = rxcpp::observable<>::range(1, 3);
      auto values2 = rxcpp::observable<>::range(4, 6);
      values1.subscribe(subscriber.get_observer());
      values2.subscribe(subscriber.get_observer());

  OnNext: 1
  OnNext: 2
  OnNext: 3
  OnCompleted
  OnNext: 4
  OnNext: 5
  OnNext: 6
  OnCompleted

• Pass an on_next handler:

      auto values = rxcpp::observable<>::range(1, 3);
      values.subscribe(
          [](int v){printf("OnNext: %d\n", v);});

  OnNext: 1
  OnNext: 2
  OnNext: 3

• Pass on_next and on_error handlers:

      auto values = rxcpp::observable<>::range(1, 3).
          concat(rxcpp::observable<>::error<int>(std::runtime_error("Error from source")));
      values.subscribe(
          [](int v){printf("OnNext: %d\n", v);},
          [](std::exception_ptr ep){
              try {std::rethrow_exception(ep);}
              catch (const std::exception& ex) {
                  printf("OnError: %s\n", ex.what());
              }
          });

  OnNext: 1
  OnNext: 2
  OnNext: 3
  OnError: Error from source

• Pass on_next and on_completed handlers:

      auto values = rxcpp::observable<>::range(1, 3);
      values.subscribe(
          [](int v){printf("OnNext: %d\n", v);},
          [](){printf("OnCompleted\n");});

  OnNext: 1
  OnNext: 2
  OnNext: 3
  OnCompleted

• Pass on_next, on_error, and on_completed handlers:

      auto values = rxcpp::observable<>::range(1, 3).
          concat(rxcpp::observable<>::error<int>(std::runtime_error("Error from source")));
      values.subscribe(
          [](int v){printf("OnNext: %d\n", v);},
          [](std::exception_ptr ep){
              try {std::rethrow_exception(ep);}
              catch (const std::exception& ex) {
                  printf("OnError: %s\n", ex.what());
              }
          },
          [](){printf("OnCompleted\n");});

  OnNext: 1
  OnNext: 2
  OnNext: 3
  OnError: Error from source

All the alternatives above also support passing rxcpp::composite_subscription instance. For example:

    auto subscription = rxcpp::composite_subscription();
    auto values = rxcpp::observable<>::range(1, 5);
    values.subscribe(
        subscription,
        [&subscription](int v){
            printf("OnNext: %d\n", v);
            if (v == 3)
                subscription.unsubscribe();
        },
        [](){printf("OnCompleted\n");});

OnNext: 1
OnNext: 2
OnNext: 3

If neither subscription nor subscriber are provided, then a new subscription is created and returned as a result:

    auto values = rxcpp::observable<>::range(1, 3).
        concat(rxcpp::observable<>::never<int>()).
        finally([](){printf("The final action\n");});
    auto subscription = values.subscribe(
        [](int v){printf("OnNext: %d\n", v);},
        [](){printf("OnCompleted\n");});
    subscription.unsubscribe();

OnNext: 1
OnNext: 2
OnNext: 3
The final action

For more details, see rxcpp::make_subscriber function description.

Macro Definition Documentation

#define RXCPP_OPERATORS_RX_SUBSCRIBE_HPP