lss_master.hpp

Go to the documentation of this file.

 
#ifndef LELY_COAPP_LSS_MASTER_HPP_
#define LELY_COAPP_LSS_MASTER_HPP_
 
#include <lely/coapp/node.hpp>
#include <lely/libc/functional.hpp>
#include <lely/libc/type_traits.hpp>
 
#include <chrono>
#include <memory>
#include <utility>
 
namespace lely {
 
namespace canopen {

template <class T>
using LssPromise = ev::Promise<T, ::std::exception_ptr>;

template <class T>
using LssFuture = ev::Future<T, ::std::exception_ptr>;

struct LssAddress {
  LssAddress(uint32_t vendor_id_ = 0, uint32_t product_code_ = 0,
             uint32_t revision_ = 0, uint32_t serial_nr_ = 0)
      : vendor_id(vendor_id_),
        product_code(product_code_),
        revision(revision_),
        serial_nr(serial_nr_) {}

  uint32_t vendor_id;
  uint32_t product_code;
  uint32_t revision;
  uint32_t serial_nr;
};

enum class LssState {
  WAITING = 0,
  CONFIG = 1
};
 
class LssMaster;
 
namespace detail {
 
class LssRequestBase : public ev_task {
  friend class canopen::LssMaster;
 
 public:
  explicit LssRequestBase(ev_exec_t* exec)
      : ev_task EV_TASK_INIT(exec, [](ev_task* task) noexcept {
          (*static_cast<LssRequestBase*>(task))();
        }) {}
 
  LssRequestBase(const LssRequestBase&) = delete;
  LssRequestBase& operator=(const LssRequestBase&) = delete;
 
  virtual ~LssRequestBase() = default;

  ev::Executor
  GetExecutor() const noexcept {
    return ev::Executor(ev_task::exec);
  }

  ::std::error_code ec{};
 
 private:
  virtual void operator()() noexcept = 0;
 
  virtual void OnRequest(void* data) noexcept = 0;
};
 
class LssSwitchRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;

  LssState state{LssState::WAITING};
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssSwitchSelectiveRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;

  LssAddress address{0, 0, 0, 0};
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssSetIdRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;

  uint8_t id{0};
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssSetBitrateRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;

  int bitrate{0};
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssSwitchBitrateRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;

  int delay{0};
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssStoreRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssGetNumberRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;

  uint32_t number{0};
};
 
class LssGetVendorIdRequestBase : public LssGetNumberRequestBase {
 public:
  using LssGetNumberRequestBase::LssGetNumberRequestBase;
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssGetProductCodeRequestBase : public LssGetNumberRequestBase {
 public:
  using LssGetNumberRequestBase::LssGetNumberRequestBase;
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssGetRevisionRequestBase : public LssGetNumberRequestBase {
 public:
  using LssGetNumberRequestBase::LssGetNumberRequestBase;
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssGetSerialNrRequestBase : public LssGetNumberRequestBase {
 public:
  using LssGetNumberRequestBase::LssGetNumberRequestBase;
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssGetIdRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;

  uint8_t id{0};
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssIdNonConfigRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssScanRequestBase : public LssRequestBase {
 public:
  using LssRequestBase::LssRequestBase;

  LssAddress address{0, 0, 0, 0};
};
 
class LssSlowscanRequestBase : public LssScanRequestBase {
 public:
  using LssScanRequestBase::LssScanRequestBase;

  LssAddress lo{0, 0, 0, 0};
  LssAddress hi{0, 0, 0, 0};
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
class LssFastscanRequestBase : public LssScanRequestBase {
 public:
  using LssScanRequestBase::LssScanRequestBase;

  LssAddress mask{0, 0, 0, 0};
 
 private:
  void OnRequest(void* data) noexcept final;
};
 
}  // namespace detail

class LssSwitchRequest : public detail::LssSwitchRequestBase {
 public:
  using Signature = void(::std::error_code ec);

  template <class F>
  explicit LssSwitchRequest(ev_exec_t* exec, F&& con)
      : detail::LssSwitchRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssSwitchRequest(F&& con)
      : LssSwitchRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec);
  }
 
  ::std::function<Signature> con_;
};

class LssSwitchSelectiveRequest : public detail::LssSwitchSelectiveRequestBase {
 public:
  using Signature = void(::std::error_code ec);

  template <class F>
  explicit LssSwitchSelectiveRequest(ev_exec_t* exec, F&& con)
      : detail::LssSwitchSelectiveRequestBase(exec),
        con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssSwitchSelectiveRequest(F&& con)
      : LssSwitchSelectiveRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec);
  }
 
  ::std::function<Signature> con_;
};

class LssSetIdRequest : public detail::LssSetIdRequestBase {
 public:
  using Signature = void(::std::error_code ec);

  template <class F>
  explicit LssSetIdRequest(ev_exec_t* exec, F&& con)
      : detail::LssSetIdRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssSetIdRequest(F&& con)
      : LssSetIdRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec);
  }
 
  ::std::function<Signature> con_;
};

class LssSetBitrateRequest : public detail::LssSetBitrateRequestBase {
 public:
  using Signature = void(::std::error_code ec);

  template <class F>
  explicit LssSetBitrateRequest(ev_exec_t* exec, F&& con)
      : detail::LssSetBitrateRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssSetBitrateRequest(F&& con)
      : LssSetBitrateRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec);
  }
 
  ::std::function<Signature> con_;
};

class LssSwitchBitrateRequest : public detail::LssSwitchBitrateRequestBase {
 public:
  using Signature = void(::std::error_code ec);

  template <class F>
  explicit LssSwitchBitrateRequest(ev_exec_t* exec, F&& con)
      : detail::LssSwitchBitrateRequestBase(exec),
        con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssSwitchBitrateRequest(F&& con)
      : LssSwitchBitrateRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec);
  }
 
  ::std::function<Signature> con_;
};

class LssStoreRequest : public detail::LssStoreRequestBase {
 public:
  using Signature = void(::std::error_code ec);

  template <class F>
  explicit LssStoreRequest(ev_exec_t* exec, F&& con)
      : detail::LssStoreRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssStoreRequest(F&& con)
      : LssStoreRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec);
  }
 
  ::std::function<Signature> con_;
};

class LssGetVendorIdRequest : public detail::LssGetVendorIdRequestBase {
 public:
  using Signature = void(::std::error_code ec, uint32_t number);

  template <class F>
  explicit LssGetVendorIdRequest(ev_exec_t* exec, F&& con)
      : detail::LssGetVendorIdRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssGetVendorIdRequest(F&& con)
      : LssGetVendorIdRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec, number);
  }
 
  ::std::function<Signature> con_;
};

class LssGetProductCodeRequest : public detail::LssGetProductCodeRequestBase {
 public:
  using Signature = void(::std::error_code ec, uint32_t number);

  template <class F>
  explicit LssGetProductCodeRequest(ev_exec_t* exec, F&& con)
      : detail::LssGetProductCodeRequestBase(exec),
        con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssGetProductCodeRequest(F&& con)
      : LssGetProductCodeRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec, number);
  }
 
  ::std::function<Signature> con_;
};

class LssGetRevisionRequest : public detail::LssGetRevisionRequestBase {
 public:
  using Signature = void(::std::error_code ec, uint32_t number);

  template <class F>
  explicit LssGetRevisionRequest(ev_exec_t* exec, F&& con)
      : detail::LssGetRevisionRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssGetRevisionRequest(F&& con)
      : LssGetRevisionRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec, number);
  }
 
  ::std::function<Signature> con_;
};

class LssGetSerialNrRequest : public detail::LssGetSerialNrRequestBase {
 public:
  using Signature = void(::std::error_code ec, uint32_t number);

  template <class F>
  explicit LssGetSerialNrRequest(ev_exec_t* exec, F&& con)
      : detail::LssGetSerialNrRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssGetSerialNrRequest(F&& con)
      : LssGetSerialNrRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec, number);
  }
 
  ::std::function<Signature> con_;
};

class LssGetIdRequest : public detail::LssGetIdRequestBase {
 public:
  using Signature = void(::std::error_code ec, uint8_t id);

  template <class F>
  explicit LssGetIdRequest(ev_exec_t* exec, F&& con)
      : detail::LssGetIdRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssGetIdRequest(F&& con)
      : LssGetIdRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec, id);
  }
 
  ::std::function<Signature> con_;
};

class LssIdNonConfigRequest : public detail::LssStoreRequestBase {
 public:
  using Signature = void(::std::error_code ec, bool found);

  template <class F>
  explicit LssIdNonConfigRequest(ev_exec_t* exec, F&& con)
      : detail::LssStoreRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssIdNonConfigRequest(F&& con)
      : LssIdNonConfigRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    bool found = !ec;
    // A timeout means no slave was found, but is otherwise not an error.
    if (ec == ::std::errc::timed_out) ec.clear();
    if (con_) con_(ec, found);
  }
 
  ::std::function<Signature> con_;
};

class LssSlowscanRequest : public detail::LssSlowscanRequestBase {
 public:
  using Signature = void(::std::error_code ec, LssAddress address);

  template <class F>
  explicit LssSlowscanRequest(ev_exec_t* exec, F&& con)
      : detail::LssSlowscanRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssSlowscanRequest(F&& con)
      : LssSlowscanRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec, address);
  }
 
  ::std::function<Signature> con_;
};

class LssFastscanRequest : public detail::LssFastscanRequestBase {
 public:
  using Signature = void(::std::error_code ec, LssAddress address);

  template <class F>
  explicit LssFastscanRequest(ev_exec_t* exec, F&& con)
      : detail::LssFastscanRequestBase(exec), con_(::std::forward<F>(con)) {}

  template <class F>
  explicit LssFastscanRequest(F&& con)
      : LssFastscanRequest(nullptr, ::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    if (con_) con_(ec, address);
  }
 
  ::std::function<Signature> con_;
};
 
namespace detail {
 
template <class F>
class LssSwitchRequestWrapper : public LssSwitchRequestBase {
 public:
  explicit LssSwitchRequestWrapper(ev_exec_t* exec, LssState state, F&& con)
      : LssSwitchRequestBase(exec), con_(::std::forward<F>(con)) {
    this->state = state;
  }
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssSwitchSelectiveRequestWrapper : public LssSwitchSelectiveRequestBase {
 public:
  explicit LssSwitchSelectiveRequestWrapper(ev_exec_t* exec,
                                            const LssAddress& address, F&& con)
      : LssSwitchSelectiveRequestBase(exec), con_(::std::forward<F>(con)) {
    this->address = address;
  }
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssSetIdRequestWrapper : public LssSetIdRequestBase {
 public:
  explicit LssSetIdRequestWrapper(ev_exec_t* exec, uint8_t id, F&& con)
      : LssSetIdRequestBase(exec), con_(::std::forward<F>(con)) {
    this->id = id;
  }
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssSetBitrateRequestWrapper : public LssSetBitrateRequestBase {
 public:
  explicit LssSetBitrateRequestWrapper(ev_exec_t* exec, int bitrate, F&& con)
      : LssSetBitrateRequestBase(exec), con_(::std::forward<F>(con)) {
    this->bitrate = bitrate;
  }
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssSwitchBitrateRequestWrapper : public LssSwitchBitrateRequestBase {
 public:
  explicit LssSwitchBitrateRequestWrapper(ev_exec_t* exec, int delay, F&& con)
      : LssSwitchBitrateRequestBase(exec), con_(::std::forward<F>(con)) {
    this->delay = delay;
  }
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssStoreRequestWrapper : public LssStoreRequestBase {
 public:
  explicit LssStoreRequestWrapper(ev_exec_t* exec, F&& con)
      : LssStoreRequestBase(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssGetVendorIdRequestWrapper : public LssGetVendorIdRequestBase {
 public:
  explicit LssGetVendorIdRequestWrapper(ev_exec_t* exec, F&& con)
      : LssGetVendorIdRequestBase(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec, number);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssGetProductCodeRequestWrapper : public LssGetProductCodeRequestBase {
 public:
  explicit LssGetProductCodeRequestWrapper(ev_exec_t* exec, F&& con)
      : LssGetProductCodeRequestBase(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec, number);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssGetRevisionRequestWrapper : public LssGetRevisionRequestBase {
 public:
  explicit LssGetRevisionRequestWrapper(ev_exec_t* exec, F&& con)
      : LssGetRevisionRequestBase(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec, number);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssGetSerialNrRequestWrapper : public LssGetSerialNrRequestBase {
 public:
  explicit LssGetSerialNrRequestWrapper(ev_exec_t* exec, F&& con)
      : LssGetSerialNrRequestBase(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec, number);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssGetIdRequestWrapper : public LssGetIdRequestBase {
 public:
  explicit LssGetIdRequestWrapper(ev_exec_t* exec, F&& con)
      : LssGetIdRequestBase(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec, id);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssIdNonConfigRequestWrapper : public LssIdNonConfigRequestBase {
 public:
  explicit LssIdNonConfigRequestWrapper(ev_exec_t* exec, F&& con)
      : LssIdNonConfigRequestBase(exec), con_(::std::forward<F>(con)) {}
 
 private:
  void
  operator()() noexcept final {
    bool found = !ec;
    // A timeout means no slave was found, but is otherwise not an error.
    if (ec == ::std::errc::timed_out) ec.clear();
    compat::invoke(::std::move(con_), ec, found);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssSlowscanRequestWrapper : public LssSlowscanRequestBase {
 public:
  explicit LssSlowscanRequestWrapper(ev_exec_t* exec, const LssAddress& lo,
                                     const LssAddress& hi, F&& con)
      : LssSlowscanRequestBase(exec), con_(::std::forward<F>(con)) {
    this->lo = lo;
    this->hi = hi;
  }
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec, address);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
template <class F>
class LssFastscanRequestWrapper : public LssFastscanRequestBase {
 public:
  explicit LssFastscanRequestWrapper(ev_exec_t* exec, const LssAddress& address,
                                     const LssAddress& mask, F&& con)
      : LssFastscanRequestBase(exec), con_(::std::forward<F>(con)) {
    this->address = address;
    this->mask = mask;
  }
 
 private:
  void
  operator()() noexcept final {
    compat::invoke(::std::move(con_), ec, address);
    delete this;
  }
 
  typename ::std::decay<F>::type con_;
};
 
}  // namespace detail

template <class F>
// clang-format off
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code>::value,
    detail::LssSwitchRequestWrapper<F>*>::type
make_lss_switch_request(ev_exec_t* exec, LssState state, F&& con) {
  // clang-format on
  return new detail::LssSwitchRequestWrapper<F>(exec, state,
                                                ::std::forward<F>(con));
}

template <class F>
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code>::value,
    detail::LssSwitchSelectiveRequestWrapper<F>*>::type
make_lss_switch_selective_request(ev_exec_t* exec, const LssAddress& address,
                                  F&& con) {
  return new detail::LssSwitchSelectiveRequestWrapper<F>(
      exec, address, ::std::forward<F>(con));
}

template <class F>
// clang-format off
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code>::value,
    detail::LssSetIdRequestWrapper<F>*>::type
make_lss_set_id_request(ev_exec_t* exec, uint8_t id, F&& con) {
  // clang-format on
  return new detail::LssSetIdRequestWrapper<F>(exec, id,
                                               ::std::forward<F>(con));
}

template <class F>
// clang-format off
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code>::value,
    detail::LssSetBitrateRequestWrapper<F>*>::type
make_lss_set_bitrate_request(ev_exec_t* exec, int bitrate, F&& con) {
  // clang-format on
  return new detail::LssSetBitrateRequestWrapper<F>(exec, bitrate,
                                                    ::std::forward<F>(con));
}

template <class F>
// clang-format off
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code>::value,
    detail::LssSwitchBitrateRequestWrapper<F>*>::type
make_lss_switch_bitrate_request(ev_exec_t* exec, int delay, F&& con) {
  // clang-format on
  return new detail::LssSwitchBitrateRequestWrapper<F>(exec, delay,
                                                       ::std::forward<F>(con));
}

template <class F>
// clang-format off
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code>::value,
    detail::LssStoreRequestWrapper<F>*>::type
make_lss_store_request(ev_exec_t* exec, F&& con) {
  // clang-format on
  return new detail::LssStoreRequestWrapper<F>(exec, ::std::forward<F>(con));
}

template <class F>
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code, uint32_t>::value,
    detail::LssGetVendorIdRequestWrapper<F>*>::type
make_lss_get_vendor_id_request(ev_exec_t* exec, F&& con) {
  return new detail::LssGetVendorIdRequestWrapper<F>(exec,
                                                     ::std::forward<F>(con));
}

template <class F>
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code, uint32_t>::value,
    detail::LssGetProductCodeRequestWrapper<F>*>::type
make_lss_get_product_code_request(ev_exec_t* exec, F&& con) {
  return new detail::LssGetProductCodeRequestWrapper<F>(exec,
                                                        ::std::forward<F>(con));
}

template <class F>
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code, uint32_t>::value,
    detail::LssGetRevisionRequestWrapper<F>*>::type
make_lss_get_revision_request(ev_exec_t* exec, F&& con) {
  return new detail::LssGetRevisionRequestWrapper<F>(exec,
                                                     ::std::forward<F>(con));
}

template <class F>
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code, uint32_t>::value,
    detail::LssGetSerialNrRequestWrapper<F>*>::type
make_lss_get_serial_nr_request(ev_exec_t* exec, F&& con) {
  return new detail::LssGetSerialNrRequestWrapper<F>(exec,
                                                     ::std::forward<F>(con));
}

template <class F>
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code, uint8_t>::value,
    detail::LssGetIdRequestWrapper<F>*>::type
make_lss_get_id_request(ev_exec_t* exec, F&& con) {
  return new detail::LssGetIdRequestWrapper<F>(exec, ::std::forward<F>(con));
}

template <class F>
// clang-format off
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code, bool>::value,
    detail::LssIdNonConfigRequestWrapper<F>*>::type
make_lss_id_non_config_request(ev_exec_t* exec, F&& con) {
  // clang-format on
  return new detail::LssIdNonConfigRequestWrapper<F>(exec,
                                                     ::std::forward<F>(con));
}

template <class F>
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code, LssAddress>::value,
    detail::LssSlowscanRequestWrapper<F>*>::type
make_lss_slowscan_request(ev_exec_t* exec, const LssAddress& lo,
                          const LssAddress& hi, F&& con) {
  return new detail::LssSlowscanRequestWrapper<F>(exec, lo, hi,
                                                  ::std::forward<F>(con));
}

template <class F>
inline typename ::std::enable_if<
    compat::is_invocable<F, ::std::error_code, LssAddress>::value,
    detail::LssFastscanRequestWrapper<F>*>::type
make_lss_fastscan_request(ev_exec_t* exec, const LssAddress& address,
                          const LssAddress& mask, F&& con) {
  return new detail::LssFastscanRequestWrapper<F>(exec, address, mask,
                                                  ::std::forward<F>(con));
}

class LssMaster : protected util::BasicLockable {
  friend class detail::LssSwitchRequestBase;
  friend class detail::LssSwitchSelectiveRequestBase;
  friend class detail::LssSetIdRequestBase;
  friend class detail::LssSetBitrateRequestBase;
  friend class detail::LssSwitchBitrateRequestBase;
  friend class detail::LssStoreRequestBase;
  friend class detail::LssGetVendorIdRequestBase;
  friend class detail::LssGetProductCodeRequestBase;
  friend class detail::LssGetRevisionRequestBase;
  friend class detail::LssGetSerialNrRequestBase;
  friend class detail::LssGetIdRequestBase;
  friend class detail::LssIdNonConfigRequestBase;
  friend class detail::LssSlowscanRequestBase;
  friend class detail::LssFastscanRequestBase;
 
 public:
  explicit LssMaster(ev_exec_t* exec, Node& node,
                     io::CanControllerBase* ctrl = nullptr);

  explicit LssMaster(Node& node, io::CanControllerBase* ctrl = nullptr)
      : LssMaster(nullptr, node, ctrl) {}
 
  LssMaster(const LssMaster&) = delete;
  LssMaster& operator=(const LssMaster&) = delete;
 
  virtual ~LssMaster();

  ev::Executor GetExecutor() const noexcept;

  Node& GetNode() const noexcept;

  io::CanControllerBase* GetController() const noexcept;

  ::std::chrono::microseconds GetInhibit() const;

  void SetInhibit(const ::std::chrono::microseconds& inhibit);

  ::std::chrono::milliseconds GetTimeout() const;

  void SetTimeout(const ::std::chrono::milliseconds& timeout);

  void
  SubmitSwitch(detail::LssSwitchRequestBase& req,
               LssState state = LssState::WAITING) {
    req.state = state;
    Submit(req);
  }

  template <class F>
  void
  SubmitSwitch(ev_exec_t* exec, LssState state, F&& con) {
    Submit(*make_lss_switch_request(exec, state, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitSwitch(LssState state, F&& con) {
    SubmitSwitch(nullptr, state, ::std::forward<F>(con));
  }

  bool
  CancelSwitch(detail::LssSwitchRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortSwitch(detail::LssSwitchRequestBase& req) {
    return Abort(req);
  }

  LssFuture<void> AsyncSwitch(ev_exec_t* exec,
                              LssState state = LssState::WAITING,
                              detail::LssSwitchRequestBase** preq = nullptr);

  LssFuture<void>
  AsyncSwitch(LssState state = LssState::WAITING,
              detail::LssSwitchRequestBase** preq = nullptr) {
    return AsyncSwitch(nullptr, state, preq);
  }

  void
  SubmitSwitchSelective(detail::LssSwitchSelectiveRequestBase& req,
                        const LssAddress& address) {
    req.address = address;
    Submit(req);
  }

  template <class F>
  void
  SubmitSwitchSelective(ev_exec_t* exec, const LssAddress& address, F&& con) {
    Submit(*make_lss_switch_selective_request(exec, address,
                                              ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitSwitchSelective(const LssAddress& address, F&& con) {
    SubmitSwitchSelective(nullptr, address, ::std::forward<F>(con));
  }

  bool
  CancelSwitchSelective(detail::LssSwitchSelectiveRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortSwitchSelective(detail::LssSwitchSelectiveRequestBase& req) {
    return Abort(req);
  }

  LssFuture<void> AsyncSwitchSelective(
      ev_exec_t* exec, const LssAddress& address,
      detail::LssSwitchSelectiveRequestBase** preq = nullptr);

  LssFuture<void>
  AsyncSwitchSelective(const LssAddress& address,
                       detail::LssSwitchSelectiveRequestBase** preq = nullptr) {
    return AsyncSwitchSelective(nullptr, address, preq);
  }

  void
  SubmitSetId(detail::LssSetIdRequestBase& req, uint8_t id) {
    req.id = id;
    Submit(req);
  }

  template <class F>
  void
  SubmitSetId(ev_exec_t* exec, uint8_t id, F&& con) {
    Submit(*make_lss_set_id_request(exec, id, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitSetId(uint8_t id, F&& con) {
    SubmitSetId(nullptr, id, ::std::forward<F>(con));
  }

  bool
  CancelSetId(detail::LssSetIdRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortSetId(detail::LssSetIdRequestBase& req) {
    return Abort(req);
  }

  LssFuture<void> AsyncSetId(ev_exec_t* exec, uint8_t id,
                             detail::LssSetIdRequestBase** preq = nullptr);

  LssFuture<void>
  AsyncSetId(uint8_t id, detail::LssSetIdRequestBase** preq = nullptr) {
    return AsyncSetId(nullptr, id, preq);
  }

  void
  SubmitSetBitrate(detail::LssSetBitrateRequestBase& req, int bitrate) {
    req.bitrate = bitrate;
    Submit(req);
  }

  template <class F>
  void
  SubmitSetBitrate(ev_exec_t* exec, int bitrate, F&& con) {
    Submit(
        *make_lss_set_bitrate_request(exec, bitrate, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitSetBitrate(int bitrate, F&& con) {
    SubmitSetBitrate(nullptr, bitrate, ::std::forward<F>(con));
  }

  bool
  CancelSetBitrate(detail::LssSetBitrateRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortSetBitrate(detail::LssSetBitrateRequestBase& req) {
    return Abort(req);
  }

  LssFuture<void> AsyncSetBitrate(
      ev_exec_t* exec, int bitrate,
      detail::LssSetBitrateRequestBase** preq = nullptr);

  LssFuture<void>
  AsyncSetBitrate(int bitrate,
                  detail::LssSetBitrateRequestBase** preq = nullptr) {
    return AsyncSetBitrate(nullptr, bitrate, preq);
  }

  void
  SubmitSwitchBitrate(detail::LssSwitchBitrateRequestBase& req, int delay) {
    req.delay = delay;
    Submit(req);
  }

  template <class F>
  void
  SubmitSwitchBitrate(ev_exec_t* exec, int delay, F&& con) {
    Submit(
        *make_lss_switch_bitrate_request(exec, delay, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitSwitchBitrate(int delay, F&& con) {
    SubmitSwitchBitrate(nullptr, delay, ::std::forward<F>(con));
  }

  bool
  CancelSwitchBitrate(detail::LssSwitchBitrateRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortSwitchBitrate(detail::LssSwitchBitrateRequestBase& req) {
    return Abort(req);
  }

  LssFuture<void> AsyncSwitchBitrate(
      ev_exec_t* exec, int delay,
      detail::LssSwitchBitrateRequestBase** preq = nullptr);

  LssFuture<void>
  AsyncSwitchBitrate(int delay,
                     detail::LssSwitchBitrateRequestBase** preq = nullptr) {
    return AsyncSwitchBitrate(nullptr, delay, preq);
  }

  void
  SubmitStore(detail::LssStoreRequestBase& req) {
    Submit(req);
  }

  template <class F>
  void
  SubmitStore(ev_exec_t* exec, F&& con) {
    Submit(*make_lss_store_request(exec, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitStore(F&& con) {
    SubmitStore(nullptr, ::std::forward<F>(con));
  }

  bool
  CancelStore(detail::LssStoreRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortStore(detail::LssStoreRequestBase& req) {
    return Abort(req);
  }

  LssFuture<void> AsyncStore(ev_exec_t* exec,
                             detail::LssStoreRequestBase** preq = nullptr);

  LssFuture<void>
  AsyncStore(detail::LssStoreRequestBase** preq = nullptr) {
    return AsyncStore(nullptr, preq);
  }

  void
  SubmitGetVendorId(detail::LssGetVendorIdRequestBase& req) {
    Submit(req);
  }

  template <class F>
  void
  SubmitGetVendorId(ev_exec_t* exec, F&& con) {
    Submit(*make_lss_get_vendor_id_request(exec, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitGetVendorId(F&& con) {
    SubmitGetVendorId(nullptr, ::std::forward<F>(con));
  }

  bool
  CancelGetVendorId(detail::LssGetVendorIdRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortGetVendorId(detail::LssGetVendorIdRequestBase& req) {
    return Abort(req);
  }

  LssFuture<uint32_t> AsyncGetVendorId(
      ev_exec_t* exec, detail::LssGetVendorIdRequestBase** preq = nullptr);

  LssFuture<uint32_t>
  AsyncGetVendorId(detail::LssGetVendorIdRequestBase** preq = nullptr) {
    return AsyncGetVendorId(nullptr, preq);
  }

  void
  SubmitGetProductCode(detail::LssGetProductCodeRequestBase& req) {
    Submit(req);
  }

  template <class F>
  void
  SubmitGetProductCode(ev_exec_t* exec, F&& con) {
    Submit(*make_lss_get_product_code_request(exec, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitGetProductCode(F&& con) {
    SubmitGetProductCode(nullptr, ::std::forward<F>(con));
  }

  bool
  CancelGetProductCode(detail::LssGetProductCodeRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortGetProductCode(detail::LssGetProductCodeRequestBase& req) {
    return Abort(req);
  }

  LssFuture<uint32_t> AsyncGetProductCode(
      ev_exec_t* exec, detail::LssGetProductCodeRequestBase** preq = nullptr);

  LssFuture<uint32_t>
  AsyncGetProductCode(detail::LssGetProductCodeRequestBase** preq = nullptr) {
    return AsyncGetProductCode(nullptr, preq);
  }

  void
  SubmitGetRevision(detail::LssGetRevisionRequestBase& req) {
    Submit(req);
  }

  template <class F>
  void
  SubmitGetRevision(ev_exec_t* exec, F&& con) {
    Submit(*make_lss_get_revision_request(exec, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitGetRevision(F&& con) {
    SubmitGetRevision(nullptr, ::std::forward<F>(con));
  }

  bool
  CancelGetRevision(detail::LssGetRevisionRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortGetRevision(detail::LssGetRevisionRequestBase& req) {
    return Abort(req);
  }

  LssFuture<uint32_t> AsyncGetRevision(
      ev_exec_t* exec, detail::LssGetRevisionRequestBase** preq = nullptr);

  LssFuture<uint32_t>
  AsyncGetRevision(detail::LssGetRevisionRequestBase** preq = nullptr) {
    return AsyncGetRevision(nullptr, preq);
  }

  void
  SubmitGetSerialNr(detail::LssGetSerialNrRequestBase& req) {
    Submit(req);
  }

  template <class F>
  void
  SubmitGetSerialNr(ev_exec_t* exec, F&& con) {
    Submit(*make_lss_get_serial_nr_request(exec, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitGetSerialNr(F&& con) {
    SubmitGetSerialNr(nullptr, ::std::forward<F>(con));
  }

  bool
  CancelGetSerialNr(detail::LssGetSerialNrRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortGetSerialNr(detail::LssGetSerialNrRequestBase& req) {
    return Abort(req);
  }

  LssFuture<uint32_t> AsyncGetSerialNr(
      ev_exec_t* exec, detail::LssGetSerialNrRequestBase** preq = nullptr);

  LssFuture<uint32_t>
  AsyncGetSerialNr(detail::LssGetSerialNrRequestBase** preq = nullptr) {
    return AsyncGetSerialNr(nullptr, preq);
  }

  void
  SubmitGetId(detail::LssGetIdRequestBase& req) {
    Submit(req);
  }

  template <class F>
  void
  SubmitGetId(ev_exec_t* exec, F&& con) {
    Submit(*make_lss_get_id_request(exec, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitGetId(F&& con) {
    SubmitGetId(nullptr, ::std::forward<F>(con));
  }

  bool
  CancelGetId(detail::LssGetIdRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortGetId(detail::LssGetIdRequestBase& req) {
    return Abort(req);
  }

  LssFuture<uint8_t> AsyncGetId(ev_exec_t* exec,
                                detail::LssGetIdRequestBase** preq = nullptr);

  LssFuture<uint8_t>
  AsyncGetId(detail::LssGetIdRequestBase** preq = nullptr) {
    return AsyncGetId(nullptr, preq);
  }

  void
  SubmitIdNonConfig(detail::LssIdNonConfigRequestBase& req) {
    Submit(req);
  }

  template <class F>
  void
  SubmitIdNonConfig(ev_exec_t* exec, F&& con) {
    Submit(*make_lss_id_non_config_request(exec, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitIdNonConfig(F&& con) {
    SubmitIdNonConfig(nullptr, ::std::forward<F>(con));
  }

  bool
  CancelIdNonConfig(detail::LssIdNonConfigRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortIdNonConfig(detail::LssIdNonConfigRequestBase& req) {
    return Abort(req);
  }

  LssFuture<bool> AsyncIdNonConfig(
      ev_exec_t* exec, detail::LssIdNonConfigRequestBase** preq = nullptr);

  LssFuture<bool>
  AsyncIdNonConfig(detail::LssIdNonConfigRequestBase** preq = nullptr) {
    return AsyncIdNonConfig(nullptr, preq);
  }

  void
  SubmitSlowscan(detail::LssSlowscanRequestBase& req, const LssAddress& lo,
                 const LssAddress& hi) {
    req.lo = lo;
    req.hi = hi;
    Submit(req);
  }

  template <class F>
  void
  SubmitSlowscan(ev_exec_t* exec, const LssAddress& lo, const LssAddress& hi,
                 F&& con) {
    Submit(*make_lss_slowscan_request(exec, lo, hi, ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitSlowscan(F&& con) {
    SubmitSlowscan(nullptr, ::std::forward<F>(con));
  }

  bool
  CancelSlowscan(detail::LssSlowscanRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortSlowscan(detail::LssSlowscanRequestBase& req) {
    return Abort(req);
  }

  LssFuture<LssAddress> AsyncSlowscan(
      ev_exec_t* exec, const LssAddress& lo, const LssAddress& hi,
      detail::LssSlowscanRequestBase** preq = nullptr);

  LssFuture<LssAddress>
  AsyncSlowscan(const LssAddress& lo, const LssAddress& hi,
                detail::LssSlowscanRequestBase** preq = nullptr) {
    return AsyncSlowscan(nullptr, lo, hi, preq);
  }

  void
  SubmitFastscan(detail::LssFastscanRequestBase& req, const LssAddress& address,
                 const LssAddress& mask) {
    req.address = address;
    req.mask = mask;
    Submit(req);
  }

  template <class F>
  void
  SubmitFastscan(ev_exec_t* exec, const LssAddress& address,
                 const LssAddress& mask, F&& con) {
    Submit(*make_lss_fastscan_request(exec, address, mask,
                                      ::std::forward<F>(con)));
  }

  template <class F>
  void
  SubmitFastscan(F&& con) {
    SubmitFastscan(nullptr, ::std::forward<F>(con));
  }

  bool
  CancelFastscan(detail::LssFastscanRequestBase& req) {
    return Cancel(req);
  }

  bool
  AbortFastscan(detail::LssFastscanRequestBase& req) {
    return Abort(req);
  }

  LssFuture<LssAddress> AsyncFastscan(
      ev_exec_t* exec, const LssAddress& address = {0, 0, 0, 0},
      const LssAddress& mask = {0, 0, 0, 0},
      detail::LssFastscanRequestBase** preq = nullptr);

  LssFuture<LssAddress>
  AsyncFastscan(const LssAddress& address = {0, 0, 0, 0},
                const LssAddress& mask = {0, 0, 0, 0},
                detail::LssFastscanRequestBase** preq = nullptr) {
    return AsyncFastscan(nullptr, address, mask, preq);
  }

  void Submit(detail::LssRequestBase& req);

  bool Cancel(detail::LssRequestBase& req);

  ::std::size_t CancelAll();

  bool Abort(detail::LssRequestBase& req);

  ::std::size_t AbortAll();

  virtual void
  OnStart(::std::function<void(::std::error_code ec)> res) noexcept {
    res(::std::error_code{});
  }

  virtual void OnSwitchBitrate(
      int bitrate, ::std::chrono::milliseconds delay,
      ::std::function<void(::std::error_code ec)> res) noexcept;
 
 protected:
  void lock() final;
  void unlock() final;

  void SetTime();
 
 private:
  struct Impl_;
  ::std::unique_ptr<Impl_> impl_;
};
 
}  // namespace canopen
 
}  // namespace lely
 
#endif  // LELY_COAPP_LSS_MASTER_HPP_