loop_driver.hpp

Go to the documentation of this file.

 
#ifndef LELY_COAPP_LOOP_DRIVER_HPP_
#define LELY_COAPP_LOOP_DRIVER_HPP_
 
#include <lely/coapp/driver.hpp>
#include <lely/ev/loop.hpp>
#include <lely/ev/strand.hpp>
 
#include <memory>
#include <utility>
 
namespace lely {
 
namespace canopen {
 
namespace detail {

class LoopDriverBase {
 protected:
  ev::Loop loop{};
  ev::Strand strand{loop.get_executor()};
};
 
}  // namespace detail

class LoopDriver : detail::LoopDriverBase, public BasicDriver {
 public:
  explicit LoopDriver(AsyncMaster& master, uint8_t id);

  ~LoopDriver();

  ev::Loop&
  GetLoop() noexcept {
    return loop;
  }

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

  void Join();

  ev::Future<void, void> AsyncStoppped() noexcept;

  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) {
    GetLoop().wait(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) {
    GetLoop().wait(f, ec);
    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);
    }
    return T{};
  }

  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);

  template <class T>
  T
  RunRead(uint16_t idx, uint8_t subidx) {
    return Wait(AsyncRead<T>(idx, subidx));
  }

  template <class T>
  T
  RunRead(uint16_t idx, uint8_t subidx, ::std::error_code& ec) {
    return Wait(AsyncRead<T>(idx, subidx), ec);
  }

  template <class T>
  T
  RunRead(uint16_t idx, uint8_t subidx,
          const ::std::chrono::milliseconds& timeout) {
    return Wait(AsyncRead<T>(idx, subidx, timeout));
  }

  template <class T>
  T
  RunRead(uint16_t idx, uint8_t subidx,
          const ::std::chrono::milliseconds& timeout, ::std::error_code& ec) {
    return Wait(AsyncRead<T>(idx, subidx, timeout), ec);
  }

  template <class T>
  void
  RunWrite(uint16_t idx, uint8_t subidx, T&& value) {
    Wait(AsyncWrite(idx, subidx, ::std::forward<T>(value)));
  }

  template <class T>
  void
  RunWrite(uint16_t idx, uint8_t subidx, T&& value, ::std::error_code& ec) {
    Wait(AsyncWrite(idx, subidx, ::std::forward<T>(value)), ec);
  }

  template <class T>
  void
  RunWrite(uint16_t idx, uint8_t subidx, T&& value,
           const ::std::chrono::milliseconds& timeout) {
    Wait(AsyncWrite(idx, subidx, ::std::forward<T>(value), timeout));
  }

  template <class T>
  void
  RunWrite(uint16_t idx, uint8_t subidx, T&& value,
           const ::std::chrono::milliseconds& timeout, ::std::error_code& ec) {
    Wait(AsyncWrite(idx, subidx, ::std::forward<T>(value), timeout), ec);
  }
 
 private:
  struct Impl_;
  ::std::unique_ptr<Impl_> impl_;
};
 
}  // namespace canopen
 
}  // namespace lely
 
#endif  // LELY_COAPP_LOOP_DRIVER_HPP_