sync.hpp

Go to the documentation of this file.

 
#ifndef LELY_CO_SYNC_HPP_
#define LELY_CO_SYNC_HPP_
 
#ifndef __cplusplus
#error "include <lely/co/sync.h> for the C interface"
#endif
 
#include <lely/can/net.hpp>
#include <lely/co/sync.h>
 
namespace lely {
 
template <>
struct c_type_traits<__co_sync> {
  typedef __co_sync value_type;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
 
  static void*
  alloc() noexcept {
    return __co_sync_alloc();
  }
  static void
  free(void* ptr) noexcept {
    __co_sync_free(ptr);
  }
 
  static pointer
  init(pointer p, CANNet* net, CODev* dev) noexcept {
    return __co_sync_init(p, net, dev);
  }
 
  static void
  fini(pointer p) noexcept {
    __co_sync_fini(p);
  }
};
 
class COSync : public incomplete_c_type<__co_sync> {
  typedef incomplete_c_type<__co_sync> c_base;
 
 public:
  COSync(CANNet* net, CODev* dev) : c_base(net, dev) {}
 
  CANNet*
  getNet() const noexcept {
    return co_sync_get_net(this);
  }
  CODev*
  getDev() const noexcept {
    return co_sync_get_dev(this);
  }
 
  void
  getInd(co_sync_ind_t** pind, void** pdata) const noexcept {
    co_sync_get_ind(this, pind, pdata);
  }
 
  void
  setInd(co_sync_ind_t* ind, void* data) noexcept {
    co_sync_set_ind(this, ind, data);
  }
 
  template <class F>
  void
  setInd(F* f) noexcept {
    setInd(&c_obj_call<co_sync_ind_t*, F>::function, static_cast<void*>(f));
  }
 
  template <class C, typename c_mem_fn<co_sync_ind_t*, C>::type M>
  void
  setInd(C* obj) noexcept {
    setInd(&c_mem_call<co_sync_ind_t*, C, M>::function,
           static_cast<void*>(obj));
  }
 
  void
  getErr(co_sync_err_t** perr, void** pdata) const noexcept {
    co_sync_get_err(this, perr, pdata);
  }
 
  void
  setErr(co_sync_err_t* err, void* data) noexcept {
    co_sync_set_err(this, err, data);
  }
 
  template <class F>
  void
  setErr(F* f) noexcept {
    setErr(&c_obj_call<co_sync_err_t*, F>::function, static_cast<void*>(f));
  }
 
  template <class C, typename c_mem_fn<co_sync_err_t*, C>::type M>
  void
  setErr(C* obj) noexcept {
    setErr(&c_mem_call<co_sync_err_t*, C, M>::function,
           static_cast<void*>(obj));
  }
 
 protected:
  ~COSync() {}
};
 
}  // namespace lely
 
#endif  // !LELY_CO_SYNC_HPP_