asyncop.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
----------------------------------------------------------------------/
*
* This file contains private API, this might break at any time between releases.
* You have been warned!
*
*/
#ifndef ZYPPNG_ASYNC_ASYNCOP_H_INCLUDED
#define ZYPPNG_ASYNC_ASYNCOP_H_INCLUDED
 
#include <zypp-core/zyppng/meta/type_traits.h>
#include <zypp-core/zyppng/base/Base>
#include <zypp-core/base/Exception.h>
#include <zypp-core/zyppng/base/Signals>
#include <optional>
#include <memory>
 
namespace zyppng {
 
  template <typename Result> struct AsyncOp;
  ZYPP_FWD_DECL_TYPE_WITH_REFS ( AsyncOpBase );
 
  namespace detail {
    template <typename T, typename Enable = std::void_t<> >
    struct has_value_type : public std::false_type{};
 
    template <typename T>
    struct has_value_type<T, std::void_t<typename T::value_type>> : public std::true_type {};
 
    template <typename T>
    constexpr bool has_value_type_v = has_value_type<T>::value;
 
    template <typename T, typename Enable = void >
    struct is_asyncop_type : public std::false_type{};
 
    template <typename T>
    struct is_asyncop_type<T, std::enable_if_t< std::is_convertible_v<T*, AsyncOp<typename T::value_type>*> >> : public std::true_type{};
 
    template <typename T>
    constexpr bool is_asyncop_type_v = is_asyncop_type<T>::value;

    template <typename T>
    using is_async_op = std::conjunction<
      has_value_type<remove_smart_ptr_t<T>>,
      is_asyncop_type<remove_smart_ptr_t<T> >
      >;
 
    template < typename T>
    constexpr bool is_async_op_v = is_async_op<T>::value;
  }

  class AsyncOpNotReadyException : public zypp::Exception
  {
  public:
    AsyncOpNotReadyException()
      : Exception( "AsyncOp instance not ready" )
    {}
    ~AsyncOpNotReadyException() override;
  };
  inline AsyncOpNotReadyException::~AsyncOpNotReadyException() { }
 
  class CancelNotImplementedException : public zypp::Exception
  {
  public:
    CancelNotImplementedException()
      : Exception ("AsyncOp does not support cancelling the operation")
    {}
    ~CancelNotImplementedException() override;
  };
  inline CancelNotImplementedException::~CancelNotImplementedException() { }
 
 
  class AsyncOpBase : public Base {
 
  public:

    virtual bool canCancel () {
      return false;
    }

    virtual void cancel () {
      throw CancelNotImplementedException();
    }

    SignalProxy<void()> sigStarted () {
      return _sigStarted;
    }

    SignalProxy<void( const std::string & /*text*/, int /*current*/, int /*max*/ )> sigProgress () {
      return _sigProgress;
    }

    SignalProxy<void()> sigReady () {
      return _sigReady;
    }
 
  protected:
    Signal<void()> _sigStarted;
    Signal<void()> _sigReady;
    Signal<void( const std::string & /*text*/, int /*current*/, int /*max*/ )> _sigProgress;
  };

  template <typename Result>
  struct AsyncOp : public AsyncOpBase {
 
    static_assert(!detail::is_async_op_v<Result>, "A async op can never have a async result");
 
    using value_type = Result;
    using Ptr = std::shared_ptr<AsyncOp<Result>>;
 
    AsyncOp () = default;
 
    AsyncOp ( const AsyncOp &other ) = delete;
    AsyncOp& operator= ( const AsyncOp &other ) = delete;
 
    AsyncOp& operator= ( AsyncOp &&other ) noexcept = default;
    AsyncOp ( AsyncOp &&other ) noexcept = default;
 
    ~AsyncOp() override{}

    void setReady ( value_type && val ) {
      if ( _readyCb ) {
        // use a weak reference to know if `this` was deleted by the callback()
        auto weak = weak_from_this();
        _readyCb( std::move( val ) );
        if ( !weak.expired() )
          _readyCb = {};
      }
      else { //we need to cache the value because no callback is available
        _maybeValue = std::move(val);
        _sigReady.emit();
      }
    }

    bool isReady () const {
      return _maybeValue.has_value();
    }

    template< typename Fun >
    void onReady ( Fun &&cb ) {
      this->_readyCb =  std::forward<Fun>(cb);
 
      if ( isReady() ) {
        // use a weak reference to know if `this` was deleted by the callback()
        auto weak = weak_from_this();
 
        _readyCb( std::move( _maybeValue.value()) );
 
        if ( !weak.expired() ) {
          // value was passed on, reset the optional
          _maybeValue.reset();
 
          // reset the callback, it might be a lambda with captured ressources
          // that need to be released after returning from the func
          _readyCb = {};
        }
      }
    }

    value_type &get (){
      if ( !isReady() )
        ZYPP_THROW(AsyncOpNotReadyException());
      return _maybeValue.value();
    }
 
  private:
    std::function<void(value_type &&)> _readyCb;
    std::optional<value_type> _maybeValue;
  };
 
 
  template <typename T>
  using AsyncOpRef = std::shared_ptr<AsyncOp<T>>;
 

  template <typename Base, typename Result = typename Base::value_type>
  struct NestedAsyncOpMixin
  {
    template <typename ...Args>
    void operator ()( Args &&...args ) {
      assert(!_nestedPipeline);
      _nestedPipeline = static_cast<Base *>(this)->makePipeline( std::forward<Args>(args)...);
      _nestedPipeline->onReady([this]( auto &&val ){
        static_cast<Base *>(this)->setReady( std::forward<decltype(val)>(val) );
      });
    }
 
  private:
    AsyncOpRef<Result> _nestedPipeline;
  };
 
  namespace detail {
    //A async result that is ready right away
    template <typename T>
    struct ReadyResult : public zyppng::AsyncOp< T >
    {
      ReadyResult( T &&val ) {
        this->setReady( std::move(val) );
      }
    };
  }

  template <typename T, bool isAsync = true>
  std::conditional_t<isAsync, AsyncOpRef<T>, T> makeReadyResult ( T && result ) {
    if constexpr ( isAsync ) {
      return std::make_shared<detail::ReadyResult<T>>( std::forward<T>(result) );
    } else {
      return result;
    }
  }
 
}
 
 
 
#endif