| Nrpp | |
| Ndetails | |
| Ndisposables | |
| Cdynamic_disposables_container | |
| Cstatic_disposables_container | Container with fixed std::array as underlying storage |
| Cstatic_disposables_container< 0 > | |
| Nobservables | |
| Cblocking_disposable | |
| Cblocking_strategy | |
| Cchain | |
| Cchain< TStrategy > | |
| Cmake_chain | |
| Cmake_chain< New, chain< Args... > > | |
| Cdynamic_disposables_strategy | |
| Cfixed_disposables_strategy | |
| Cdynamic_strategy | |
| Cfake_strategy | |
| Nobservers | |
| Clocal_disposables_strategy | |
| Cnone_disposables_strategy | |
| Cboolean_disposables_strategy | |
| Cobserver_vtable | |
| Cvtable_t | |
| Ctype_erased_observer | |
| Cdynamic_strategy | |
| Clambda_strategy | |
| Coverride_disposables_strategy | |
| Cfake_strategy | |
| Cbase_disposable_impl | |
| Cenable_wrapper_from_this | |
| Cauto_dispose_wrapper | |
| Cdisposable_wrapper_base | |
| Crefocunt_disposable_inner | |
| Cref_count_on_subscribe_t | |
| Cref_count_on_subscribe_t< rpp::connectable_observable< OriginalObservable, Subject > > | |
| Cstate_t | |
| Cvariant_observable_strategy | |
| Cobserver_impl | |
| Cconcat_state_t | |
| Cconcat_source_observer_strategy | |
| Cconcat_strategy | |
| Ccreate_strategy | |
| Cdefer_strategy | |
| Cempty_strategy | |
| Cerror_strategy | |
| Cshared_container | |
| Cfrom_iterable_schedulable | |
| Cfrom_iterable_strategy | |
| Cfrom_callable_invoke | |
| Cinterval_schedulable | |
| Cinterval_strategy | |
| Cnever_strategy | |
| Ctuple_leaf | |
| Ctuple_impl | |
| Ctuple_impl< std::index_sequence< Indices... >, Args... > | |
| Nmemory_model | |
| Cuse_stack | |
| Cuse_shared | |
| Nutils | |
| Ndetails | |
| Ctraits | |
| Cunique_variant_t | |
| Cunique_variant_t< std::variant< Ts... >, U, Us... > | |
| Cnot_enough_emissions | |
| Cmore_disposables_than_expected | |
| Ctimeout_reached | |
| Cout_of_range | |
| Cis_not_template_callable_t | |
| Cis_not_template_callable_t< T, std::void_t< decltype(&T::operator())> > | |
| Cis_not_template_callable_t< R(T::*)(Args...) const > | |
| Cis_not_template_callable_t< R(T::*)(Args...)> | |
| Cis_not_template_callable_t< R(*)(Args...)> | |
| Cfunction_traits | |
| Cfunction_traits< R(T::*)(Args...) const > | |
| Cfunction_traits< R(T::*)(Args...)> | |
| Cfunction_traits< R(*)()> | |
| Cfunction_traits< R(*)(Args...)> | |
| Coverloaded | |
| Cempty_function_t | |
| Cempty_function_any_t | |
| Cempty_function_any_by_lvalue_t | |
| Crethrow_error_t | |
| Cequal_to | |
| Creturn_true | |
| Cless | |
| Cpack_to_tuple | |
| Ctuple | |
| Cnone | |
| Ctypes | |
| Cconvertible_to_any | |
| Cstatic_mem_fn | |
| Cfinally_action | Calls passed function during destruction |
| Crepeated_container | |
| Citerator | |
| Cinfinite_repeated_container | |
| Citerator | |
| Cnone_mutex | |
| Cvalue_with_mutex | |
| Cpointer_under_lock | |
| Noperators | |
| Ndetails | |
| Cas_blocking_t | |
| Cbuffer_observer_strategy | |
| Cbuffer_t | |
| Coperator_traits | |
| Ccombine_latest_disposable | |
| Ccombine_latest_observer_strategy | |
| Ccombine_latest_t | |
| Cconcat_inner_observer_strategy | |
| Cconcat_disposable | |
| Cconcat_observer_strategy | |
| Cconcat_t | |
| Coperator_traits | |
| Cdebounce_disposable | |
| Cdebounce_disposable_wrapper | |
| Cdebounce_observer_strategy | |
| Cdebounce_t | |
| Coperator_traits | |
| Cemission | |
| Cdelay_disposable | |
| Cdelay_disposable_wrapper | |
| Cdelay_observer_strategy | |
| Cdelay_t | |
| Coperator_traits | |
| Ccombining_disposable | |
| Ccombining_observer_strategy | |
| Ccombining_operator_t | |
| Coperator_traits | |
| Cforwarding_subject | |
| Crepeating_state | |
| Crepeating_inner_observer_strategy | |
| Crepeating_observer_strategy | |
| Clift_operator | |
| Cdistinct_observer_strategy | |
| Cdistinct_t | |
| Coperator_traits | |
| Cdistinct_until_changed_observer_strategy | |
| Cdistinct_until_changed_t | |
| Coperator_traits | |
| Celement_at_observer_strategy | |
| Celement_at_t | |
| Coperator_traits | |
| Cfilter_observer_strategy | |
| Cfilter_t | |
| Coperator_traits | |
| Cfinally_t | |
| Coperator_traits | |
| Cfirst_observer_strategy | |
| Cfirst_t | |
| Coperator_traits | |
| Cflat_map_t | |
| Cgroup_by_observable_strategy | |
| Cgroup_by_inner_observer_strategy | |
| Cgroup_by_observer_strategy | |
| Cgroup_by_t | |
| Coperator_traits | |
| Clast_observer_strategy | |
| Clast_t | |
| Coperator_traits | |
| Cmap_observer_strategy | |
| Cmap_t | |
| Coperator_traits | |
| Cmerge_disposable | |
| Cmerge_observer_base_strategy | |
| Cmerge_observer_inner_strategy | |
| Cmerge_observer_strategy | |
| Cmerge_t | |
| Coperator_traits | |
| Cmerge_with_t | |
| Coperator_traits | |
| Cmulticast_t | |
| Ctemplate_multicast_t | |
| Con_error_resume_next_disposable | |
| Con_error_resume_next_inner_observer_strategy | |
| Con_error_resume_next_observer_strategy | |
| Con_error_resume_next_t | |
| Coperator_traits | |
| Creduce_observer_strategy | |
| Creduce_t | |
| Coperator_traits | |
| Creduce_no_seed_observer_strategy | |
| Creduce_no_seed_t | |
| Coperator_traits | |
| Cref_count_t | |
| Crepeat_t | |
| Cinfinite_repeat_t | |
| Crepeat_when_impl_strategy | |
| Crepeat_when_t | |
| Coperator_traits | |
| Cretry_state_t | |
| Cretry_observer_strategy | |
| Cretry_t | |
| Coperator_traits | |
| Cretry_when_impl_strategy | |
| Cretry_when_t | |
| Coperator_traits | |
| Cscan_observer_strategy | |
| Cscan_t | |
| Coperator_traits | |
| Cscan_no_seed_observer_strategy | |
| Cscan_no_seed_t | |
| Coperator_traits | |
| Cskip_observer_strategy | |
| Cskip_t | |
| Coperator_traits | |
| Cstart_with_t | |
| Cstart_with_values_t | |
| Csubscribe_t | |
| Csubscribe_t< observer< Type, ObserverStrategy > > | |
| Csubscribe_t< ObserverStrategy > | |
| Csubscribe_t< rpp::composite_disposable_wrapper, observer< Type, ObserverStrategy > > | |
| Csubscribe_t< rpp::composite_disposable_wrapper, ObserverStrategy > | |
| Csubscribe_t< OnNext, OnError, OnCompleted > | |
| Csubscribe_t< rpp::composite_disposable_wrapper, OnNext, OnError, OnCompleted > | |
| Csubscribe_on_schedulable | |
| Csubscribe_on_t | |
| Coperator_traits | |
| Cswitch_on_next_state_t | |
| Cswitch_on_next_inner_observer_strategy | |
| Cswitch_on_next_observer_strategy | |
| Cswitch_on_next_t | |
| Coperator_traits | |
| Ctake_observer_strategy | |
| Ctake_t | |
| Coperator_traits | |
| Ctake_last_observer_strategy | |
| Ctake_last_t | |
| Coperator_traits | |
| Ctake_until_disposable | |
| Ctake_until_observer_strategy_base | |
| Ctake_until_throttle_observer_strategy | |
| Ctake_until_observer_strategy | |
| Ctake_until_t | |
| Coperator_traits | |
| Ctake_while_observer_strategy | |
| Ctake_while_t | |
| Coperator_traits | |
| Ctap_observer_strategy | |
| Ctap_t | |
| Coperator_traits | |
| Cthrottle_observer_strategy | |
| Cthrottle_t | |
| Coperator_traits | |
| Ctimeout_disposable | |
| Cobserver_with_timeout | |
| Ctimeout_disposable_wrapper | |
| Ctimeout_observer_strategy | |
| Ctimeout_t | |
| Coperator_traits | |
| Ctimeout_with_error_t | |
| Coperator_traits | |
| Cwindow_observer_strategy | |
| Cwindow_t | |
| Coperator_traits | |
| Cwindow_toggle_state | |
| Cstate_t | |
| Cwindow_toggle_closing_observer_strategy | |
| Cwindow_toggle_opening_observer_strategy | |
| Cwindow_toggle_observer_strategy | |
| Cwindow_toggle_t | |
| Coperator_traits | |
| Cwith_latest_from_disposable | |
| Cwith_latest_from_inner_observer_strategy | |
| Cwith_latest_from_observer_strategy | |
| Cwith_latest_from_t | |
| Coperator_traits | |
| Czip_disposable | |
| Czip_observer_strategy | |
| Czip_t | |
| Nschedulers | |
| Ndetails | |
| Cschedulable_base | |
| Cadvanced_call | |
| Cspecific_schedulable | |
| Coptional_mutex | |
| Cshared_queue_data | |
| Cschedulables_queue | |
| Cfake_schedulable_handler | |
| Nconstraint | |
| Ndetails | |
| Cis_worker | |
| Cis_worker< rpp::schedulers::worker< Strategy > > | |
| Ccomputational | Scheduler owning static thread pool of workers and using "some" thread from this pool on create_worker call |
| Ccurrent_thread | Schedules execution of schedulables via queueing tasks to the caller thread with priority to time_point and order |
| Cis_queue_is_empty | |
| Cworker_strategy | |
| Cworker | |
| Cdelay_from_now | Timepoint of next execution would be calculcated from NOW timpoint (time of returning from schedulable) |
| Cdelay_from_this_timepoint | Timepoint of next execution would be calculcated from timepoint of current scheduling |
| Cdelay_to | Provide timepoint of next execution explicitly |
| Cimmediate | Immediately calls provided schedulable or waits for time_point (in the caller-thread) |
| Cworker_strategy | |
| Cnew_thread | Scheduler which schedules invoking of schedulables to another thread via queueing tasks with priority to time_point and order |
| Cworker_strategy | |
| Crun_loop | Scheduler which schedules execution via queueing tasks, but execution of tasks should be manually dispatched |
| Ctest_scheduler | |
| Cstate | |
| Cworker_strategy | |
| Cthread_pool | Scheduler owning static thread pool of workers and using "some" thread from this pool on create_worker call |
| Nsubjects | |
| Ndetails | |
| Cbehavior_subject_base | |
| Csubject_on_subscribe_strategy | |
| Ccompleted | |
| Cdisposed | |
| Csubject_state | |
| Cpublish_subject_base | |
| Creplay_subject_base | |
| Cbehavior_subject | Same as rpp::subjects::publish_subject but keeps last value (or default) and emits it to newly subscribed observer |
| Cserialized_behavior_subject | Same as rpp::subjects::behavior_subject but on_next/on_error/on_completed calls are serialized via mutex |
| Cpublish_subject | Subject which just multicasts values to observers subscribed on it. It contains two parts: observer and observable at the same time |
| Cserialized_publish_subject | Serialized version of rpp::subjects::publish_subject |
| Creplay_subject | Same as rpp::subjects::publish_subject but send all earlier emitted values to any new observers |
| Cserialized_replay_subject | Same as rpp::subjects::replay_subject but on_next/on_error/on_completed calls are serialized via mutex |
| Ccallback_disposable | Disposable invokes underlying callable on disposing |
| Ccomposite_disposable_impl | Disposable which can keep some other sub-disposables. When this root disposable is disposed, then all sub-disposables would be disposed too |
| Ccomposite_disposable | Disposable which can keep some other sub-disposables. When this root disposable is disposed, then all sub-disposables would be disposed too |
| Cdisposable_wrapper_impl | Main RPP wrapper over disposables |
| Cinterface_composite_disposable | |
| Cinterface_disposable | Interface of disposable |
| Crefcount_disposable | |
| Cblocking_observable | Extension over rpp::observable with set of blocking operators - it waits till completion of underlying observable |
| Cconnectable_observable | Extension over raw observable with ability to be manually connected at any time or ref_counting (sharing same observable between multiple observers) |
| Cdynamic_connectable_observable | |
| Cdynamic_observable | Type-erased version of the rpp::observable. Any observable can be converted to dynamic_observable via rpp::observable::as_dynamic member function |
| Cobservable | Base class for any observable used in RPP. It handles core callbacks of observable |
| Cgrouped_observable | Extension over rpp::observable for some "subset" of values from original observable grouped by some key. It has get_key() member function. Used in group_by operator to represent grouped observable |
| Cvariant_observable | Extension over rpp::observable to provide ability statically keep one of multiple observables |
| Cdynamic_observer | Type-erased version of the rpp::observer. Any observer can be converted to dynamic_observer via rpp::observer::as_dynamic member function |
| Cobserver | Base class for any observer used in RPP. It handles core callbacks of observers. Objects of this class would be passed to subscribe of observable |
| Cobserver< Type, details::observers::override_disposables_strategy< Strategy, DisposableStrategy > > | |
| Cobserver< Type, rpp::details::observers::dynamic_strategy< Type > > | |
| Nrppasio | |
| Nschedulers | |
| Cstrand | Asio based scheduler where each worker is assigned an asio strand to execute schedulables with the guarantee that none of those schedulables will execute concurrently |
| Nrppgrpc | |
| Ndetails | |
| Cbase_writer | |
| Cobserver_strategy | |
| Cbase_reader | |
| Nutils | |
| Creactor_failed | |
| Cclient_bidi_reactor | RPP's based implementation for grpc client bidirectional reactor |
| Cclient_write_reactor | RPP's based implementation for grpc client write reactor |
| Cclient_read_reactor | RPP's based implementation for grpc client read reactor |
| Cserver_bidi_reactor | RPP's based implementation for grpc server bidirectional reactor |
| Cserver_write_reactor | RPP's based implementation for grpc server write reactor |
| Cserver_read_reactor | RPP's based implementation for grpc server read reactor |
| Nrppqt | |
| Nschedulers | |
| Cmain_thread_scheduler | Schedule provided schedulables to main GUI QT thread (where QApplication placed) |
| Ndetails | |
| Cfrom_signal_on_event | |
| Cfrom_signal_on_event< Arg > | |
| Cfrom_signal_on_event<> | |
| Nutils | |
| Cno_active_qapplication | |
| Cmock_observer_strategy | |
| Cserver | |
| Csimple_map | |
| Coperator_traits | |
1.16.1