1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
#include "../include/register_event.hpp"
#include <vsomeip/internal/logger.hpp>
namespace vsomeip_v3 {
namespace protocol {
register_event::register_event(service_t service, instance_t instance,
event_t event, event_type_e event_type,
bool is_provided, reliability_type_e reliability,
bool is_cyclic, uint16_t num_eventg,
const std::set<eventgroup_t> &eventgroups):
service_(service), instance_(instance), event_(event),
event_type_(event_type), is_provided_(is_provided),
reliability_(reliability), is_cyclic_(is_cyclic),
num_eventg_(num_eventg), eventgroups_(eventgroups) {
}
void
register_event::serialize(std::vector<byte_t> &_buffer, size_t &_offset) const {
std::memcpy(&_buffer[_offset], &service_, sizeof(service_));
_offset += sizeof(service_);
std::memcpy(&_buffer[_offset], &instance_, sizeof(instance_));
_offset += sizeof(instance_);
std::memcpy(&_buffer[_offset], &event_, sizeof(event_));
_offset += sizeof(event_);
_buffer[_offset] = static_cast<byte_t>(event_type_);
_offset += sizeof(event_type_);
_buffer[_offset] = static_cast<byte_t>(is_provided_);
_offset += sizeof(is_provided_);
_buffer[_offset] = static_cast<byte_t>(reliability_);
_offset += sizeof(reliability_);
_buffer[_offset] = static_cast<byte_t>(is_cyclic_);
_offset += sizeof(is_cyclic_);
std::memcpy(&_buffer[_offset], &num_eventg_, sizeof(num_eventg_));
_offset += sizeof(num_eventg_);
for (const auto g : eventgroups_) {
std::memcpy(&_buffer[_offset], &g, sizeof(g));
_offset += sizeof(g);
}
}
void
register_event::deserialize(const std::vector<byte_t> &_buffer, size_t &_offset) {
std::memcpy(&service_, &_buffer[_offset], sizeof(service_));
_offset += sizeof(service_);
std::memcpy(&instance_, &_buffer[_offset], sizeof(instance_));
_offset += sizeof(instance_);
std::memcpy(&event_, &_buffer[_offset], sizeof(event_));
_offset += sizeof(event_);
event_type_ = static_cast<event_type_e>(_buffer[_offset]);
_offset += sizeof(event_type_);
is_provided_ = static_cast<bool>(_buffer[_offset]);
_offset += sizeof(is_provided_);
reliability_ = static_cast<reliability_type_e>(_buffer[_offset]);
_offset += sizeof(reliability_);
is_cyclic_ = static_cast<bool>(_buffer[_offset]);
_offset += sizeof(is_cyclic_);
std::memcpy(&num_eventg_, &_buffer[_offset], sizeof(num_eventg_));
_offset += sizeof(num_eventg_);
eventgroups_.clear();
for (size_t i = 0; i < num_eventg_; i++) {
eventgroup_t its_g;
std::memcpy(&its_g, &_buffer[_offset], sizeof(its_g));
_offset += sizeof(its_g);
eventgroups_.insert(its_g);
}
}
void
register_event::set_eventgroups(const std::set<eventgroup_t> &_eventgroups) {
eventgroups_ = _eventgroups;
num_eventg_ = (uint16_t)eventgroups_.size();
}
} // namespace protocol
} // namespace vsomeip_v3
|
