14#ifndef ZYPPNG_MONADIC_ASYNCRESULT_H_INCLUDED 
   15#define ZYPPNG_MONADIC_ASYNCRESULT_H_INCLUDED 
   17#include <zypp-core/zyppng/meta/TypeTraits> 
   18#include <zypp-core/zyppng/meta/FunctionTraits> 
   19#include <zypp-core/zyppng/meta/Functional> 
   20#include <zypp-core/zyppng/async/AsyncOp> 
   27    template< 
typename Callback, 
typename MsgType, 
typename = std::
void_t<> >
 
   30    template< 
typename Callback, 
typename MsgType >
 
   33        std::enable_if_t< is_async_op_v<Callback> >,
 
   34        decltype ( std::declval<remove_smart_ptr_t<Callback>>()( std::declval<MsgType>()) )
 
   36      > : 
public std::true_type{};
 
 
   42    template< 
typename Callback, 
typename MsgType >
 
   45    template< 
typename Callback, 
typename MsgType, 
typename = std::
void_t<> >
 
   48    template< 
typename Callback, 
typename MsgType >
 
   51        std::enable_if_t< !is_async_op_v<Callback> >,
 
   52        std::enable_if_t< !std::is_same_v< void, decltype ( std::declval<Callback>()(std::declval<MsgType>())) > > > 
 
   53      > : 
public std::true_type{};
 
 
   58    template< 
typename Callback, 
typename MsgType, 
typename = std::
void_t<> >
 
   62    template <
typename Callback, 
typename Arg>
 
   66    template< 
typename Callback, 
typename MsgType, 
typename = std::
void_t<> >
 
   69    template< 
typename Callback, 
typename MsgType >
 
   72        std::enable_if_t< is_sync_monad_cb<Callback, MsgType>::value >,
 
   73        std::enable_if_t< callback_returns_async_op<Callback, MsgType>::value >>
 
   74      > : 
public std::true_type{};
 
 
   76    template< 
typename Callback, 
typename MsgType, 
typename = std::
void_t<> >
 
   79    template< 
typename Callback, 
typename MsgType >
 
   82        std::enable_if_t< is_sync_monad_cb<Callback, MsgType>::value >,
 
   83        std::enable_if_t< !callback_returns_async_op<Callback, MsgType>::value > >
 
   84      > : 
public std::true_type{};
 
 
   89    template <
typename Callback, 
typename Arg>
 
   95    template <
typename Callback, 
typename Arg>
 
  119    template <
typename T>
 
  122    template <
typename T>
 
  125    template <
typename T>
 
  130    template <
typename PrevRes, 
typename CallbackOp, 
typename AOpRes = 
typename CallbackOp::value_type >
 
  154        _myTask->onReady( [
this] ( AOpRes && res ){
 
 
  170        _myTask->operator()(std::move(res));
 
 
 
  177    template <
typename PrevRes, 
typename Callback, 
typename Enable = 
void>
 
  181    template <
typename PrevRes, 
typename Callback>
 
  182    struct AsyncToSyncResult<PrevRes, Callback, 
std::enable_if_t< is_sync_monad_cb_with_sync_res_v<Callback, PrevRes> >>
 
  183      : 
public zyppng::AsyncOp< typename std::invoke_result_t<Callback, PrevRes> > {
 
  189      template <
typename CBType = Callback>
 
  207        _prevTask->onReady( std::bind( &AsyncToSyncResult::readyWasCalled, 
this, std::placeholders::_1) );
 
 
 
  228    template <
typename PrevRes, 
typename Callback>
 
  229    struct AsyncToSyncResult<PrevRes, Callback, 
std::enable_if_t< is_sync_monad_cb_with_async_res_v<Callback, PrevRes> >>
 
  230      : 
public zyppng::AsyncOp< typename remove_smart_ptr_t<std::invoke_result_t<Callback, PrevRes>>::value_type> {
 
  235      template <
typename CBType = Callback>
 
  253        _prevTask->onReady( std::bind( &AsyncToSyncResult::readyWasCalled, 
this, std::placeholders::_1) );
 
 
 
  281    template< 
typename PrevOp , 
typename Callback,
 
  286      using PrevOpRes = 
typename PrevOp::value_type;
 
  287      return std::make_shared<detail::AsyncToAsyncResult<PrevOpRes, Callback>>( std::move(in), std::move(c) );
 
 
  290    template< 
typename PrevOp , 
typename Callback,
 
  294    auto operator| ( std::shared_ptr<PrevOp> &&in, Callback &&c )
 
  296      using PrevOpRes = 
typename PrevOp::value_type;
 
 
  304    template< 
typename PrevOp , 
typename Callback,
 
  308    auto operator| ( std::shared_ptr<PrevOp> &&in, Callback &&c )
 
  310      using PrevOpRes = 
typename PrevOp::value_type;
 
 
  319    template< 
typename PrevRes , 
typename CallbackOp,
 
  325      std::forward<CallbackOp>(c)->operator()( std::forward<PrevRes>(in) );
 
 
  331    template< 
typename SyncRes
 
  338      return std::forward<Callback>(c)(std::forward<SyncRes>(in));
 
 
 
typename enable_if< B, T >::type enable_if_t
typename remove_reference< T >::type remove_reference_t
std::enable_if< std::is_member_pointer< typenamestd::decay< Functor >::type >::value, typenamestd::result_of< Functor &&(Args &&...)>::type >::type invoke(Functor &&f, Args &&... args)
constexpr bool is_nested_async_v
constexpr bool is_sync_monad_cb_with_sync_res_v
constexpr bool is_future_monad_cb_v
constexpr bool is_async_op_v
std::conjunction< has_value_type< remove_smart_ptr_t< T > >, is_asyncop_type< remove_smart_ptr_t< T > > > is_async_op
constexpr bool is_sync_monad_cb_with_async_res_v
constexpr bool is_sync_monad_cb_v
is_async_op< std::invoke_result_t< Callback, Arg > > callback_returns_async_op
auto operator|(std::shared_ptr< PrevOp > &&in, std::shared_ptr< Callback > &&c) -> AsyncOpRef< typename Callback::value_type >
std::conditional_t< isAsync, AsyncOpRef< T >, T > makeReadyResult(T &&result)
std::shared_ptr< AsyncOp< T > > AsyncOpRef
typename remove_smart_ptr< T >::type remove_smart_ptr_t
void setReady(value_type &&val)
AsyncToAsyncResult(AsyncOpRef< PrevRes > &&prevTask, std::shared_ptr< CallbackOp > &&cb)
virtual ~AsyncToAsyncResult()
AsyncToAsyncResult(AsyncToAsyncResult &&other)=delete
AsyncToAsyncResult & operator=(const AsyncToAsyncResult &other)=delete
AsyncToAsyncResult(const AsyncToAsyncResult &other)=delete
std::shared_ptr< CallbackOp > _myTask
void readyWasCalled(PrevRes res)
AsyncOpRef< PrevRes > _prevTask
AsyncToSyncResult(AsyncOpRef< PrevRes > &&prevTask, CBType &&cb)
void readyWasCalled(PrevRes res)
AsyncToSyncResult(const AsyncToSyncResult &other)=delete
AsyncOpRef< PrevRes > _prevTask
AsyncToSyncResult(AsyncToSyncResult &&other)=delete
virtual ~AsyncToSyncResult()
std::invoke_result_t< Callback, PrevRes > value_type
AsyncOpRef< value_type > _asyncResult
AsyncToSyncResult(AsyncOpRef< PrevRes > &&prevTask, CBType &&cb)
AsyncOpRef< PrevRes > _prevTask
void readyWasCalled(PrevRes res)
typename remove_smart_ptr_t< std::invoke_result_t< Callback, PrevRes > >::value_type value_type
AsyncToSyncResult(AsyncToSyncResult &&other)=delete
virtual ~AsyncToSyncResult()
AsyncToSyncResult(const AsyncToSyncResult &other)=delete