proxygen: wangle::Observer< T > Struct Template Reference

#include <Observer.h>

Inheritance diagram for wangle::Observer< T >:

Public Member Functions
virtual void	onNext (const T &)=0

virtual void	onError (Error)=0

virtual void	onCompleted ()=0

virtual	~Observer ()=default

Static Public Member Functions
template<class N , class E , class C >
static std::unique_ptr< Observer >	create (N &&onNextFn, E &&onErrorFn, C &&onCompletedFn)

template<class N , class E >
static std::unique_ptr< Observer >	create (N &&onNextFn, E &&onErrorFn)

template<class N >
static std::unique_ptr< Observer >	create (N &&onNextFn)

Detailed Description

template<class T>
struct wangle::Observer< T >

Observer interface. You can subclass it, or you can just use create() to use std::functions.

Definition at line 32 of file Observer.h.

Constructor & Destructor Documentation

template<class T>

virtual wangle::Observer< T >::~Observer ( )

virtualdefault

Member Function Documentation

template<class T>

template<class N , class E , class C >

static std::unique_ptr<Observer> wangle::Observer< T >::create	(	N &&	onNextFn,
		E &&	onErrorFn,
		C &&	onCompletedFn
	)

inlinestatic

Create an Observer with std::function callbacks. Handy to make ad-hoc Observers with lambdas.

Templated for maximum perfect forwarding flexibility, but ultimately whatever you pass in has to implicitly become a std::function for the same signature as onNext(), onError(), and onCompleted() respectively. (see the FunctionObserver typedefs)

Definition at line 48 of file Observer.h.

Referenced by incrementer(), makeCOObserver(), makeMOObserver(), makeObserver(), and TEST().

   {
     return std::make_unique<FunctionObserver<T>>(
       std::forward<N>(onNextFn),
       std::forward<E>(onErrorFn),
       std::forward<C>(onCompletedFn));
   }

template<class T>

template<class N , class E >

static std::unique_ptr<Observer> wangle::Observer< T >::create	(	N &&	onNextFn,
		E &&	onErrorFn
	)

inlinestatic

Create an Observer with only onNext and onError callbacks. onCompleted will just be a no-op.

Definition at line 60 of file Observer.h.

                                                                      {
     return std::make_unique<FunctionObserver<T>>(
       std::forward<N>(onNextFn),
       std::forward<E>(onErrorFn),
       nullptr);
   }

template<class T>

template<class N >

static std::unique_ptr<Observer> wangle::Observer< T >::create ( N && onNextFn )

inlinestatic

Create an Observer with only an onNext callback. onError and onCompleted will just be no-ops.

Definition at line 70 of file Observer.h.

                                                       {
     return std::make_unique<FunctionObserver<T>>(
       std::forward<N>(onNextFn),
       nullptr,
       nullptr);
   }