logichelpers.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_NG_LOGICHELPERS_INCLUDED
#define ZYPP_NG_LOGICHELPERS_INCLUDED
 
#include <zypp-core/zyppng/async/AsyncOp>
 
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;
    };
 
  }

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

    template<class Type>
    using MaybeAsyncRef = std::conditional_t< isAsync, AsyncOpRef<Type>, Type>;
 
 
  protected:
    template <typename T>
    inline auto makeReadyResult( T &&res ) {
      return zyppng::makeReadyResult<T, isAsync>  ( std::forward<T>(res) );
    }
  };

  #define ZYPP_ENABLE_MAYBE_ASYNC_MIXIN( IsAsync ) \
    using MaybeAsyncMixin<IsAsync>::makeReadyResult; \
    template<class T> \
    using MaybeAsyncRef = typename MaybeAsyncMixin<IsAsync>:: template MaybeAsyncRef<T>
 
 

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

    Executor *executor () {
      return static_cast<Executor *>(this);
    }
 
  private:
    template <typename FOpType = OpType>
    std::enable_if_t< detail::is_async_op_v<FOpType>, void> asyncExecute() {
      this->_innerPipeline = static_cast<Executor*>(this)->execute();
      this->_innerPipeline->onReady([this]( auto &&val ){
        this->setReady( std::forward<decltype(val)>(val) );
      });
    }
  };

  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; \
    using LogicBase<Executor, OpType>::makeReadyResult; \
    template<class T> \
    using MaybeAsyncRef = typename LogicBase<Executor, OpType>:: template MaybeAsyncRef<T>
}
#endif