protozero  1.7.0
Minimalistic protocol buffer decoder and encoder in C++.
buffer_fixed.hpp
Go to the documentation of this file.
1 #ifndef PROTOZERO_BUFFER_FIXED_HPP
2 #define PROTOZERO_BUFFER_FIXED_HPP
3 
4 /*****************************************************************************
5 
6 protozero - Minimalistic protocol buffer decoder and encoder in C++.
7 
8 This file is from https://github.com/mapbox/protozero where you can find more
9 documentation.
10 
11 *****************************************************************************/
12 
19 #include "buffer_tmpl.hpp"
20 #include "config.hpp"
21 
22 #include <algorithm>
23 #include <cstddef>
24 #include <iterator>
25 #include <stdexcept>
26 
27 namespace protozero {
28 
35 
36  char* m_data;
37  std::size_t m_capacity;
38  std::size_t m_size = 0;
39 
40 public:
41 
43 
44  using size_type = std::size_t;
45 
46  using value_type = char;
47  using reference = value_type&;
48  using const_reference = const value_type&;
49  using pointer = value_type*;
50  using const_pointer = const value_type*;
51 
52  using iterator = pointer;
53  using const_iterator = const_pointer;
54 
56 
63  fixed_size_buffer_adaptor(char* data, std::size_t capacity) noexcept :
64  m_data(data),
65  m_capacity(capacity) {
66  }
67 
74  template <typename T>
75  explicit fixed_size_buffer_adaptor(T& container) :
76  m_data(container.data()),
77  m_capacity(container.size()) {
78  }
79 
81  const char* data() const noexcept {
82  return m_data;
83  }
84 
86  char* data() noexcept {
87  return m_data;
88  }
89 
91  std::size_t capacity() const noexcept {
92  return m_capacity;
93  }
94 
96  std::size_t size() const noexcept {
97  return m_size;
98  }
99 
101  char* begin() noexcept {
102  return m_data;
103  }
104 
106  const char* begin() const noexcept {
107  return m_data;
108  }
109 
111  const char* cbegin() const noexcept {
112  return m_data;
113  }
114 
116  char* end() noexcept {
117  return m_data + m_size;
118  }
119 
121  const char* end() const noexcept {
122  return m_data + m_size;
123  }
124 
126  const char* cend() const noexcept {
127  return m_data + m_size;
128  }
129 
131 
132  // Do not rely on anything beyond this point
133 
134  void append(const char* data, std::size_t count) {
135  if (m_size + count > m_capacity) {
136  throw std::length_error{"fixed size data store exhausted"};
137  }
138  std::copy_n(data, count, m_data + m_size);
139  m_size += count;
140  }
141 
142  void append_zeros(std::size_t count) {
143  if (m_size + count > m_capacity) {
144  throw std::length_error{"fixed size data store exhausted"};
145  }
146  std::fill_n(m_data + m_size, count, '\0');
147  m_size += count;
148  }
149 
150  void resize(std::size_t size) {
151  protozero_assert(size < m_size);
152  if (size > m_capacity) {
153  throw std::length_error{"fixed size data store exhausted"};
154  }
155  m_size = size;
156  }
157 
158  void erase_range(std::size_t from, std::size_t to) {
159  protozero_assert(from <= m_size);
160  protozero_assert(to <= m_size);
161  protozero_assert(from < to);
162  std::copy(m_data + to, m_data + m_size, m_data + from);
163  m_size -= (to - from);
164  }
165 
166  char* at_pos(std::size_t pos) {
167  protozero_assert(pos <= m_size);
168  return m_data + pos;
169  }
170 
171  void push_back(char ch) {
172  if (m_size >= m_capacity) {
173  throw std::length_error{"fixed size data store exhausted"};
174  }
175  m_data[m_size++] = ch;
176  }
178 
179 }; // class fixed_size_buffer_adaptor
180 
182 template <>
183 struct buffer_customization<fixed_size_buffer_adaptor> {
184 
185  static std::size_t size(const fixed_size_buffer_adaptor* buffer) noexcept {
186  return buffer->size();
187  }
188 
189  static void append(fixed_size_buffer_adaptor* buffer, const char* data, std::size_t count) {
190  buffer->append(data, count);
191  }
192 
193  static void append_zeros(fixed_size_buffer_adaptor* buffer, std::size_t count) {
194  buffer->append_zeros(count);
195  }
196 
197  static void resize(fixed_size_buffer_adaptor* buffer, std::size_t size) {
198  buffer->resize(size);
199  }
200 
201  static void reserve_additional(fixed_size_buffer_adaptor* /*buffer*/, std::size_t /*size*/) {
202  /* nothing to be done for fixed-size buffers */
203  }
204 
205  static void erase_range(fixed_size_buffer_adaptor* buffer, std::size_t from, std::size_t to) {
206  buffer->erase_range(from, to);
207  }
208 
209  static char* at_pos(fixed_size_buffer_adaptor* buffer, std::size_t pos) {
210  return buffer->at_pos(pos);
211  }
212 
213  static void push_back(fixed_size_buffer_adaptor* buffer, char ch) {
214  buffer->push_back(ch);
215  }
216 
217 };
219 
220 } // namespace protozero
221 
222 #endif // PROTOZERO_BUFFER_FIXED_HPP
protozero::fixed_size_buffer_adaptor::end
char * end() noexcept
Return iterator to end of data.
Definition: buffer_fixed.hpp:116
protozero::fixed_size_buffer_adaptor::cbegin
const char * cbegin() const noexcept
Return iterator to beginning of data.
Definition: buffer_fixed.hpp:111
protozero::fixed_size_buffer_adaptor::fixed_size_buffer_adaptor
fixed_size_buffer_adaptor(T &container)
Definition: buffer_fixed.hpp:75
config.hpp
Contains macro checks for different configurations.
protozero
All parts of the protozero header-only library are in this namespace.
Definition: basic_pbf_builder.hpp:24
protozero::fixed_size_buffer_adaptor::data
const char * data() const noexcept
Returns a pointer to the data in the buffer.
Definition: buffer_fixed.hpp:81
protozero::fixed_size_buffer_adaptor::begin
const char * begin() const noexcept
Return iterator to beginning of data.
Definition: buffer_fixed.hpp:106
protozero::fixed_size_buffer_adaptor
Definition: buffer_fixed.hpp:34
protozero::fixed_size_buffer_adaptor::fixed_size_buffer_adaptor
fixed_size_buffer_adaptor(char *data, std::size_t capacity) noexcept
Definition: buffer_fixed.hpp:63
protozero::fixed_size_buffer_adaptor::size
std::size_t size() const noexcept
The number of bytes used in the buffer. Always <= capacity().
Definition: buffer_fixed.hpp:96
protozero::fixed_size_buffer_adaptor::cend
const char * cend() const noexcept
Return iterator to end of data.
Definition: buffer_fixed.hpp:126
protozero::fixed_size_buffer_adaptor::end
const char * end() const noexcept
Return iterator to end of data.
Definition: buffer_fixed.hpp:121
protozero::fixed_size_buffer_adaptor::capacity
std::size_t capacity() const noexcept
The capacity this buffer was created with.
Definition: buffer_fixed.hpp:91
protozero::fixed_size_buffer_adaptor::begin
char * begin() noexcept
Return iterator to beginning of data.
Definition: buffer_fixed.hpp:101
buffer_tmpl.hpp
Contains the customization points for buffer implementations.
protozero::fixed_size_buffer_adaptor::data
char * data() noexcept
Returns a pointer to the data in the buffer.
Definition: buffer_fixed.hpp:86