fiber_driver.hpp

Go to the documentation of this file.

 
#ifndef LELY_COAPP_FIBER_DRIVER_HPP_
#define LELY_COAPP_FIBER_DRIVER_HPP_
 
#include <lely/coapp/driver.hpp>
#include <lely/ev/fiber_exec.hpp>
#include <lely/ev/strand.hpp>
 
#include <utility>
 
namespace lely {
 
namespace canopen {
 
namespace detail {

class FiberDriverBase {
 protected:
  FiberDriverBase(ev_exec_t* exec);
 
  ev::FiberThread thrd;
  ev::FiberExecutor exec;
  ev::Strand strand;
};
 
}  // namespace detail

class FiberDriver : detail::FiberDriverBase, public BasicDriver {
 public:
  explicit FiberDriver(ev_exec_t* exec, AsyncMaster& master, uint8_t id);

  explicit FiberDriver(AsyncMaster& master, uint8_t id)
      : FiberDriver(nullptr, master, id) {}

  ev::Executor
  GetStrand() const noexcept {
    return strand;
  }

  template <class F, class... Args>
  void
  Defer(F&& f, Args&&... args) {
    GetStrand().post(::std::forward<F>(f), ::std::forward<Args>(args)...);
  }

  template <class T>
  T
  Wait(SdoFuture<T> f) {
    fiber_await(f);
    try {
      return f.get().value();
    } catch (const ev::future_not_ready& e) {
      util::throw_error_code("Wait", ::std::errc::operation_canceled);
    }
  }

  template <class T>
  typename ::std::enable_if<!::std::is_void<T>::value, T>::type
  Wait(SdoFuture<T> f, ::std::error_code& ec) {
    fiber_await(f);
    try {
      return f.get().value();
    } catch (const ::std::system_error& e) {
      ec = e.code();
    } catch (const ev::future_not_ready& e) {
      ec = ::std::make_error_code(::std::errc::operation_canceled);
    }
  }

  void Wait(SdoFuture<void> f, ::std::error_code& ec);

  void USleep(uint_least64_t usec);

  void USleep(uint_least64_t usec, ::std::error_code& ec);
};
 
}  // namespace canopen
 
}  // namespace lely
 
#endif  // LELY_COAPP_FIBER_DRIVER_HPP_