RxCpp
The Reactive Extensions for Native (RxCpp) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++.
Classes | Typedefs | Functions
rxcpp::util Namespace Reference

Classes

struct  all_true
 
struct  all_true< B >
 
struct  all_true< B, BN... >
 
struct  all_true_type
 
struct  all_true_type< B >
 
struct  all_true_type< B, BN... >
 
struct  all_values_true
 
struct  any_value_true
 
struct  count
 
struct  defer_seed_type
 
struct  defer_trait
 
struct  defer_type
 
struct  defer_value_type
 
struct  equal_to
 
struct  equal_to< void >
 
struct  expand_value_types
 
struct  expand_value_types< types< TN... >, types_checked_t< typename std::decay< TN >::type::value_type... > >
 
struct  is_duration
 
struct  is_string
 
struct  is_string< T, typename types_checked_from< typename T::value_type, typename T::traits_type, typename T::allocator_type >::type >
 
struct  less
 
struct  negation
 
struct  plus
 
struct  resolve_type
 
struct  resolve_type< defer_seed_type< Deferred, AN... > >
 
struct  resolve_type< defer_type< Deferred, AN... > >
 
struct  resolve_type< defer_value_type< Deferred, AN... > >
 
struct  types
 
struct  types_checked
 
struct  types_checked_from
 
struct  value_type_from
 
struct  value_type_from< T, typename types_checked_from< value_type_t< T > >::type >
 
struct  values
 
struct  values_from
 
struct  values_from< T, 0, Step, Cursor, ValueN... >
 

Typedefs

template<class T >
using value_type_t = typename std::decay< T >::type::value_type
 
template<class T >
using decay_t = typename std::decay< T >::type
 
template<class... TN>
using result_of_t = typename std::result_of< TN... >::type
 
template<bool... BN>
using enable_if_all_true_t = typename std::enable_if< all_true< BN... >::value >::type
 
template<class... BN>
using enable_if_all_true_type_t = typename std::enable_if< all_true_type< BN... >::value >::type
 
template<class... TN>
using types_checked_t = typename types_checked_from< TN... >::type
 
template<class... TN>
using value_types_t = typename expand_value_types< types< TN... >>::type
 

Functions

template<class T , std::size_t size>
std::vector< T > to_vector (const T(&arr)[size])
 
template<class T >
std::vector< T > to_vector (std::initializer_list< T > il)
 
template<class T0 , class... TN>
std::enable_if<!std::is_array< T0 >::value &&std::is_pod< T0 >::value, std::vector< T0 > >::type to_vector (T0 t0, TN...tn)
 
template<typename T >
T const & as_const (T &t)
 
template<typename T >
void as_const (T const &&)=delete
 
template<class F , class... ParamN>
auto apply (std::tuple< ParamN... > p, F &&f) -> decltype(detail::apply(std::move(p), typename values_from< int, sizeof...(ParamN)>::type(), std::forward< F >(f)))
 
template<class F_inner , class F_outer , class... ParamN>
auto apply_to_each (std::tuple< ParamN... > &p, F_inner &f_inner, F_outer &f_outer) -> decltype(detail::apply_to_each(p, typename values_from< int, sizeof...(ParamN)>::type(), f_inner, f_outer))
 
template<class F_inner , class F_outer , class... ParamN>
auto apply_to_each (std::tuple< ParamN... > &p, const F_inner &f_inner, const F_outer &f_outer) -> decltype(detail::apply_to_each(p, typename values_from< int, sizeof...(ParamN)>::type(), f_inner, f_outer))
 
template<class F >
auto apply_to (F f) -> detail::apply_to< F >
 
auto pack () -> detail::pack
 
template<int Index>
auto take_at () -> detail::take_at< Index >
 
template<class OStream >
auto endline (OStream &os) -> detail::endline< OStream >
 
template<class OStream >
auto println (OStream &os) -> decltype(detail::print_followed_with(os, endline(os)))
 
template<class OStream , class Delimit >
auto print_followed_with (OStream &os, Delimit d) -> decltype(detail::print_followed_with(os, detail::insert_function< OStream, Delimit >(os, std::move(d))))
 
template<class OStream , class DelimitValue >
auto print_followed_by (OStream &os, DelimitValue dv) -> decltype(detail::print_followed_with(os, detail::insert_value< OStream, DelimitValue >(os, std::move(dv))))
 
std::string what (std::exception_ptr ep)
 
template<class... T>
auto surely (const std::tuple< T... > &tpl) -> decltype(apply(tpl, detail::surely()))
 

Typedef Documentation

template<class T >
using rxcpp::util::decay_t = typedef typename std::decay<T>::type
template<bool... BN>
using rxcpp::util::enable_if_all_true_t = typedef typename std::enable_if<all_true<BN...>::value>::type
template<class... BN>
using rxcpp::util::enable_if_all_true_type_t = typedef typename std::enable_if<all_true_type<BN...>::value>::type
template<class... TN>
using rxcpp::util::result_of_t = typedef typename std::result_of<TN...>::type
template<class... TN>
using rxcpp::util::types_checked_t = typedef typename types_checked_from<TN...>::type
template<class T >
using rxcpp::util::value_type_t = typedef typename std::decay<T>::type::value_type
template<class... TN>
using rxcpp::util::value_types_t = typedef typename expand_value_types<types<TN...>>::type

Function Documentation

template<class F , class... ParamN>
auto rxcpp::util::apply ( std::tuple< ParamN... >  p,
F &&  f 
) -> decltype(detail::apply(std::move(p), typename values_from<int, sizeof...(ParamN)>::type(), std::forward<F>(f)))
template<class F >
auto rxcpp::util::apply_to ( F  f) -> detail::apply_to<F>
template<class F_inner , class F_outer , class... ParamN>
auto rxcpp::util::apply_to_each ( std::tuple< ParamN... > &  p,
F_inner &  f_inner,
F_outer &  f_outer 
) -> decltype(detail::apply_to_each(p, typename values_from<int, sizeof...(ParamN)>::type(), f_inner, f_outer))
template<class F_inner , class F_outer , class... ParamN>
auto rxcpp::util::apply_to_each ( std::tuple< ParamN... > &  p,
const F_inner &  f_inner,
const F_outer &  f_outer 
) -> decltype(detail::apply_to_each(p, typename values_from<int, sizeof...(ParamN)>::type(), f_inner, f_outer))
template<typename T >
T const& rxcpp::util::as_const ( T &  t)
template<typename T >
void rxcpp::util::as_const ( T const &&  )
delete
template<class OStream >
auto rxcpp::util::endline ( OStream &  os) -> detail::endline<OStream>
auto rxcpp::util::pack ( ) -> detail::pack
inline
template<class OStream , class DelimitValue >
auto rxcpp::util::print_followed_by ( OStream &  os,
DelimitValue  dv 
) -> decltype(detail::print_followed_with(os, detail::insert_value<OStream, DelimitValue>(os, std::move(dv))))
template<class OStream , class Delimit >
auto rxcpp::util::print_followed_with ( OStream &  os,
Delimit  d 
) -> decltype(detail::print_followed_with(os, detail::insert_function<OStream, Delimit>(os, std::move(d))))
template<class OStream >
auto rxcpp::util::println ( OStream &  os) -> decltype(detail::print_followed_with(os, endline(os)))
template<class... T>
auto rxcpp::util::surely ( const std::tuple< T... > &  tpl) -> decltype(apply(tpl, detail::surely()))
inline
template<int Index>
auto rxcpp::util::take_at ( ) -> detail::take_at<Index>
inline
template<class T , std::size_t size>
std::vector<T> rxcpp::util::to_vector ( const T(&)  arr[size])
template<class T >
std::vector<T> rxcpp::util::to_vector ( std::initializer_list< T >  il)
template<class T0 , class... TN>
std::enable_if<!std::is_array<T0>::value && std::is_pod<T0>::value, std::vector<T0> >::type rxcpp::util::to_vector ( T0  t0,
TN...  tn 
)
std::string rxcpp::util::what ( std::exception_ptr  ep)
inline
Generated on Wed Apr 26 2017 23:15:58 for RxCpp by   doxygen 1.8.11