serialization.h
Go to the documentation of this file.
1 #pragma once
2 
3 #include <stdint.h>
4 #include <stdbool.h>
5 
6 #include "../mip_field.h"
7 #include "../mip_packet.h"
8 #include "../mip_types.h"
9 
18 
19 #ifdef __cplusplus
20 #include <type_traits>
21 
22 namespace mip {
23 namespace C {
24 extern "C" {
25 #endif // __cplusplus
26 
27 
28 
35 
36 
45 typedef struct mip_serializer
46 {
47  uint8_t* _buffer;
48  size_t _buffer_size;
49  size_t _offset;
50 } mip_serializer;
51 
52 void mip_serializer_init_insertion(mip_serializer* serializer, uint8_t* buffer, size_t buffer_size);
53 void mip_serializer_init_extraction(mip_serializer* serializer, const uint8_t* buffer, size_t buffer_size);
54 void mip_serializer_init_new_field(mip_serializer* serializer, mip_packet* packet, uint8_t field_descriptor);
55 void mip_serializer_finish_new_field(const mip_serializer* serializer, mip_packet* packet);
56 void mip_serializer_init_from_field(mip_serializer* serializer, const mip_field* field);
57 
58 size_t mip_serializer_capacity(const mip_serializer* serializer);
59 size_t mip_serializer_length(const mip_serializer* serializer);
60 int mip_serializer_remaining(const mip_serializer* serializer);
61 
62 bool mip_serializer_is_ok(const mip_serializer* serializer);
63 bool mip_serializer_is_complete(const mip_serializer* serializer);
64 
65 
66 void insert_bool(mip_serializer* serializer, bool value);
67 void insert_char(mip_serializer* serializer, char value);
68 
69 void insert_u8 (mip_serializer* serializer, uint8_t value);
70 void insert_u16(mip_serializer* serializer, uint16_t value);
71 void insert_u32(mip_serializer* serializer, uint32_t value);
72 void insert_u64(mip_serializer* serializer, uint64_t value);
73 
74 void insert_s8 (mip_serializer* serializer, int8_t value);
75 void insert_s16(mip_serializer* serializer, int16_t value);
76 void insert_s32(mip_serializer* serializer, int32_t value);
77 void insert_s64(mip_serializer* serializer, int64_t value);
78 
79 void insert_float (mip_serializer* serializer, float value);
80 void insert_double(mip_serializer* serializer, double value);
81 
82 
83 void extract_bool(mip_serializer* serializer, bool* value);
84 void extract_char(mip_serializer* serializer, char* value);
85 
86 void extract_u8 (mip_serializer* serializer, uint8_t* value);
87 void extract_u16(mip_serializer* serializer, uint16_t* value);
88 void extract_u32(mip_serializer* serializer, uint32_t* value);
89 void extract_u64(mip_serializer* serializer, uint64_t* value);
90 
91 void extract_s8 (mip_serializer* serializer, int8_t* value);
92 void extract_s16(mip_serializer* serializer, int16_t* value);
93 void extract_s32(mip_serializer* serializer, int32_t* value);
94 void extract_s64(mip_serializer* serializer, int64_t* value);
95 
96 void extract_float (mip_serializer* serializer, float* value);
97 void extract_double(mip_serializer* serializer, double* value);
98 
99 void extract_count(mip_serializer* serializer, uint8_t* count_out, uint8_t max_count);
100 
103 
104 #ifdef __cplusplus
105 } // extern "C"
106 } // namespace C
107 
111 
148 
152 class Serializer : public C::mip_serializer
153 {
154 public:
155  Serializer(C::mip_packet& packet, uint8_t newFieldDescriptor) { C::mip_serializer_init_new_field(this, &packet, newFieldDescriptor); }
156  Serializer(uint8_t* buffer, size_t size, size_t offset=0) { C::mip_serializer_init_insertion(this, buffer, size); this->_offset = offset; }
157  Serializer(const uint8_t* buffer, size_t size, size_t offset=0) { C::mip_serializer_init_extraction(this, const_cast<uint8_t*>(buffer), size); this->_offset = offset; }
158 
159  size_t capacity() const { return C::mip_serializer_capacity(this); }
160  size_t length() const { return C::mip_serializer_length(this); }
161  int remaining() const { return C::mip_serializer_remaining(this); }
162 
163  bool isOk() const { return C::mip_serializer_is_ok(this); }
164  bool isComplete() const { return C::mip_serializer_is_complete(this); }
165 
166  operator const void*() const { return isOk() ? this : nullptr; }
167  bool operator!() const { return !isOk(); }
168 };
169 
170 
171 
172 inline void insert(Serializer& serializer, bool value) { return C::insert_bool (&serializer, value); }
173 inline void insert(Serializer& serializer, char value) { return C::insert_char (&serializer, value); }
174 inline void insert(Serializer& serializer, uint8_t value) { return C::insert_u8 (&serializer, value); }
175 inline void insert(Serializer& serializer, uint16_t value) { return C::insert_u16 (&serializer, value); }
176 inline void insert(Serializer& serializer, uint32_t value) { return C::insert_u32 (&serializer, value); }
177 inline void insert(Serializer& serializer, uint64_t value) { return C::insert_u64 (&serializer, value); }
178 inline void insert(Serializer& serializer, int8_t value) { return C::insert_s8 (&serializer, value); }
179 inline void insert(Serializer& serializer, int16_t value) { return C::insert_s16 (&serializer, value); }
180 inline void insert(Serializer& serializer, int32_t value) { return C::insert_s32 (&serializer, value); }
181 inline void insert(Serializer& serializer, int64_t value) { return C::insert_s64 (&serializer, value); }
182 inline void insert(Serializer& serializer, float value) { return C::insert_float (&serializer, value); }
183 inline void insert(Serializer& serializer, double value) { return C::insert_double(&serializer, value); }
184 
193 template<typename Enum>
194 typename std::enable_if< std::is_enum<Enum>::value, void>::type
195 /*void*/ insert(Serializer& serializer, Enum value) { return insert(serializer, static_cast< typename std::underlying_type<Enum>::type >(value) ); }
196 
210 template<typename T>
211 bool insert(const T& value, uint8_t* buffer, size_t bufferSize, size_t offset=0)
212 {
213  Serializer serializer(buffer, bufferSize, offset);
214  insert(serializer, value);
215  return !!serializer;
216 }
217 
218 inline void extract(Serializer& serializer, bool& value) { return C::extract_bool (&serializer, &value); }
219 inline void extract(Serializer& serializer, char& value) { return C::extract_char (&serializer, &value); }
220 inline void extract(Serializer& serializer, uint8_t& value) { return C::extract_u8 (&serializer, &value); }
221 inline void extract(Serializer& serializer, uint16_t& value) { return C::extract_u16 (&serializer, &value); }
222 inline void extract(Serializer& serializer, uint32_t& value) { return C::extract_u32 (&serializer, &value); }
223 inline void extract(Serializer& serializer, uint64_t& value) { return C::extract_u64 (&serializer, &value); }
224 inline void extract(Serializer& serializer, int8_t& value) { return C::extract_s8 (&serializer, &value); }
225 inline void extract(Serializer& serializer, int16_t& value) { return C::extract_s16 (&serializer, &value); }
226 inline void extract(Serializer& serializer, int32_t& value) { return C::extract_s32 (&serializer, &value); }
227 inline void extract(Serializer& serializer, int64_t& value) { return C::extract_s64 (&serializer, &value); }
228 inline void extract(Serializer& serializer, float& value) { return C::extract_float (&serializer, &value); }
229 inline void extract(Serializer& serializer, double& value) { return C::extract_double(&serializer, &value); }
230 
239 template<typename Enum>
240 typename std::enable_if< std::is_enum<Enum>::value, void>::type
241 /*void*/ extract(Serializer& serializer, Enum& value) {
242  typename std::underlying_type<Enum>::type tmp;
243  extract(serializer, tmp);
244  value = static_cast<Enum>(tmp);
245 }
246 
267 template<typename T>
268 bool extract(T& value_out, const uint8_t* buffer, size_t bufferSize, size_t offset=0, bool exact_size=false)
269 {
270  Serializer serializer(buffer, bufferSize, offset);
271  extract(serializer, value_out);
272  return exact_size ? serializer.isComplete() : serializer.isOk();
273 }
274 
278 
279 } // namespace mip
280 #endif // __cplusplus
281 
282 ////////////////////////////////////////////////////////////////////////////////
insert_bool
void insert_bool(mip_serializer *serializer, bool value)
mip_serializer_capacity
size_t mip_serializer_capacity(const mip_serializer *serializer)
Determines the total length the buffer.
Definition: serialization.c:115
mip
Definition: ping.cpp:12
mip_serializer_init_from_field
void mip_serializer_init_from_field(mip_serializer *serializer, const mip_field *field)
Initialize a serialization struct from a MIP field payload.
Definition: serialization.c:103
extract_u16
void extract_u16(mip_serializer *serializer, uint16_t *value)
extract_s32
void extract_s32(mip_serializer *serializer, int32_t *value)
mip::commands_3dm::extract
void extract(Serializer &serializer, NmeaMessage &self)
Definition: commands_3dm.cpp:38
mip_serializer_length
size_t mip_serializer_length(const mip_serializer *serializer)
Determines the length of the data in the buffer.
Definition: serialization.c:131
insert_double
void insert_double(mip_serializer *serializer, double value)
extract_float
void extract_float(mip_serializer *serializer, float *value)
extract_double
void extract_double(mip_serializer *serializer, double *value)
insert_s16
void insert_s16(mip_serializer *serializer, int16_t value)
mip_serializer_init_extraction
void mip_serializer_init_extraction(mip_serializer *serializer, const uint8_t *buffer, size_t buffer_size)
Initialize a serialization struct for extraction from a buffer.
Definition: serialization.c:40
mip_serializer
Structure used for serialization.
Definition: serialization.h:45
insert_s8
void insert_s8(mip_serializer *serializer, int8_t value)
mip::commands_3dm::insert
void insert(Serializer &serializer, const NmeaMessage &self)
Definition: commands_3dm.cpp:27
insert_u8
void insert_u8(mip_serializer *serializer, uint8_t value)
mip_field
A structure representing a MIP field.
Definition: mip_field.h:52
insert_char
void insert_char(mip_serializer *serializer, char value)
mip_serializer_is_complete
bool mip_serializer_is_complete(const mip_serializer *serializer)
Determines if the number of remaining bytes is 0.
Definition: serialization.c:180
extract_count
void extract_count(mip_serializer *serializer, uint8_t *count_out, uint8_t max_count)
Similar to extract_u8 but allows a maximum value to be specified.
Definition: serialization.c:259
mip_serializer::_buffer
uint8_t * _buffer
Pointer to data for serialization.
Definition: serialization.h:47
mip_serializer_init_insertion
void mip_serializer_init_insertion(mip_serializer *serializer, uint8_t *buffer, size_t buffer_size)
Initialize a serialization struct for insertion into a buffer.
Definition: serialization.c:24
extract_u64
void extract_u64(mip_serializer *serializer, uint64_t *value)
mip_serializer_init_new_field
void mip_serializer_init_new_field(mip_serializer *serializer, mip_packet *packet, uint8_t field_descriptor)
Initializer a serialization struct for creation of a new field at the end of the packet.
Definition: serialization.c:61
extract_s8
void extract_s8(mip_serializer *serializer, int8_t *value)
insert_float
void insert_float(mip_serializer *serializer, float value)
insert_s32
void insert_s32(mip_serializer *serializer, int32_t value)
mip_packet
struct mip_packet mip_packet
Structure representing a MIP Packet.
extract_char
void extract_char(mip_serializer *serializer, char *value)
insert_u32
void insert_u32(mip_serializer *serializer, uint32_t value)
extract_u8
void extract_u8(mip_serializer *serializer, uint8_t *value)
extract_s64
void extract_s64(mip_serializer *serializer, int64_t *value)
insert_u16
void insert_u16(mip_serializer *serializer, uint16_t value)
mip_serializer_finish_new_field
void mip_serializer_finish_new_field(const mip_serializer *serializer, mip_packet *packet)
Call this after a new field allocated by mip_serializer_init_new_field has been written.
Definition: serialization.c:84
mip_serializer
struct mip_serializer mip_serializer
Structure used for serialization.
extract_bool
void extract_bool(mip_serializer *serializer, bool *value)
mip_serializer::_buffer_size
size_t _buffer_size
Size of the buffer.
Definition: serialization.h:48
mip_serializer_remaining
int mip_serializer_remaining(const mip_serializer *serializer)
Determines the difference between the length and buffer size.
Definition: serialization.c:148
mip_serializer_is_ok
bool mip_serializer_is_ok(const mip_serializer *serializer)
Determines if the data read/written is less than the buffer size.
Definition: serialization.c:165
extract_u32
void extract_u32(mip_serializer *serializer, uint32_t *value)
extract_s16
void extract_s16(mip_serializer *serializer, int16_t *value)
mip_serializer::_offset
size_t _offset
Current offset into the buffer (can exceed buffer_size!).
Definition: serialization.h:49
mip_packet
Structure representing a MIP Packet.
Definition: mip_packet.h:41
length
TF2SIMD_FORCE_INLINE tf2Scalar length(const Quaternion &q)
insert_s64
void insert_s64(mip_serializer *serializer, int64_t value)
insert_u64
void insert_u64(mip_serializer *serializer, uint64_t value)

microstrain_inertial_driver
Author(s): Brian Bingham, Parker Hannifin Corp
autogenerated on Mon Jun 24 2024 02:51:40