slave.hpp

Go to the documentation of this file.

 
#ifndef LELY_COCPP_SLAVE_HPP_
#define LELY_COCPP_SLAVE_HPP_
 
#include <lely/coapp/node.hpp>
 
namespace lely {
 
namespace canopen {

class BasicSlave : public Node {
 public:
  BasicSlave(aio::TimerBase& timer, aio::CanBusBase& bus,
             const ::std::string& dcf_txt, const ::std::string& dcf_bin = "",
             uint8_t id = 0xff);
 
  virtual ~BasicSlave();
 
 protected:
  class Object;
  class ConstObject;

  class SubObject {
    friend class Object;
 
   public:
    SubObject(const SubObject&) = default;
    SubObject(SubObject&&) = default;
 
    SubObject& operator=(const SubObject&) = default;
    SubObject& operator=(SubObject&&) = default;

    template <class T>
    SubObject&
    operator=(T&& value) {
      Set(::std::forward<T>(value));
      return *this;
    }

    template <class T>
    operator T() const {
      return Get<T>();
    }

    const ::std::type_info&
    Type() const {
      return slave_->Type(idx_, subidx_);
    }

    const ::std::type_info&
    Type(::std::error_code& ec) const {
      return slave_->Type(idx_, subidx_, ec);
    }

    template <class T>
    T
    Get() const {
      return slave_->Get<T>(idx_, subidx_);
    }

    template <class T>
    T
    Get(::std::error_code& ec) const {
      return slave_->Get<T>(idx_, subidx_, ec);
    }

    template <class T>
    void
    Set(T&& value) {
      slave_->Set(idx_, subidx_, ::std::forward<T>(value));
    }

    template <class T>
    void
    Set(T&& value, ::std::error_code& ec) {
      slave_->Set(idx_, subidx_, ::std::forward<T>(value), ec);
    }

    void
    Set(const void* p, ::std::size_t n) {
      slave_->Set(idx_, subidx_, p, n);
    }

    void
    Set(const void* p, ::std::size_t n, ::std::error_code& ec) {
      slave_->Set(idx_, subidx_, p, n, ec);
    }
 
   private:
    SubObject(BasicSlave* slave, uint16_t idx, uint8_t subidx)
        : slave_(slave), idx_(idx), subidx_(subidx) {}
 
    BasicSlave* slave_;
    uint16_t idx_;
    uint8_t subidx_;
  };

  class ConstSubObject {
    friend class Object;
    friend class ConstObject;
 
   public:
    template <class T>
    operator T() const {
      return Get<T>();
    }

    const ::std::type_info&
    Type() const {
      return slave_->Type(idx_, subidx_);
    }

    const ::std::type_info&
    Type(::std::error_code& ec) const {
      return slave_->Type(idx_, subidx_, ec);
    }

    template <class T>
    T
    Get() const {
      return slave_->Get<T>(idx_, subidx_);
    }

    template <class T>
    T
    Get(::std::error_code& ec) const {
      return slave_->Get<T>(idx_, subidx_, ec);
    }
 
   private:
    ConstSubObject(const BasicSlave* slave, uint16_t idx, uint8_t subidx)
        : slave_(slave), idx_(idx), subidx_(subidx) {}
 
    const BasicSlave* slave_;
    uint16_t idx_;
    uint8_t subidx_;
  };

  class Object {
    friend class BasicSlave;
 
   public:
    SubObject operator[](uint8_t subidx) {
      return SubObject(slave_, idx_, subidx);
    }

    ConstSubObject operator[](uint8_t subidx) const {
      return ConstSubObject(slave_, idx_, subidx);
    }
 
   private:
    Object(BasicSlave* slave, uint16_t idx) : slave_(slave), idx_(idx) {}
 
    BasicSlave* slave_;
    uint16_t idx_;
  };

  class ConstObject {
    friend class BasicSlave;
 
   public:
    ConstSubObject operator[](uint8_t subidx) const {
      return ConstSubObject(slave_, idx_, subidx);
    }
 
   private:
    ConstObject(const BasicSlave* slave, uint16_t idx)
        : slave_(slave), idx_(idx) {}
 
    const BasicSlave* slave_;
    uint16_t idx_;
  };

  template <class T>
  using OnReadSignature = ::std::error_code(uint16_t idx, uint8_t subdx,
                                            T& value);

  template <class T>
  using OnWriteSignature = typename ::std::conditional<
      detail::IsCanopenBasic<T>::value,
      ::std::error_code(uint16_t idx, uint8_t subidx, T& new_val, T old_val),
      ::std::error_code(uint16_t idx, uint8_t subidx, T& new_val)>::type;

  Object operator[](uint16_t idx) { return Object(this, idx); }

  ConstObject operator[](uint16_t idx) const { return ConstObject(this, idx); }

  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value>::type OnRead(
      uint16_t idx, uint8_t subidx, ::std::function<OnReadSignature<T>> ind);

  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value>::type OnRead(
      uint16_t idx, uint8_t subidx, ::std::function<OnReadSignature<T>> ind,
      ::std::error_code& ec);

  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value>::type OnWrite(
      uint16_t idx, uint8_t subidx, ::std::function<OnWriteSignature<T>> ind);

  template <class T>
  typename ::std::enable_if<detail::IsCanopenType<T>::value>::type OnWrite(
      uint16_t idx, uint8_t subidx, ::std::function<OnWriteSignature<T>> ind,
      ::std::error_code& ec);
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
#endif
  virtual void
  OnLifeGuarding(bool occurred) noexcept {
    (void)occurred;
  };
 
 private:
  struct Impl_;
  ::std::unique_ptr<Impl_> impl_;
};
 
}  // namespace canopen
 
}  // namespace lely
 
#endif  // LELY_COCPP_SLAVE_HPP_