#include <zypp/ng/workflows/logichelpers.h>

Inheritance diagram for zyppng::LogicBase< Executor, OpType >:

[legend]

Public Types
using	ExecutorType = Executor
using	Result = typename OpType::value_type
Public Types inherited from zyppng::MaybeAsyncMixin< detail::is_async_op_v< OpType > >
using	MaybeAsyncRef

Public Member Functions
	LogicBase ()
virtual	~LogicBase ()
Executor *	executor ()

Static Public Member Functions
template<typename ... Args, typename FOpType = OpType>
static std::enable_if_t< detail::is_async_op_v< FOpType >, AsyncOpRef< Result > >	run (Args &&...args)
template<typename ... Args, typename FOpType = OpType>
static std::enable_if_t< !detail::is_async_op_v< FOpType >, Result >	run (Args &&...args)

Private Member Functions
template<typename FOpType = OpType>
std::enable_if_t< detail::is_async_op_v< FOpType >, void >	asyncExecute ()

Additional Inherited Members
Static Public Attributes inherited from zyppng::MaybeAsyncMixin< detail::is_async_op_v< OpType > >
static constexpr bool	is_async
Protected Member Functions inherited from zyppng::MaybeAsyncMixin< detail::is_async_op_v< OpType > >
auto	makeReadyResult (T &&res)

Detailed Description

template<typename Executor, typename OpType>
struct zyppng::LogicBase< Executor, OpType >

Logic base class template, this allows us to implement certain workflows in a sync/async agnostic way, based on the OpType the code is either sync or async:

// ------------------ computeint.h ---------------------------
 
// the public interface for the workflows are just functions, usually with some
// context object just save passing a gazillion of arguments to the func and
// to carry some state.
AsyncOpRef<expected<int>> computeInt( ContextRef context );
expected<int> computeInt( SyncContextRef context );
 
// ------------------ computeint.cc ---------------------------
 
namespace {
template <
    typename Executor 
  , typename OpType   
>
struct ComputeIntLogic : public LogicBase<Executor, OpType>
{
  // declare some helper tools from the base
  ZYPP_ENABLE_LOGIC_BASE(Executor, OpType);
 
  // declare our context type based on the OpType we are
  using ZyppContextRefType = MaybeAsyncContextRef<OpType>;
 
  // all arguments to the sync/async function are passed to the constructor
  LogicImpl( ZyppContextRefType ctx )
  : LogicBase<Executor>()
  , _ctx( std::move(ctx) )
  {}
 
  // every logic type must implement execute() without any arguments, returning
  // the result type. In async world the pipeline will be stored in the object until its ready
  MaybeAsyncRef<<expected<int>> execute() {
    return executor()->computeSomeInt()
    | and_then( [this]( int result ) {
      std::cout<< "Int calculated as: " << result << std::endl;
      return expected<int>::success(result);
    });
  }
 
  protected:
  ZyppContextRefType _ctx;
};
 
// AsyncOp Executor for ComputeIntLogic implementation,
// here we put all code that can not be implementedin a
// sync/async agnostic way. Usually sending reports to the user.
// If no such code is required, simply use the \ref SimpleExecutor template
class ComputeIntAsyncExecutor : public ComputeIntLogic<ComputeIntAsyncExecutor, AsyncOp<int>>
{
  // usually we just want to use Logic's constructors
  using ComputeIntLogic<ComputeIntAsyncExecutor, AsyncOp<int>>::ComputeIntLogic;
  AsyncOpRef<expected<int>> computeSomeInt() {
    // .... some implementation that asynchronously computes a int and returns it
  }
};
 
// SyncOp Executor for ComputeIntLogic implementation,
// here we put all the sync variants of code that can not be implemented in a
// sync/async agnostic way. Usually sending reports to the user.
// If no such code is required, simply use the \ref SimpleExecutor template
class ComputeIntSyncExecutor : public ComputeIntLogic<ComputeIntAsyncExecutor, SyncOp<int>>
{
  using ComputeIntLogic<ComputeIntAsyncExecutor, SyncOp<int>>::ComputeIntLogic;
  expected<int> computeSomeInt(){
    // .... some implementation that synchronously computes a int and returns it
  }
};
 
} //namespace
 
// by overloading this function on the (Sync)ContextRef type other workflow implementations
// can call the async/sync version just by passing the right parameters
AsyncOpRef<expected<int>> computeInt( ContextRef context ) {
  // the run() static method is provided by the LogicBase subclass
  return ComputeIntAsyncExecutor::run( std::move(context) );
}
 
expected<int> computeInt( SyncContextRef context ) {
  // the run() static method is provided by the LogicBase subclass
  return ComputeIntSyncExecutor::run( std::move(context) );
}

Definition at line 161 of file logichelpers.h.