sdo.hpp

Go to the documentation of this file.

#ifndef LELY_COAPP_SDO_HPP_
#define LELY_COAPP_SDO_HPP_

#include <lely/aio/exec.hpp>
#include <lely/aio/future.hpp>
#include <lely/coapp/detail/type_traits.hpp>
#include <lely/coapp/sdo_error.hpp>

#include <chrono>
#include <memory>
#include <tuple>

namespace lely {

// The CAN network interface from <lely/can/net.hpp>.
class CANNet;

// The CANopen device from <lely/co/dev.hpp>.
class CODev;

// The CANopen Client-SDO service from <lely/co/csdo.hpp>.
class COCSDO;

namespace canopen {

class Sdo {
 public:
  using duration = ::std::chrono::milliseconds;

 private:
  struct Impl_;

  class RequestBase_ : public aio_task {
    friend class Sdo;

   public:
    RequestBase_(aio::ExecutorBase& exec, aio_task_func_t* func)
        : aio_task AIO_TASK_INIT(exec, func) {}

    RequestBase_(aio::ExecutorBase& exec, aio_task_func_t* func, uint16_t idx_,
                 uint8_t subidx_, const duration& timeout_)
        : aio_task AIO_TASK_INIT(exec, func),
          idx(idx_),
          subidx(subidx_),
          timeout(timeout_) {}

    RequestBase_(const RequestBase_&) = delete;

    RequestBase_& operator=(const RequestBase_&) = delete;

    virtual ~RequestBase_() = default;

    aio::ExecutorBase
    GetExecutor() const noexcept {
      return aio::ExecutorBase(exec);
    }

    uint16_t idx{0};
    uint8_t subidx{0};
    duration timeout{};
    uint32_t ac{0};

   private:
    virtual void OnRequest(Impl_* impl) noexcept = 0;
  };

  template <class T>
  class DownloadRequestBase_ : public RequestBase_ {
   public:
    DownloadRequestBase_(aio::ExecutorBase& exec, aio_task_func_t* func)
        : RequestBase_(exec, func) {}

    template <class U>
    DownloadRequestBase_(aio::ExecutorBase& exec, aio_task_func_t* func,
                         uint16_t idx, uint8_t subidx, U&& value_,
                         const duration& timeout)
        : RequestBase_(exec, func, idx, subidx, timeout),
          value(::std::forward<U>(value_)) {}

    T value{};
  };

  template <class T>
  class UploadRequestBase_ : public RequestBase_ {
    friend Impl_;

   public:
    using RequestBase_::RequestBase_;

    T value{};
  };

 public:
  using DownloadSignature = void(uint16_t idx, uint8_t subidx,
                                 ::std::error_code ec);

  template <class T>
  class DownloadRequest : public DownloadRequestBase_<T> {
   public:
    template <class F>
    DownloadRequest(aio::ExecutorBase& exec, F&& con)
        : DownloadRequestBase_<T>(exec, &Func_), con_(::std::forward<F>(con)) {}

    template <class U, class F>
    DownloadRequest(uint16_t idx, uint8_t subidx, U&& value,
                    aio::ExecutorBase& exec, F&& con, const duration& timeout)
        : DownloadRequestBase_<T>(exec, &Func_, idx, subidx,
                                  ::std::forward<U>(value), timeout),
          con_(::std::forward<F>(con)) {}

   private:
    void OnRequest(Impl_* impl) noexcept override;

    static void Func_(aio_task* task) noexcept;

    ::std::function<DownloadSignature> con_{nullptr};
  };

  template <class T>
  using UploadSignature = void(uint16_t idx, uint8_t subidx,
                               ::std::error_code ec, T value);

  template <class T>
  class UploadRequest : public UploadRequestBase_<T> {
   public:
    template <class F>
    UploadRequest(aio::ExecutorBase& exec, F&& con)
        : UploadRequestBase_<T>(exec, &Func_), con_(::std::forward<F>(con)) {}

    template <class F>
    UploadRequest(uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec,
                  F&& con, const duration& timeout)
        : UploadRequestBase_<T>(exec, &Func_, idx, subidx, timeout),
          con_(::std::forward<F>(con)) {}

   private:
    void OnRequest(Impl_* impl) noexcept override;

    static void Func_(aio_task* task) noexcept;

    ::std::function<UploadSignature<T>> con_{nullptr};
  };

  Sdo();

  Sdo(CANNet* net, uint8_t id);

  Sdo(CANNet* net, CODev* dev, uint8_t num);

  explicit Sdo(COCSDO* sdo);

  Sdo(const Sdo&) = delete;
  Sdo(Sdo&&) = default;

  Sdo& operator=(const Sdo&) = delete;
  Sdo& operator=(Sdo&&);

  ~Sdo();

  explicit operator bool() const noexcept { return !!impl_; }

  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value>::type
  SubmitDownload(DownloadRequest<T>& req) {
    Submit(static_cast<RequestBase_&>(req));
  }

  template <class T, class F, class U = typename ::std::decay<T>::type>
  typename ::std::enable_if<
      detail::IsCanopenType<typename ::std::decay<U>::type>::value>::type
  SubmitDownload(uint16_t idx, uint8_t subidx, T&& value,
                 aio::ExecutorBase& exec, F&& con, const duration& timeout) {
    auto req =
        new DownloadRequestWrapper<U>(idx, subidx, ::std::forward<T>(value),
                                      exec, ::std::forward<F>(con), timeout);
    Submit(*req);
  }

  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value,
                            ::std::size_t>::type
  CancelDownload(DownloadRequest<T>& req, SdoErrc ac) {
    return Cancel(req, ac);
  }

  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value>::type
  SubmitUpload(UploadRequest<T>& req) {
    Submit(static_cast<RequestBase_&>(req));
  }

  template <class T, class F>
  typename ::std::enable_if<detail::IsCanopenType<T>::value>::type
  SubmitUpload(uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec, F&& con,
               const duration& timeout) {
    auto req = new UploadRequestWrapper<T>(idx, subidx, exec,
                                           ::std::forward<F>(con), timeout);
    Submit(*req);
  }

  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value,
                            ::std::size_t>::type
  CancelUpload(UploadRequest<T>& req, SdoErrc ac) {
    return Cancel(req, ac);
  }

  ::std::size_t Cancel(SdoErrc ac);

  template <class T, class U = typename ::std::decay<T>::type>
  typename ::std::enable_if<detail::IsCanopenType<U>::value,
                            aio::Future<::std::error_code>>::type
  AsyncDownload(aio::LoopBase& loop, aio::ExecutorBase& exec, int16_t idx,
                uint8_t subidx, T&& value, const duration& timeout) {
    auto req = new AsyncDownloadRequest<U>(loop, exec, idx, subidx,
                                           ::std::forward<T>(value), timeout);
    Submit(*req);
    return req->GetFuture();
  }

  template <class T>
  typename ::std::enable_if<
      detail::IsCanopenType<T>::value,
      aio::Future<::std::tuple<::std::error_code, T>>>::type
  AsyncUpload(aio::LoopBase& loop, aio::ExecutorBase& exec, int16_t idx,
              uint8_t subidx, const duration& timeout) {
    auto req = new AsyncUploadRequest<T>(loop, exec, idx, subidx, timeout);
    Submit(*req);
    return req->GetFuture();
  }

 private:
  template <class T>
  class DownloadRequestWrapper : public DownloadRequestBase_<T> {
   public:
    template <class U, class F>
    DownloadRequestWrapper(uint16_t idx, int8_t subidx, U&& value,
                           aio::ExecutorBase& exec, F&& con,
                           const duration& timeout)
        : DownloadRequestBase_<T>(exec, &Func_, idx, subidx,
                                  ::std::forward<U>(value), timeout),
          con_(::std::forward<F>(con)) {}

   private:
    ~DownloadRequestWrapper() = default;

    void OnRequest(Impl_* impl) noexcept override;

    static void Func_(aio_task* task) noexcept;

    ::std::function<DownloadSignature> con_{nullptr};
  };

  template <class T>
  class UploadRequestWrapper : public UploadRequestBase_<T> {
   public:
    template <class F>
    UploadRequestWrapper(uint16_t idx, uint8_t subidx, aio::ExecutorBase& exec,
                         F&& con, const duration& timeout)
        : UploadRequestBase_<T>(exec, &Func_, idx, subidx, timeout),
          con_(::std::forward<F>(con)) {}

   private:
    ~UploadRequestWrapper() = default;

    void OnRequest(Impl_* impl) noexcept override;

    static void Func_(aio_task* task) noexcept;

    ::std::function<UploadSignature<T>> con_{nullptr};
  };

  template <class T>
  class AsyncDownloadRequest : public DownloadRequestBase_<T> {
   public:
    template <class U>
    AsyncDownloadRequest(aio::LoopBase& loop, aio::ExecutorBase& exec,
                         uint16_t idx, int8_t subidx, U&& value,
                         const duration& timeout)
        : DownloadRequestBase_<T>(exec, &Func_, idx, subidx,
                                  ::std::forward<U>(value), timeout),
          promise_(loop, exec) {}

    aio::Future<::std::error_code>
    GetFuture() noexcept {
      return promise_.GetFuture();
    }

   private:
    ~AsyncDownloadRequest() = default;

    void OnRequest(Impl_* impl) noexcept override;

    static void Func_(aio_task* task) noexcept;

    aio::Promise<::std::error_code> promise_;
  };

  template <class T>
  class AsyncUploadRequest : public UploadRequestBase_<T> {
   public:
    AsyncUploadRequest(aio::LoopBase& loop, aio::ExecutorBase& exec,
                       uint16_t idx, int8_t subidx, const duration& timeout)
        : UploadRequestBase_<T>(exec, &Func_, idx, subidx, timeout),
          promise_(loop, exec) {}

    aio::Future<::std::tuple<::std::error_code, T>>
    GetFuture() noexcept {
      return promise_.GetFuture();
    }

   private:
    ~AsyncUploadRequest() = default;

    void OnRequest(Impl_* impl) noexcept override;

    static void Func_(aio_task* task) noexcept;

    aio::Promise<::std::tuple<::std::error_code, T>> promise_;
  };

  void Submit(RequestBase_& req);

  ::std::size_t Cancel(RequestBase_& req, SdoErrc ac);

  ::std::unique_ptr<Impl_> impl_;
};

}  // namespace canopen

}  // namespace lely

#endif  // LELY_COAPP_SDO_HPP_