libzypp: zyppng::detail Namespace Reference

libzypp 17.36.6

Classes | Typedefs | Functions | Variables
zyppng::detail Namespace Reference

## Classes
struct | add_type_to_collection
| this adds the type NewType to the collection if the condition is true More...
struct | add_type_to_collection< Templ, NewType, Templ< Types... >, false >
struct | add_type_to_collection< Templ, NewType, Templ< Types... >, true >
struct | and_then_helper
struct | AsyncFirstOfImpl
struct | AsyncToAsyncResult
struct | AsyncToSyncResult
struct | AsyncToSyncResult< PrevRes, Callback, std::enable_if_t< is_sync_monad_cb_with_async_res_v< Callback, PrevRes > > >
struct | AsyncToSyncResult< PrevRes, Callback, std::enable_if_t< is_sync_monad_cb_with_sync_res_v< Callback, PrevRes > > >
struct | AwaitImpl
struct | AwaitImpl< ArgType, SignalProxy< SigR(SigT...)>(ArgType::*)()>
struct | collect_helper
struct | collect_transitions
struct | collect_transitions_helper
| collect all transitions that have the same SourceState as the first type argument More...
struct | collect_transitions_helper< State, TupleSoFar, Head >
struct | ContinueUntilValidPredicate
struct | FirstOfHelper
struct | has_value_type
struct | has_value_type< T, std::void_t< typename T::value_type > >
struct | inspect_err_helper
struct | inspect_helper
struct | is_asyncop_type
struct | is_asyncop_type< T, std::enable_if_t< std::is_convertible_v< T *, AsyncOp< typename T::value_type > * > > >
struct | is_future_monad_cb
struct | is_future_monad_cb< Callback, MsgType, std::void_t< std::enable_if_t< is_async_op_v< Callback > >, decltype(std::declval< remove_smart_ptr_t< Callback > >()(std::declval< MsgType >())) > >
struct | is_nested_async
struct | is_nested_async< AsyncOpRef< AsyncOpRef< T > > >
struct | is_same_state
| Evaluates to true if type A and type B wrap the same State type. More...
struct | is_sync_monad_cb
struct | is_sync_monad_cb< Callback, MsgType, std::void_t< std::enable_if_t< !is_async_op_v< Callback > >, std::enable_if_t< !std::is_same_v< void, decltype(std::declval< Callback >()(std::declval< MsgType >())) > > > >
struct | is_sync_monad_cb_with_async_res
struct | is_sync_monad_cb_with_async_res< Callback, MsgType, std::void_t< std::enable_if_t< is_sync_monad_cb< Callback, MsgType >::value >, std::enable_if_t< callback_returns_async_op< Callback, MsgType >::value > > >
struct | is_sync_monad_cb_with_sync_res
struct | is_sync_monad_cb_with_sync_res< Callback, MsgType, std::void_t< std::enable_if_t< is_sync_monad_cb< Callback, MsgType >::value >, std::enable_if_t< !callback_returns_async_op< Callback, MsgType >::value > > >
struct | lifter
struct | lifter< std::shared_ptr< AsyncOp >, std::void_t< std::enable_if_t< zyppng::detail::is_async_op< AsyncOp >::value > > >
struct | LogicBaseExec
struct | LogicBaseExec< Op, std::enable_if_t< detail::is_async_op_v< Op > > >
struct | make_state_set
struct | make_state_set_helper
| Iterates over the list of Transitions and collects them all in a std::variant<State1, State2, ...> type. More...
struct | make_state_set_helper< VariantSoFar, Head >
struct | make_statewithtransition
| Turns a State type into its StateWithTransitions counterpart. More...
struct | make_statewithtransition_set
struct | make_statewithtransition_set< NoState, std::variant< HeadState, States... >, Transitions... >
struct | make_statewithtransition_set_helper
| Iterates over each State in the StateVariant argument, collects the corresponding Transitions and combines the results in a std::variant< StateWithTransitions<...>,... > type. More...
struct | make_statewithtransition_set_helper< VariantSoFar, std::variant< HeadState >, Transitions... >
struct | make_statewithtransition_set_helper< VariantSoFar, std::variant< HeadState, State... >, Transitions... >
struct | mtry_helper
struct | or_else_helper
struct | ReadyResult
struct | RedoWhileImpl
struct | RedoWhileImpl< std::shared_ptr< MyAsyncOp >, Pred, std::enable_if_t< is_async_op< MyAsyncOp >::value > >
struct | RedoWhileImpl< Task, Pred, std::enable_if_t< is_async_op< remove_smart_ptr_t< typename function_traits< Task >::return_type > >::value > >
class | ReportHolder
class | ReportHolder< ContextRef, Report >
class | ReportHolder< SyncContextRef, Report >
struct | showme
struct | StateWithTransitions
struct | transform_collect_helper
struct | transform_helper
struct | WaitForHelper
struct | WaitForHelperExt
struct | WaitForImpl

## Typedefs
template<typename T>
using | is_async_op
template<typename T>
using | EventSource = SignalProxy<void()> (T::*)()
template<typename Callback, typename Arg>
using | callback_returns_async_op = is_async_op< std::invoke_result_t<Callback, Arg >>
template<typename Function, typename ArgType>
using | mbind_cb_result_t = typename std::conditional_t< std::is_same_v<ArgType,void>, std::invoke_result<Function>,std::invoke_result<Function, ArgType> >::type
template<typename T>
using | has_func_trait = typename function_traits<T>::return_type

## Functions
template<typename Variant, typename Type, template< typename, typename > typename Compare = std::is_same, size_t I = 0>
constexpr bool | VariantHasType ()
| Constexpr function that evaluates to true if a variant type Variant already contains the type Type.
template<typename Excpt, typename ... Rest>
bool | containsOneOfExceptionImpl (const std::exception_ptr &exceptionPtr)
template<typename T>
bool | waitForCanContinueExpected (const expected< T > &value)

## Variables
template<typename T>
constexpr bool | has_value_type_v = has_value_type<T>::value
template<typename T>
constexpr bool | is_asyncop_type_v = is_asyncop_type<T>::value
template<typename T>
constexpr bool | is_async_op_v = is_async_op<T>::value
template<typename Callback, typename MsgType>
constexpr bool | is_future_monad_cb_v = is_future_monad_cb<Callback, MsgType>::value
template<typename Callback, typename MsgType, typename = std::void_t<>>
constexpr bool | is_sync_monad_cb_v = is_sync_monad_cb<Callback, MsgType>::value
template<typename Callback, typename Arg>
constexpr bool | is_sync_monad_cb_with_async_res_v = is_sync_monad_cb_with_async_res<Callback, Arg>::value
template<typename Callback, typename Arg>
constexpr bool | is_sync_monad_cb_with_sync_res_v = is_sync_monad_cb_with_sync_res<Callback, Arg>::value
template<typename T>
constexpr bool | is_nested_async_v = is_nested_async<T>::value

## Typedef Documentation

## ◆ is_async_op

template<typename T>

using zyppng::detail::is_async_op

Initial value:
std::conjunction<
has_value_type<remove_smart_ptr_t<T>>,
is_asyncop_type<remove_smart_ptr_t<T> >
>
std::conjunction
Definition type_traits.h:90
zyppng::detail::has_value_type
Definition asyncop.h:31
zyppng::detail::is_asyncop_type
Definition asyncop.h:40

Detects if a type is a AsyncOp based type. This is required in cases where we can not use simple Argument type matching but need to decide on the type characteristics. For example when a AsyncOp is passed as callback argument in the pipelines.

Definition at line 55 of file asyncop.h.

## ◆ EventSource

template<typename T>

using zyppng::detail::EventSource = SignalProxy<void()> (T::*)()

Definition at line 31 of file statemachine.h.

## ◆ callback_returns_async_op

template<typename Callback, typename Arg>

using zyppng::detail::callback_returns_async_op = is_async_op< std::invoke_result_t<Callback, Arg >>

Definition at line 63 of file asyncresult.h.

## ◆ mbind_cb_result_t

template<typename Function, typename ArgType>

using zyppng::detail::mbind_cb_result_t = typename std::conditional_t< std::is_same_v<ArgType,void>, std::invoke_result<Function>,std::invoke_result<Function, ArgType> >::type

Definition at line 409 of file expected.h.

## ◆ has_func_trait

template<typename T>

using zyppng::detail::has_func_trait = typename function_traits<T>::return_type

Definition at line 137 of file redo.h.

## Function Documentation

## ◆ VariantHasType()

template<typename Variant, typename Type, template< typename, typename > typename Compare = std::is_same, size_t I = 0>

bool zyppng::detail::VariantHasType | ( |  | ) |
| constexpr

Constexpr function that evaluates to true if a variant type Variant already contains the type Type.

The Compare argument can be used to change how equality of a type is calculated

Definition at line 105 of file statemachine.h.

## ◆ containsOneOfExceptionImpl()

template<typename Excpt, typename ... Rest>

bool zyppng::detail::containsOneOfExceptionImpl | ( | const std::exception_ptr & | exceptionPtr | ) |

Definition at line 156 of file algorithm.h.

## ◆ waitForCanContinueExpected()

template<typename T>

bool zyppng::detail::waitForCanContinueExpected | ( | const expected< T > & | value | ) |

Definition at line 412 of file expected.h.

## Variable Documentation

## ◆ has_value_type_v

template<typename T>

bool zyppng::detail::has_value_type_v = has_value_type<T>::value
| constexpr

Definition at line 37 of file asyncop.h.

## ◆ is_asyncop_type_v

template<typename T>

bool zyppng::detail::is_asyncop_type_v = is_asyncop_type<T>::value
| constexpr

Definition at line 46 of file asyncop.h.

## ◆ is_async_op_v

template<typename T>

bool zyppng::detail::is_async_op_v = is_async_op<T>::value
| constexpr

Definition at line 61 of file asyncop.h.

## ◆ is_future_monad_cb_v

template<typename Callback, typename MsgType>

bool zyppng::detail::is_future_monad_cb_v = is_future_monad_cb<Callback, MsgType>::value
| constexpr

Checks if a Callable object is of type async_op and if it accepts the given MsgType and returns the expected type

Definition at line 43 of file asyncresult.h.

## ◆ is_sync_monad_cb_v

template<typename Callback, typename MsgType, typename = std::void_t<>>

bool zyppng::detail::is_sync_monad_cb_v = is_sync_monad_cb<Callback, MsgType>::value
| constexpr

Checks if a Callable object is a syncronous callback type with the expected signature

Definition at line 59 of file asyncresult.h.

## ◆ is_sync_monad_cb_with_async_res_v

template<typename Callback, typename Arg>

bool zyppng::detail::is_sync_monad_cb_with_async_res_v = is_sync_monad_cb_with_async_res<Callback, Arg>::value
| constexpr

Checks if a Callable object is a syncronous callback type with the expected signature

Definition at line 90 of file asyncresult.h.

## ◆ is_sync_monad_cb_with_sync_res_v

template<typename Callback, typename Arg>

bool zyppng::detail::is_sync_monad_cb_with_sync_res_v = is_sync_monad_cb_with_sync_res<Callback, Arg>::value
| constexpr

Checks if the given Callback is a function returning a syncronous result

Definition at line 96 of file asyncresult.h.

## ◆ is_nested_async_v

template<typename T>

bool zyppng::detail::is_nested_async_v = is_nested_async<T>::value
| constexpr

Definition at line 126 of file asyncresult.h.