logichelpers.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_NG_LOGICHELPERS_INCLUDED
#define ZYPP_NG_LOGICHELPERS_INCLUDED
 
#include <zypp-core/ng/async/awaitable.h>
#include <zypp/ng/context.h>
 
namespace zyppng
{
 
  namespace detail {
    template <typename Op, typename = void>
    struct LogicBaseExec : public Op { };
 
    template <typename Op>
    struct LogicBaseExec<Op, std::enable_if_t<detail::is_async_op_v<Op>>> : public Op
    {
    protected:
      AsyncOpRef<typename Op::value_type> _innerPipeline;
    };
 
  }

  struct MaybeAsyncMixin
  {
    // Make the isAsync flag accessible for subclasses.
    static constexpr bool is_async = ZYPP_IS_ASYNC;

    template<class Type>
    using MaybeAsyncRef = MaybeAwaitable<Type>;
  };

  #define ZYPP_ENABLE_MAYBE_ASYNC_MIXIN( IsAsync ) \
    template<class T> \
    using MaybeAsyncRef = MaybeAwaitable<T>
 
 

  template <typename Executor, typename OpType>
  struct LogicBase : public detail::LogicBaseExec<OpType>, public MaybeAsyncMixin {
 
    using ExecutorType = Executor;
    using Result = typename OpType::value_type;
 
    LogicBase( ){ }
    virtual ~LogicBase(){}
 
    template <typename ...Args>
    static auto run( Args &&...args ) {
#ifdef ZYPP_ENABLE_ASYNC
        auto op = std::make_shared<Executor>( std::forward<Args>(args)... );
        op->asyncExecute();
        return op;
#else
        return Executor( std::forward<Args>(args)... ).execute();
#endif
    }

    Executor *executor () {
      return static_cast<Executor *>(this);
    }
 
  private:
#ifdef ZYPP_ENABLE_ASYNC
    void asyncExecute() {
      this->_innerPipeline = static_cast<Executor*>(this)->execute();
      this->_innerPipeline->onReady([this]( auto &&val ){
        this->setReady( std::forward<decltype(val)>(val) );
      });
    }
#endif
  };

  template <typename Result>
  struct SyncOp : public Base {
    using value_type = Result;
  };
 
 
  template <template<typename, typename> typename Logic , typename OpType>
  struct SimpleExecutor : public Logic<SimpleExecutor<Logic, OpType>, OpType>
  {
  public:
    template <typename ...Args>
    SimpleExecutor( Args &&...args ) : Logic<SimpleExecutor<Logic, OpType>, OpType>( std::forward<Args>(args)...) {}
  };
 

  #define ZYPP_ENABLE_LOGIC_BASE(Executor, OpType) \
    using LogicBase<Executor, OpType>::executor; \
    template<class T> \
    using MaybeAsyncRef = typename LogicBase<Executor, OpType>:: template MaybeAsyncRef<T>
}
#endif