buf.hpp

Go to the documentation of this file.

 
#ifndef LELY_CAN_BUF_HPP_
#define LELY_CAN_BUF_HPP_
 
#ifndef __cplusplus
#error "include <lely/can/buf.h> for the C interface"
#endif
 
#include <lely/util/c_type.hpp>
#include <lely/can/buf.h>
 
namespace lely {
 
template <>
struct c_type_traits<can_buf> {
  typedef can_buf value_type;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
 
  static pointer
  init(pointer p, ::std::size_t size) noexcept {
    return can_buf_init(p, size) ? 0 : p;
  }
 
  static void
  fini(pointer p) noexcept {
    can_buf_fini(p);
  }
};
 
class CANBuf : public standard_c_type<can_buf> {
  typedef standard_c_type<can_buf> c_base;
 
 public:
  explicit CANBuf(::std::size_t size = 0) : c_base(size) {}
 
  CANBuf& operator=(const CANBuf&) = delete;
 
  void
  clear() noexcept {
    can_buf_clear(c_ptr());
  }
 
  ::std::size_t
  size() const noexcept {
    return can_buf_size(c_ptr());
  }
 
  ::std::size_t
  capacity() const noexcept {
    return can_buf_capacity(c_ptr());
  }
 
  ::std::size_t
  reserve(::std::size_t n) noexcept {
    return can_buf_reserve(c_ptr(), n);
  }
 
  ::std::size_t
  peek(can_msg* ptr, ::std::size_t n) noexcept {
    return can_buf_peek(c_ptr(), ptr, n);
  }
 
  bool
  peek(can_msg& msg) noexcept {
    return !!peek(&msg, 1);
  }
 
  ::std::size_t
  read(can_msg* ptr, ::std::size_t n) noexcept {
    return can_buf_read(c_ptr(), ptr, n);
  }
 
  bool
  read(can_msg& msg) noexcept {
    return !!read(&msg, 1);
  }
 
  ::std::size_t
  write(const can_msg* ptr, ::std::size_t n) noexcept {
    return can_buf_write(c_ptr(), ptr, n);
  }
 
  bool
  write(const can_msg& msg) noexcept {
    return !!write(&msg, 1);
  }
 
 private:
  can_msg* m_ptr;
  ::std::size_t m_size;
#ifdef LELY_NO_ATOMICS
  ::std::size_t m_begin;
#else
  atomic_size_t m_begin;
#endif
#ifdef LELY_NO_ATOMICS
  ::std::size_t m_end;
#else
  atomic_size_t m_end;
#endif
};
 
}  // namespace lely
 
#endif  // !LELY_CAN_BUF_HPP_