Lely core libraries  2.2.5
buf.hpp
Go to the documentation of this file.
1 
22 #ifndef LELY_CAN_BUF_HPP_
23 #define LELY_CAN_BUF_HPP_
24 
25 #ifndef __cplusplus
26 #error "include <lely/can/buf.h> for the C interface"
27 #endif
28 
29 #include <lely/util/c_type.hpp>
30 #include <lely/can/buf.h>
31 
32 namespace lely {
33 
35 template <>
37  typedef can_buf value_type;
38  typedef value_type& reference;
39  typedef const value_type& const_reference;
40  typedef value_type* pointer;
41  typedef const value_type* const_pointer;
42 
43  static pointer
44  init(pointer p, ::std::size_t size) noexcept {
45  return can_buf_init(p, size) ? 0 : p;
46  }
47 
48  static void
49  fini(pointer p) noexcept {
50  can_buf_fini(p);
51  }
52 };
53 
55 class CANBuf : public standard_c_type<can_buf> {
57 
58  public:
59  explicit CANBuf(::std::size_t size = 0) : c_base(size) {}
60 
61  CANBuf& operator=(const CANBuf&) = delete;
62 
63  void
64  clear() noexcept {
65  can_buf_clear(c_ptr());
66  }
67 
68  ::std::size_t
69  size() const noexcept {
70  return can_buf_size(c_ptr());
71  }
72 
73  ::std::size_t
74  capacity() const noexcept {
75  return can_buf_capacity(c_ptr());
76  }
77 
78  ::std::size_t
79  reserve(::std::size_t n) noexcept {
80  return can_buf_reserve(c_ptr(), n);
81  }
82 
83  ::std::size_t
84  peek(can_msg* ptr, ::std::size_t n) noexcept {
85  return can_buf_peek(c_ptr(), ptr, n);
86  }
87 
88  bool
89  peek(can_msg& msg) noexcept {
90  return !!peek(&msg, 1);
91  }
92 
93  ::std::size_t
94  read(can_msg* ptr, ::std::size_t n) noexcept {
95  return can_buf_read(c_ptr(), ptr, n);
96  }
97 
98  bool
99  read(can_msg& msg) noexcept {
100  return !!read(&msg, 1);
101  }
102 
103  ::std::size_t
104  write(const can_msg* ptr, ::std::size_t n) noexcept {
105  return can_buf_write(c_ptr(), ptr, n);
106  }
107 
108  bool
109  write(const can_msg& msg) noexcept {
110  return !!write(&msg, 1);
111  }
112 
113  private:
114  can_msg* m_ptr;
115  ::std::size_t m_size;
116 #ifdef LELY_NO_ATOMICS
117  ::std::size_t m_begin;
118 #else
119  atomic_size_t m_begin;
120 #endif
121 #ifdef LELY_NO_ATOMICS
122  ::std::size_t m_end;
123 #else
124  atomic_size_t m_end;
125 #endif
126 };
127 
128 } // namespace lely
129 
130 #endif // !LELY_CAN_BUF_HPP_
void can_buf_clear(struct can_buf *buf)
Clears a CAN frame buffer.
Definition: buf.h:199
A CAN or CAN FD format frame.
Definition: msg.h:87
void can_buf_fini(struct can_buf *buf)
Finalizes a CAN frame buffer.
Definition: buf.c:67
size_t can_buf_size(const struct can_buf *buf)
Returns the number of frames available for reading in a CAN buffer.
Definition: buf.h:210
A CAN frame buffer.
Definition: buf.h:47
size_t can_buf_peek(struct can_buf *buf, struct can_msg *ptr, size_t n)
Reads, but does not remove, frames from a CAN frame buffer.
Definition: buf.h:242
int can_buf_init(struct can_buf *buf, size_t size)
Initializes a CAN frame buffer.
Definition: buf.c:39
This header file is part of the utilities library; it contains the C to C++ interface declarations...
size_t can_buf_reserve(struct can_buf *buf, size_t n)
Resizes a CAN frame buffer, if necessary, to make room for at least n additional frames.
Definition: buf.c:111
This header file is part of the CAN library; it contains the CAN frame buffer declarations.
size_t can_buf_capacity(const struct can_buf *buf)
Returns the number of frames available for writing in a CAN buffer.
Definition: buf.h:226
The base class for a C++ interface to a standard layout C type.
Definition: c_type.hpp:174
size_t can_buf_read(struct can_buf *buf, struct can_msg *ptr, size_t n)
Reads, and removes, frames from a CAN frame buffer.
Definition: buf.h:268
size_t can_buf_write(struct can_buf *buf, const struct can_msg *ptr, size_t n)
Writes frames to a CAN frame buffer.
Definition: buf.h:300
Definition: buf.hpp:32
A CAN frame buffer.
Definition: buf.hpp:55
A class template supplying a uniform interface to certain attributes of C types.
Definition: c_type.hpp:120