co_can.hpp

Go to the documentation of this file.

 
#ifndef LELY_IO2_CO_CAN_HPP_
#define LELY_IO2_CO_CAN_HPP_
 
#include <lely/io2/can.hpp>
#include <lely/util/coroutine.hpp>
 
namespace lely {
namespace io {

class CoCanChannelRead : public io_can_chan_read, public util::Coroutine {
 public:
  explicit CoCanChannelRead(can_msg* msg, can_err* err = nullptr,
                            ::std::chrono::nanoseconds* dp = nullptr,
                            ev_exec_t* exec = nullptr) noexcept
      : io_can_chan_read IO_CAN_CHAN_READ_INIT(
            msg, err, dp ? &ts_ : nullptr, exec,
            [](ev_task* task) noexcept {
              auto read = io_can_chan_read_from_task(task);
              auto result = read->r.result;
              ::std::error_code ec;
              if (result == -1) ec = util::make_error_code(read->r.errc);
              auto self = static_cast<CoCanChannelRead*>(read);
              if (self->dp_) *self->dp_ = util::from_timespec(self->ts_);
              (*self)(result, ec);
            }),
        dp_(dp) {}
 
  virtual ~CoCanChannelRead() = default;
 
  operator ev_task&() & noexcept { return task; }

  ev::Executor
  get_executor() const noexcept {
    return ev::Executor(task.exec);
  }

  virtual void operator()(int result, ::std::error_code ec) noexcept = 0;
 
 private:
  timespec ts_{0, 0};
  ::std::chrono::nanoseconds* dp_{nullptr};
};

class CoCanChannelWrite : public io_can_chan_write, public util::Coroutine {
 public:
  CoCanChannelWrite(const can_msg* msg, ev_exec_t* exec = nullptr) noexcept
      : io_can_chan_write
        IO_CAN_CHAN_WRITE_INIT(msg, exec, [](ev_task* task) noexcept {
          auto write = io_can_chan_write_from_task(task);
          ::std::error_code ec = util::make_error_code(write->errc);
          auto self = static_cast<CoCanChannelWrite*>(write);
          (*self)(ec);
        }) {}
 
  virtual ~CoCanChannelWrite() = default;
 
  operator ev_task&() & noexcept { return task; }

  ev::Executor
  get_executor() const noexcept {
    return ev::Executor(task.exec);
  }

  virtual void operator()(::std::error_code ec) noexcept = 0;
};
 
}  // namespace io
}  // namespace lely
 
#endif  // !LELY_IO2_CO_CAN_HPP_