9#ifndef ZYPP_NG_LOGICHELPERS_INCLUDED 
   10#define ZYPP_NG_LOGICHELPERS_INCLUDED 
   12#include <zypp-core/zyppng/async/AsyncOp> 
   18    template <
typename Op, 
typename = 
void>
 
   21    template <
typename Op>
 
   34  template <
bool isAsync>
 
   62  #define ZYPP_ENABLE_MAYBE_ASYNC_MIXIN( IsAsync ) \ 
   63    using MaybeAsyncMixin<IsAsync>::makeReadyResult; \ 
   65    using MaybeAsyncRef = typename MaybeAsyncMixin<IsAsync>:: template MaybeAsyncRef<T> 
 
  160  template <
typename Executor, 
typename OpType>
 
  164    using Result = 
typename OpType::value_type;
 
  169    template <
typename ...Args, 
typename FOpType = OpType>
 
  171      auto op = std::make_shared<Executor>( std::forward<Args>(args)... );
 
 
  176    template <
typename ...Args, 
typename FOpType = OpType>
 
  178      return Executor( std::forward<Args>(args)... ).execute();
 
 
  187      return static_cast<Executor *
>(
this);
 
 
  191    template <
typename FOpType = OpType>
 
  193      this->_innerPipeline = 
static_cast<Executor*
>(
this)->execute();
 
  194      this->_innerPipeline->onReady([
this]( 
auto &&val ){
 
  195        this->setReady( std::forward<
decltype(val)>(val) );
 
 
 
  204  template <
typename Result>
 
  210  template <
template<
typename, 
typename> 
typename Logic , 
typename OpType>
 
  214    template <
typename ...Args>
 
 
  223  #define ZYPP_ENABLE_LOGIC_BASE(Executor, OpType) \ 
  224    using LogicBase<Executor, OpType>::executor; \ 
  225    using LogicBase<Executor, OpType>::makeReadyResult; \ 
  227    using MaybeAsyncRef = typename LogicBase<Executor, OpType>:: template MaybeAsyncRef<T> 
 
typename enable_if< B, T >::type enable_if_t
typename conditional< B, T, F >::type conditional_t
std::conditional_t< isAsync, AsyncOpRef< T >, T > makeReadyResult(T &&result)
std::shared_ptr< AsyncOp< T > > AsyncOpRef
static std::enable_if_t< detail::is_async_op_v< FOpType >, AsyncOpRef< Result > > run(Args &&...args)
static std::enable_if_t< !detail::is_async_op_v< FOpType >, Result > run(Args &&...args)
typename OpType::value_type Result
std::enable_if_t< detail::is_async_op_v< FOpType >, void > asyncExecute()
std::conditional_t< isAsync, AsyncOpRef< Type >, Type > MaybeAsyncRef
auto makeReadyResult(T &&res)
static constexpr bool is_async
SimpleExecutor(Args &&...args)
AsyncOpRef< typename Op::value_type > _innerPipeline