1
2 #pragma once
3
4 #include <cstdint>
5 #include <functional>
6 #include <iomanip>
7 #include <optional>
8 #include <sstream>
9 #include <string>
10 #include <type_traits>
11
12 #include "packet/base_packet_builder.h"
13 #include "packet/bit_inserter.h"
14 #include "packet/custom_field_fixed_size_interface.h"
15 #include "packet/iterator.h"
16 #include "packet/packet_builder.h"
17 #include "packet/packet_struct.h"
18 #include "packet/packet_view.h"
19 #include "packet/checksum_type_checker.h"
20 #include "packet/custom_type_checker.h"
21
22 #if __has_include(<bluetooth/log.h>)
23
24 #include <bluetooth/log.h>
25
26 #ifndef ASSERT
27 #define ASSERT(cond) bluetooth::log::assert_that(cond, #cond)
28 #endif // !defined(ASSERT)
29
30 #else
31
32 #ifndef ASSERT
33 #define ASSERT(cond) assert(cond)
34 #endif // !defined(ASSERT)
35
36 #endif // __has_include(<bluetooth/log.h>)
37
38
39 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING) || defined(FUZZ_TARGET)
40 #include "packet/raw_builder.h"
41 #endif
42
43
44 namespace bluetooth {
45 namespace ras {
46
47
48
49
50 using ::bluetooth::packet::BasePacketBuilder;
51 using ::bluetooth::packet::BitInserter;
52 using ::bluetooth::packet::CustomFieldFixedSizeInterface;
53 using ::bluetooth::packet::CustomTypeChecker;
54 using ::bluetooth::packet::Iterator;
55 using ::bluetooth::packet::kLittleEndian;
56 using ::bluetooth::packet::PacketBuilder;
57 using ::bluetooth::packet::PacketStruct;
58 using ::bluetooth::packet::PacketView;
59 using ::bluetooth::packet::parser::ChecksumTypeChecker;
60
61 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING) || defined(FUZZ_TARGET)
62 using ::bluetooth::packet::RawBuilder;
63 #endif
64 enum class PctFormat : uint8_t {IQ = 0x0,PHASE = 0x1,};
65
66
67 enum class RangingDoneStatus : uint8_t {ALL_RESULTS_COMPLETE = 0x0,PARTIAL_RESULTS = 0x1,ABORTED = 0xf,};
68
69
70 enum class SubeventDoneStatus : uint8_t {ALL_RESULTS_COMPLETE = 0x0,ABORTED = 0xf,};
71
72
73 enum class RangingAbortReason : uint8_t {NO_ABORT = 0x0,LOCAL_HOST_OR_REMOTE = 0x1,INSUFFICIENT_FILTERED_CHANNELS = 0x2,INSTANT_HAS_PASSED = 0x3,UNSPECIFIED = 0xf,};
74
75
76 enum class SubeventAbortReason : uint8_t {NO_ABORT = 0x0,LOCAL_HOST_OR_REMOTE = 0x1,NO_CS_SYNC_RECEIVED = 0x2,SCHEDULING_CONFLICTS_OR_LIMITED_RESOURCES = 0x3,UNSPECIFIED = 0xf,};
77
78
PctFormatText(const PctFormat & param)79 inline std::string PctFormatText(const PctFormat& param) {std::stringstream builder;switch (param) {case PctFormat::IQ: builder << "IQ"; break;case PctFormat::PHASE: builder << "PHASE"; break;default: builder << "Unknown PctFormat";}builder << "(" << std::hex << "0x" << std::setfill('0')<< std::setw(2/4)<< static_cast<uint64_t>(param) << ")";return builder.str();}
80
81
82
RangingDoneStatusText(const RangingDoneStatus & param)83 inline std::string RangingDoneStatusText(const RangingDoneStatus& param) {std::stringstream builder;switch (param) {case RangingDoneStatus::ALL_RESULTS_COMPLETE: builder << "ALL_RESULTS_COMPLETE"; break;case RangingDoneStatus::PARTIAL_RESULTS: builder << "PARTIAL_RESULTS"; break;case RangingDoneStatus::ABORTED: builder << "ABORTED"; break;default: builder << "Unknown RangingDoneStatus";}builder << "(" << std::hex << "0x" << std::setfill('0')<< std::setw(4/4)<< static_cast<uint64_t>(param) << ")";return builder.str();}
84
85
86
SubeventDoneStatusText(const SubeventDoneStatus & param)87 inline std::string SubeventDoneStatusText(const SubeventDoneStatus& param) {std::stringstream builder;switch (param) {case SubeventDoneStatus::ALL_RESULTS_COMPLETE: builder << "ALL_RESULTS_COMPLETE"; break;case SubeventDoneStatus::ABORTED: builder << "ABORTED"; break;default: builder << "Unknown SubeventDoneStatus";}builder << "(" << std::hex << "0x" << std::setfill('0')<< std::setw(4/4)<< static_cast<uint64_t>(param) << ")";return builder.str();}
88
89
90
RangingAbortReasonText(const RangingAbortReason & param)91 inline std::string RangingAbortReasonText(const RangingAbortReason& param) {std::stringstream builder;switch (param) {case RangingAbortReason::NO_ABORT: builder << "NO_ABORT"; break;case RangingAbortReason::LOCAL_HOST_OR_REMOTE: builder << "LOCAL_HOST_OR_REMOTE"; break;case RangingAbortReason::INSUFFICIENT_FILTERED_CHANNELS: builder << "INSUFFICIENT_FILTERED_CHANNELS"; break;case RangingAbortReason::INSTANT_HAS_PASSED: builder << "INSTANT_HAS_PASSED"; break;case RangingAbortReason::UNSPECIFIED: builder << "UNSPECIFIED"; break;default: builder << "Unknown RangingAbortReason";}builder << "(" << std::hex << "0x" << std::setfill('0')<< std::setw(4/4)<< static_cast<uint64_t>(param) << ")";return builder.str();}
92
93
94
SubeventAbortReasonText(const SubeventAbortReason & param)95 inline std::string SubeventAbortReasonText(const SubeventAbortReason& param) {std::stringstream builder;switch (param) {case SubeventAbortReason::NO_ABORT: builder << "NO_ABORT"; break;case SubeventAbortReason::LOCAL_HOST_OR_REMOTE: builder << "LOCAL_HOST_OR_REMOTE"; break;case SubeventAbortReason::NO_CS_SYNC_RECEIVED: builder << "NO_CS_SYNC_RECEIVED"; break;case SubeventAbortReason::SCHEDULING_CONFLICTS_OR_LIMITED_RESOURCES: builder << "SCHEDULING_CONFLICTS_OR_LIMITED_RESOURCES"; break;case SubeventAbortReason::UNSPECIFIED: builder << "UNSPECIFIED"; break;default: builder << "Unknown SubeventAbortReason";}builder << "(" << std::hex << "0x" << std::setfill('0')<< std::setw(4/4)<< static_cast<uint64_t>(param) << ")";return builder.str();}
96
97
98
99
100 /* Done ChecksumChecks */
101
StepMode()102 class StepMode : public PacketStruct<kLittleEndian> { public:StepMode() {}
103 StepMode(uint8_t mode_type, uint8_t aborted)
104 : mode_type_(mode_type), aborted_(aborted)
105 {}
106 public:
107 virtual ~StepMode() = default;
108 protected:void SerializeHeader(BitInserter& i ) const {insert(mode_type_, i,2);insert(static_cast<uint8_t>(0) /* Reserved */, i, 5 );
109 insert(aborted_, i,1);}
110
111 void SerializeFooter(BitInserter&) const {}
112
113 public:virtual void Serialize(BitInserter& i) const override {SerializeHeader(i);SerializeFooter(i);}
114
115 static Iterator<kLittleEndian> Parse(StepMode* to_fill, Iterator<kLittleEndian> struct_begin_it ) {auto to_bound = struct_begin_it;size_t end_index = struct_begin_it.NumBytesRemaining();if (end_index < 1){ return struct_begin_it.Subrange(0,0);}{if (to_bound.NumBytesRemaining() < 1){ return to_bound.Subrange(to_bound.NumBytesRemaining(),0);}}{auto mode_type_it = to_bound + (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;auto mode_type_ptr = &to_fill->mode_type_;auto extracted_value = mode_type_it.extract<uint8_t>();extracted_value &= 0x3;*mode_type_ptr = static_cast<uint8_t>(extracted_value);}{auto aborted_it = to_bound + (/* Bits: */ 7 + /* Dynamic: */ 0) / 8;auto aborted_ptr = &to_fill->aborted_;auto extracted_value = aborted_it.extract<uint8_t>();extracted_value >>= 7;extracted_value &= 0x1;*aborted_ptr = static_cast<uint8_t>(extracted_value);}return struct_begin_it + to_fill->size();}
116 protected:size_t BitsOfHeader() const {return 0 + /* Bits: */ 2 + /* Dynamic: */ 0 + /* Bits: */ 5 + /* Dynamic: */ 0 + /* Bits: */ 1 + /* Dynamic: */ 0;}
117
118 size_t BitsOfFooter() const {return 0;}
119
120 public:virtual size_t size() const override {return (BitsOfHeader() / 8) + (BitsOfFooter() / 8);}
121
122
123
124 std::string ToString() const {std::stringstream ss;ss << std::hex << std::showbase << "StepMode { ";ss << "mode_type = " << static_cast<uint64_t>(mode_type_) << ", aborted = " << static_cast<uint64_t>(aborted_);ss << " }";return ss.str();}
125
126 uint8_t mode_type_{};uint8_t aborted_{};};
127
128
RasSubeventHeader()129 class RasSubeventHeader : public PacketStruct<kLittleEndian> { public:RasSubeventHeader() {}
130 RasSubeventHeader(uint16_t start_acl_conn_event, uint16_t frequency_compensation, RangingDoneStatus ranging_done_status, SubeventDoneStatus subevent_done_status, RangingAbortReason ranging_abort_reason, SubeventAbortReason subevent_abort_reason, uint8_t reference_power_level, uint8_t num_steps_reported)
131 : start_acl_conn_event_(start_acl_conn_event), frequency_compensation_(frequency_compensation), ranging_done_status_(ranging_done_status), subevent_done_status_(subevent_done_status), ranging_abort_reason_(ranging_abort_reason), subevent_abort_reason_(subevent_abort_reason), reference_power_level_(reference_power_level), num_steps_reported_(num_steps_reported)
132 {}
133 public:
134 virtual ~RasSubeventHeader() = default;
135 protected:void SerializeHeader(BitInserter& i ) const {insert(start_acl_conn_event_, i,16);insert(frequency_compensation_, i,16);insert(static_cast<uint8_t>(ranging_done_status_), i, 4);insert(static_cast<uint8_t>(subevent_done_status_), i, 4);insert(static_cast<uint8_t>(ranging_abort_reason_), i, 4);insert(static_cast<uint8_t>(subevent_abort_reason_), i, 4);i.insert_byte(reference_power_level_);i.insert_byte(num_steps_reported_);}
136
137 void SerializeFooter(BitInserter&) const {}
138
139 public:virtual void Serialize(BitInserter& i) const override {SerializeHeader(i);SerializeFooter(i);}
140
141 static Iterator<kLittleEndian> Parse(RasSubeventHeader* to_fill, Iterator<kLittleEndian> struct_begin_it ) {auto to_bound = struct_begin_it;size_t end_index = struct_begin_it.NumBytesRemaining();if (end_index < 8){ return struct_begin_it.Subrange(0,0);}{if (to_bound.NumBytesRemaining() < 8){ return to_bound.Subrange(to_bound.NumBytesRemaining(),0);}}{auto start_acl_conn_event_it = to_bound + (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;auto start_acl_conn_event_ptr = &to_fill->start_acl_conn_event_;auto extracted_value = start_acl_conn_event_it.extract<uint16_t>();*start_acl_conn_event_ptr = static_cast<uint16_t>(extracted_value);}{auto frequency_compensation_it = to_bound + (/* Bits: */ 16 + /* Dynamic: */ 0) / 8;auto frequency_compensation_ptr = &to_fill->frequency_compensation_;auto extracted_value = frequency_compensation_it.extract<uint16_t>();*frequency_compensation_ptr = static_cast<uint16_t>(extracted_value);}{auto ranging_done_status_it = to_bound + (/* Bits: */ 32 + /* Dynamic: */ 0) / 8;auto ranging_done_status_ptr = &to_fill->ranging_done_status_;auto extracted_value = ranging_done_status_it.extract<uint8_t>();extracted_value &= 0xf;*ranging_done_status_ptr = static_cast<RangingDoneStatus>(extracted_value);}{auto subevent_done_status_it = to_bound + (/* Bits: */ 36 + /* Dynamic: */ 0) / 8;auto subevent_done_status_ptr = &to_fill->subevent_done_status_;auto extracted_value = subevent_done_status_it.extract<uint8_t>();extracted_value >>= 4;extracted_value &= 0xf;*subevent_done_status_ptr = static_cast<SubeventDoneStatus>(extracted_value);}{auto ranging_abort_reason_it = to_bound + (/* Bits: */ 40 + /* Dynamic: */ 0) / 8;auto ranging_abort_reason_ptr = &to_fill->ranging_abort_reason_;auto extracted_value = ranging_abort_reason_it.extract<uint8_t>();extracted_value &= 0xf;*ranging_abort_reason_ptr = static_cast<RangingAbortReason>(extracted_value);}{auto subevent_abort_reason_it = to_bound + (/* Bits: */ 44 + /* Dynamic: */ 0) / 8;auto subevent_abort_reason_ptr = &to_fill->subevent_abort_reason_;auto extracted_value = subevent_abort_reason_it.extract<uint8_t>();extracted_value >>= 4;extracted_value &= 0xf;*subevent_abort_reason_ptr = static_cast<SubeventAbortReason>(extracted_value);}{auto reference_power_level_it = to_bound + (/* Bits: */ 48 + /* Dynamic: */ 0) / 8;auto reference_power_level_ptr = &to_fill->reference_power_level_;auto extracted_value = reference_power_level_it.extract<uint8_t>();*reference_power_level_ptr = static_cast<uint8_t>(extracted_value);}{auto num_steps_reported_it = to_bound + (/* Bits: */ 56 + /* Dynamic: */ 0) / 8;auto num_steps_reported_ptr = &to_fill->num_steps_reported_;auto extracted_value = num_steps_reported_it.extract<uint8_t>();*num_steps_reported_ptr = static_cast<uint8_t>(extracted_value);}return struct_begin_it + to_fill->size();}
142 protected:size_t BitsOfHeader() const {return 0 + /* Bits: */ 16 + /* Dynamic: */ 0 + /* Bits: */ 16 + /* Dynamic: */ 0 + /* Bits: */ 4 + /* Dynamic: */ 0 + /* Bits: */ 4 + /* Dynamic: */ 0 + /* Bits: */ 4 + /* Dynamic: */ 0 + /* Bits: */ 4 + /* Dynamic: */ 0 + /* Bits: */ 8 + /* Dynamic: */ 0 + /* Bits: */ 8 + /* Dynamic: */ 0;}
143
144 size_t BitsOfFooter() const {return 0;}
145
146 public:virtual size_t size() const override {return (BitsOfHeader() / 8) + (BitsOfFooter() / 8);}
147
148
149
150 std::string ToString() const {std::stringstream ss;ss << std::hex << std::showbase << "RasSubeventHeader { ";ss << "start_acl_conn_event = " << static_cast<uint64_t>(start_acl_conn_event_) << ", frequency_compensation = " << static_cast<uint64_t>(frequency_compensation_) << ", ranging_done_status = " << RangingDoneStatusText(ranging_done_status_) << ", subevent_done_status = " << SubeventDoneStatusText(subevent_done_status_) << ", ranging_abort_reason = " << RangingAbortReasonText(ranging_abort_reason_) << ", subevent_abort_reason = " << SubeventAbortReasonText(subevent_abort_reason_) << ", reference_power_level = " << static_cast<uint64_t>(reference_power_level_) << ", num_steps_reported = " << static_cast<uint64_t>(num_steps_reported_);ss << " }";return ss.str();}
151
152 uint16_t start_acl_conn_event_{};uint16_t frequency_compensation_{};RangingDoneStatus ranging_done_status_{};SubeventDoneStatus subevent_done_status_{};RangingAbortReason ranging_abort_reason_{};SubeventAbortReason subevent_abort_reason_{};uint8_t reference_power_level_{};uint8_t num_steps_reported_{};};
153
154
RangingHeader()155 class RangingHeader : public PacketStruct<kLittleEndian> { public:RangingHeader() {}
156 RangingHeader(uint16_t ranging_counter, uint8_t configuration_id, uint8_t selected_tx_power, uint8_t antenna_paths_mask, PctFormat pct_format)
157 : ranging_counter_(ranging_counter), configuration_id_(configuration_id), selected_tx_power_(selected_tx_power), antenna_paths_mask_(antenna_paths_mask), pct_format_(pct_format)
158 {}
159 public:
160 virtual ~RangingHeader() = default;
161 protected:void SerializeHeader(BitInserter& i ) const {insert(ranging_counter_, i,12);insert(configuration_id_, i,4);i.insert_byte(selected_tx_power_);insert(antenna_paths_mask_, i,4);insert(static_cast<uint8_t>(0) /* Reserved */, i, 2 );
162 insert(static_cast<uint8_t>(pct_format_), i, 2);}
163
164 void SerializeFooter(BitInserter&) const {}
165
166 public:virtual void Serialize(BitInserter& i) const override {SerializeHeader(i);SerializeFooter(i);}
167
168 static Iterator<kLittleEndian> Parse(RangingHeader* to_fill, Iterator<kLittleEndian> struct_begin_it ) {auto to_bound = struct_begin_it;size_t end_index = struct_begin_it.NumBytesRemaining();if (end_index < 4){ return struct_begin_it.Subrange(0,0);}{if (to_bound.NumBytesRemaining() < 4){ return to_bound.Subrange(to_bound.NumBytesRemaining(),0);}}{auto ranging_counter_it = to_bound + (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;auto ranging_counter_ptr = &to_fill->ranging_counter_;auto extracted_value = ranging_counter_it.extract<uint16_t>();extracted_value &= 0xfff;*ranging_counter_ptr = static_cast<uint16_t>(extracted_value);}{auto configuration_id_it = to_bound + (/* Bits: */ 12 + /* Dynamic: */ 0) / 8;auto configuration_id_ptr = &to_fill->configuration_id_;auto extracted_value = configuration_id_it.extract<uint8_t>();extracted_value >>= 4;extracted_value &= 0xf;*configuration_id_ptr = static_cast<uint8_t>(extracted_value);}{auto selected_tx_power_it = to_bound + (/* Bits: */ 16 + /* Dynamic: */ 0) / 8;auto selected_tx_power_ptr = &to_fill->selected_tx_power_;auto extracted_value = selected_tx_power_it.extract<uint8_t>();*selected_tx_power_ptr = static_cast<uint8_t>(extracted_value);}{auto antenna_paths_mask_it = to_bound + (/* Bits: */ 24 + /* Dynamic: */ 0) / 8;auto antenna_paths_mask_ptr = &to_fill->antenna_paths_mask_;auto extracted_value = antenna_paths_mask_it.extract<uint8_t>();extracted_value &= 0xf;*antenna_paths_mask_ptr = static_cast<uint8_t>(extracted_value);}{auto pct_format_it = to_bound + (/* Bits: */ 30 + /* Dynamic: */ 0) / 8;auto pct_format_ptr = &to_fill->pct_format_;auto extracted_value = pct_format_it.extract<uint8_t>();extracted_value >>= 6;extracted_value &= 0x3;*pct_format_ptr = static_cast<PctFormat>(extracted_value);}return struct_begin_it + to_fill->size();}
169 protected:size_t BitsOfHeader() const {return 0 + /* Bits: */ 12 + /* Dynamic: */ 0 + /* Bits: */ 4 + /* Dynamic: */ 0 + /* Bits: */ 8 + /* Dynamic: */ 0 + /* Bits: */ 4 + /* Dynamic: */ 0 + /* Bits: */ 2 + /* Dynamic: */ 0 + /* Bits: */ 2 + /* Dynamic: */ 0;}
170
171 size_t BitsOfFooter() const {return 0;}
172
173 public:virtual size_t size() const override {return (BitsOfHeader() / 8) + (BitsOfFooter() / 8);}
174
175
176
177 std::string ToString() const {std::stringstream ss;ss << std::hex << std::showbase << "RangingHeader { ";ss << "ranging_counter = " << static_cast<uint64_t>(ranging_counter_) << ", configuration_id = " << static_cast<uint64_t>(configuration_id_) << ", selected_tx_power = " << static_cast<uint64_t>(selected_tx_power_) << ", antenna_paths_mask = " << static_cast<uint64_t>(antenna_paths_mask_) << ", pct_format = " << PctFormatText(pct_format_);ss << " }";return ss.str();}
178
179 uint16_t ranging_counter_{};uint8_t configuration_id_{};uint8_t selected_tx_power_{};uint8_t antenna_paths_mask_{};PctFormat pct_format_{};};
180
181
SegmentationHeader()182 class SegmentationHeader : public PacketStruct<kLittleEndian> { public:SegmentationHeader() {}
183 SegmentationHeader(uint8_t first_segment, uint8_t last_segment, uint8_t rolling_segment_counter)
184 : first_segment_(first_segment), last_segment_(last_segment), rolling_segment_counter_(rolling_segment_counter)
185 {}
186 public:
187 virtual ~SegmentationHeader() = default;
188 protected:void SerializeHeader(BitInserter& i ) const {insert(first_segment_, i,1);insert(last_segment_, i,1);insert(rolling_segment_counter_, i,6);}
189
190 void SerializeFooter(BitInserter&) const {}
191
192 public:virtual void Serialize(BitInserter& i) const override {SerializeHeader(i);SerializeFooter(i);}
193
194 static Iterator<kLittleEndian> Parse(SegmentationHeader* to_fill, Iterator<kLittleEndian> struct_begin_it ) {auto to_bound = struct_begin_it;size_t end_index = struct_begin_it.NumBytesRemaining();if (end_index < 1){ return struct_begin_it.Subrange(0,0);}{if (to_bound.NumBytesRemaining() < 1){ return to_bound.Subrange(to_bound.NumBytesRemaining(),0);}}{auto first_segment_it = to_bound + (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;auto first_segment_ptr = &to_fill->first_segment_;auto extracted_value = first_segment_it.extract<uint8_t>();extracted_value &= 0x1;*first_segment_ptr = static_cast<uint8_t>(extracted_value);}{auto last_segment_it = to_bound + (/* Bits: */ 1 + /* Dynamic: */ 0) / 8;auto last_segment_ptr = &to_fill->last_segment_;auto extracted_value = last_segment_it.extract<uint8_t>();extracted_value >>= 1;extracted_value &= 0x1;*last_segment_ptr = static_cast<uint8_t>(extracted_value);}{auto rolling_segment_counter_it = to_bound + (/* Bits: */ 2 + /* Dynamic: */ 0) / 8;auto rolling_segment_counter_ptr = &to_fill->rolling_segment_counter_;auto extracted_value = rolling_segment_counter_it.extract<uint8_t>();extracted_value >>= 2;extracted_value &= 0x3f;*rolling_segment_counter_ptr = static_cast<uint8_t>(extracted_value);}return struct_begin_it + to_fill->size();}
195 protected:size_t BitsOfHeader() const {return 0 + /* Bits: */ 1 + /* Dynamic: */ 0 + /* Bits: */ 1 + /* Dynamic: */ 0 + /* Bits: */ 6 + /* Dynamic: */ 0;}
196
197 size_t BitsOfFooter() const {return 0;}
198
199 public:virtual size_t size() const override {return (BitsOfHeader() / 8) + (BitsOfFooter() / 8);}
200
201
202
203 std::string ToString() const {std::stringstream ss;ss << std::hex << std::showbase << "SegmentationHeader { ";ss << "first_segment = " << static_cast<uint64_t>(first_segment_) << ", last_segment = " << static_cast<uint64_t>(last_segment_) << ", rolling_segment_counter = " << static_cast<uint64_t>(rolling_segment_counter_);ss << " }";return ss.str();}
204
205 uint8_t first_segment_{};uint8_t last_segment_{};uint8_t rolling_segment_counter_{};};
206
207
208
209
CreateOptional(PacketView<kLittleEndian> packet)210 class RasSubeventView : public PacketView<kLittleEndian> { public:static RasSubeventView Create(PacketView<kLittleEndian> packet){ return RasSubeventView(std::move(packet)); }static std::optional<RasSubeventView> CreateOptional(PacketView<kLittleEndian> packet){ auto to_validate = RasSubeventView::Create(std::move(packet));if (to_validate.IsValid()) { return to_validate; }else {return {};}}
211 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING) || defined(FUZZ_TARGET)
212 static RasSubeventView FromBytes(std::vector<uint8_t> bytes) {auto vec = std::make_shared<std::vector<uint8_t>>(bytes);return RasSubeventView::Create(PacketView<kLittleEndian>(vec));}
213 #endif
214 RasSubeventHeader GetSubeventHeader() const {ASSERT(was_validated_);size_t end_index = size();auto to_bound = begin();size_t field_begin = (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;size_t field_end = field_begin + (/* Bits: */ 64 + /* Dynamic: */ 0) / 8;if (field_end > end_index) { field_end = end_index; }auto subevent_header_it = to_bound.Subrange(field_begin, field_end - field_begin); RasSubeventHeader subevent_header_value{};RasSubeventHeader* subevent_header_ptr = &subevent_header_value;subevent_header_it = RasSubeventHeader::Parse(subevent_header_ptr, subevent_header_it);return subevent_header_value;}
215
216 std::vector<uint8_t> GetSubeventData() const {ASSERT(was_validated_);size_t end_index = size();auto to_bound = begin();size_t field_begin = (/* Bits: */ 64 + /* Dynamic: */ 0) / 8;size_t field_end = end_index - (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;auto subevent_data_it = to_bound.Subrange(field_begin, field_end - field_begin); std::vector<uint8_t> subevent_data_value{};std::vector<uint8_t>* subevent_data_ptr = &subevent_data_value;auto val_it = subevent_data_it;while (val_it.NumBytesRemaining() >= 1) {uint8_t val_value;uint8_t* val_ptr = &val_value;auto extracted_value = val_it.extract<uint8_t>();*val_ptr = static_cast<uint8_t>(extracted_value);if (val_ptr != nullptr) { subevent_data_ptr->push_back(val_value);}}return subevent_data_value;}
217
218 bool IsValid() {
219 if (was_validated_) {
220 return true;
221 } else {
222 was_validated_ = true;
223 return (was_validated_ = Validate());
224 }
225 }
226 protected:
227 virtual bool Validate() const {
228 auto it = begin() + (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;it += 8 /* Total size of the fixed fields */;if (it > end()) return false;
229
230 return true;}
231 bool was_validated_{false};
232
233 public:virtual std::string ToString() const {std::stringstream ss;ss << std::showbase << std::hex << "RasSubevent { ";ss << "" << "subevent_header = " << GetSubeventHeader().ToString() << ", subevent_data = " << "VECTOR[";for (size_t index = 0; index < GetSubeventData().size(); index++) {ss << ((index == 0) ? "" : ", ") << static_cast<uint64_t>((GetSubeventData()[index]));}ss << "]";ss << " }";return ss.str();}
234
235 protected:
236 explicit RasSubeventView(PacketView<kLittleEndian> packet) : PacketView<kLittleEndian>(packet) { was_validated_ = false;}};
237
238
CreateOptional(PacketView<kLittleEndian> packet)239 class FirstRangingDataSegmentView : public PacketView<kLittleEndian> { public:static FirstRangingDataSegmentView Create(PacketView<kLittleEndian> packet){ return FirstRangingDataSegmentView(std::move(packet)); }static std::optional<FirstRangingDataSegmentView> CreateOptional(PacketView<kLittleEndian> packet){ auto to_validate = FirstRangingDataSegmentView::Create(std::move(packet));if (to_validate.IsValid()) { return to_validate; }else {return {};}}
240 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING) || defined(FUZZ_TARGET)
241 static FirstRangingDataSegmentView FromBytes(std::vector<uint8_t> bytes) {auto vec = std::make_shared<std::vector<uint8_t>>(bytes);return FirstRangingDataSegmentView::Create(PacketView<kLittleEndian>(vec));}
242 #endif
243 SegmentationHeader GetSegmentationHeader() const {ASSERT(was_validated_);size_t end_index = size();auto to_bound = begin();size_t field_begin = (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;size_t field_end = field_begin + (/* Bits: */ 8 + /* Dynamic: */ 0) / 8;if (field_end > end_index) { field_end = end_index; }auto segmentation_header_it = to_bound.Subrange(field_begin, field_end - field_begin); SegmentationHeader segmentation_header_value{};SegmentationHeader* segmentation_header_ptr = &segmentation_header_value;segmentation_header_it = SegmentationHeader::Parse(segmentation_header_ptr, segmentation_header_it);return segmentation_header_value;}
244
245 RangingHeader GetRangingHeader() const {ASSERT(was_validated_);size_t end_index = size();auto to_bound = begin();size_t field_begin = (/* Bits: */ 8 + /* Dynamic: */ 0) / 8;size_t field_end = field_begin + (/* Bits: */ 32 + /* Dynamic: */ 0) / 8;if (field_end > end_index) { field_end = end_index; }auto ranging_header_it = to_bound.Subrange(field_begin, field_end - field_begin); RangingHeader ranging_header_value{};RangingHeader* ranging_header_ptr = &ranging_header_value;ranging_header_it = RangingHeader::Parse(ranging_header_ptr, ranging_header_it);return ranging_header_value;}
246
247 std::vector<uint8_t> GetData() const {ASSERT(was_validated_);size_t end_index = size();auto to_bound = begin();size_t field_begin = (/* Bits: */ 40 + /* Dynamic: */ 0) / 8;size_t field_end = end_index - (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;auto data_it = to_bound.Subrange(field_begin, field_end - field_begin); std::vector<uint8_t> data_value{};std::vector<uint8_t>* data_ptr = &data_value;auto val_it = data_it;while (val_it.NumBytesRemaining() >= 1) {uint8_t val_value;uint8_t* val_ptr = &val_value;auto extracted_value = val_it.extract<uint8_t>();*val_ptr = static_cast<uint8_t>(extracted_value);if (val_ptr != nullptr) { data_ptr->push_back(val_value);}}return data_value;}
248
249 bool IsValid() {
250 if (was_validated_) {
251 return true;
252 } else {
253 was_validated_ = true;
254 return (was_validated_ = Validate());
255 }
256 }
257 protected:
258 virtual bool Validate() const {
259 auto it = begin() + (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;it += 5 /* Total size of the fixed fields */;if (it > end()) return false;
260
261
262 return true;}
263 bool was_validated_{false};
264
265 public:virtual std::string ToString() const {std::stringstream ss;ss << std::showbase << std::hex << "FirstRangingDataSegment { ";ss << "" << "segmentation_header = " << GetSegmentationHeader().ToString() << ", ranging_header = " << GetRangingHeader().ToString() << ", data = " << "VECTOR[";for (size_t index = 0; index < GetData().size(); index++) {ss << ((index == 0) ? "" : ", ") << static_cast<uint64_t>((GetData()[index]));}ss << "]";ss << " }";return ss.str();}
266
267 protected:
268 explicit FirstRangingDataSegmentView(PacketView<kLittleEndian> packet) : PacketView<kLittleEndian>(packet) { was_validated_ = false;}};
269
270
CreateOptional(PacketView<kLittleEndian> packet)271 class RangingDataSegmentView : public PacketView<kLittleEndian> { public:static RangingDataSegmentView Create(PacketView<kLittleEndian> packet){ return RangingDataSegmentView(std::move(packet)); }static std::optional<RangingDataSegmentView> CreateOptional(PacketView<kLittleEndian> packet){ auto to_validate = RangingDataSegmentView::Create(std::move(packet));if (to_validate.IsValid()) { return to_validate; }else {return {};}}
272 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING) || defined(FUZZ_TARGET)
273 static RangingDataSegmentView FromBytes(std::vector<uint8_t> bytes) {auto vec = std::make_shared<std::vector<uint8_t>>(bytes);return RangingDataSegmentView::Create(PacketView<kLittleEndian>(vec));}
274 #endif
275 SegmentationHeader GetSegmentationHeader() const {ASSERT(was_validated_);size_t end_index = size();auto to_bound = begin();size_t field_begin = (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;size_t field_end = field_begin + (/* Bits: */ 8 + /* Dynamic: */ 0) / 8;if (field_end > end_index) { field_end = end_index; }auto segmentation_header_it = to_bound.Subrange(field_begin, field_end - field_begin); SegmentationHeader segmentation_header_value{};SegmentationHeader* segmentation_header_ptr = &segmentation_header_value;segmentation_header_it = SegmentationHeader::Parse(segmentation_header_ptr, segmentation_header_it);return segmentation_header_value;}
276
277 std::vector<uint8_t> GetData() const {ASSERT(was_validated_);size_t end_index = size();auto to_bound = begin();size_t field_begin = (/* Bits: */ 8 + /* Dynamic: */ 0) / 8;size_t field_end = end_index - (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;auto data_it = to_bound.Subrange(field_begin, field_end - field_begin); std::vector<uint8_t> data_value{};std::vector<uint8_t>* data_ptr = &data_value;auto val_it = data_it;while (val_it.NumBytesRemaining() >= 1) {uint8_t val_value;uint8_t* val_ptr = &val_value;auto extracted_value = val_it.extract<uint8_t>();*val_ptr = static_cast<uint8_t>(extracted_value);if (val_ptr != nullptr) { data_ptr->push_back(val_value);}}return data_value;}
278
279 bool IsValid() {
280 if (was_validated_) {
281 return true;
282 } else {
283 was_validated_ = true;
284 return (was_validated_ = Validate());
285 }
286 }
287 protected:
288 virtual bool Validate() const {
289 auto it = begin() + (/* Bits: */ 0 + /* Dynamic: */ 0) / 8;it += 1 /* Total size of the fixed fields */;if (it > end()) return false;
290
291 return true;}
292 bool was_validated_{false};
293
294 public:virtual std::string ToString() const {std::stringstream ss;ss << std::showbase << std::hex << "RangingDataSegment { ";ss << "" << "segmentation_header = " << GetSegmentationHeader().ToString() << ", data = " << "VECTOR[";for (size_t index = 0; index < GetData().size(); index++) {ss << ((index == 0) ? "" : ", ") << static_cast<uint64_t>((GetData()[index]));}ss << "]";ss << " }";return ss.str();}
295
296 protected:
297 explicit RangingDataSegmentView(PacketView<kLittleEndian> packet) : PacketView<kLittleEndian>(packet) { was_validated_ = false;}};
298
299
Create(RasSubeventHeader subevent_header,const std::vector<uint8_t> & subevent_data)300 class RasSubeventBuilder : public PacketBuilder<kLittleEndian> { public: virtual ~RasSubeventBuilder() = default;static std::unique_ptr<RasSubeventBuilder> Create(RasSubeventHeader subevent_header, const std::vector<uint8_t>& subevent_data) {auto builder = std::unique_ptr<RasSubeventBuilder>(new RasSubeventBuilder(subevent_header, subevent_data));return builder;}
301
302 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING) || defined(FUZZ_TARGET)
303 static std::unique_ptr<RasSubeventBuilder> FromView(RasSubeventView view) {if (!view.IsValid()) return nullptr;return RasSubeventBuilder::Create(view.GetSubeventHeader(), view.GetSubeventData());}
304 #endif
305
306 protected:void SerializeHeader(BitInserter& i ) const {subevent_header_.Serialize(i);for (const auto& val_ : subevent_data_) {i.insert_byte(val_);}
307 }
308
309 void SerializeFooter(BitInserter&) const {}
310
311 public:virtual void Serialize(BitInserter& i) const override {SerializeHeader(i);SerializeFooter(i);}
312
313 protected:size_t BitsOfHeader() const {return 0 + /* Bits: */ 0 + /* Dynamic: */ (subevent_header_.size() * 8) + /* Bits: */ 0 + /* Dynamic: */ (static_cast<size_t>(subevent_data_.size()) * 8);}
314
315 size_t BitsOfFooter() const {return 0;}
316
317 public:virtual size_t size() const override {return (BitsOfHeader() / 8) + (BitsOfFooter() / 8);}
318
319 protected:
320 explicit RasSubeventBuilder(RasSubeventHeader subevent_header, const std::vector<uint8_t>& subevent_data) :subevent_header_(subevent_header),subevent_data_(subevent_data) {}
321
322
323 RasSubeventHeader subevent_header_{};std::vector<uint8_t> subevent_data_{};};
324 #ifdef PACKET_TESTING
325 #define DEFINE_AND_INSTANTIATE_RasSubeventReflectionTest(...)class RasSubeventReflectionTest : public testing::TestWithParam<std::vector<uint8_t>> { public: void CompareBytes(std::vector<uint8_t> captured_packet) {RasSubeventView view = RasSubeventView::FromBytes(captured_packet);if (!view.IsValid()) { log::info("Invalid Packet Bytes (size = {})", view.size());for (size_t i = 0; i < view.size(); i++) { log::info("{:5}:{:02x}", i, *(view.begin() + i)); }}ASSERT_TRUE(view.IsValid());auto packet = RasSubeventBuilder::FromView(view);std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();packet_bytes->reserve(packet->size());BitInserter it(*packet_bytes);packet->Serialize(it);ASSERT_EQ(*packet_bytes, captured_packet);}};TEST_P(RasSubeventReflectionTest, generatedReflectionTest) {CompareBytes(GetParam());}INSTANTIATE_TEST_SUITE_P(RasSubevent_reflection, RasSubeventReflectionTest, testing::Values(__VA_ARGS__))
326 #endif
327 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING)
328 #define DEFINE_RasSubeventReflectionFuzzTest() void RunRasSubeventReflectionFuzzTest(const uint8_t* data, size_t size) {auto vec = std::vector<uint8_t>(data, data + size);RasSubeventView view = RasSubeventView::FromBytes(vec);if (!view.IsValid()) { return; }auto packet = RasSubeventBuilder::FromView(view);std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();packet_bytes->reserve(packet->size());BitInserter it(*packet_bytes);packet->Serialize(it);}
329 #endif
330
331 #ifdef PACKET_FUZZ_TESTING
332 #define DEFINE_AND_REGISTER_RasSubeventReflectionFuzzTest(REGISTRY) DEFINE_RasSubeventReflectionFuzzTest(); class RasSubeventReflectionFuzzTestRegistrant {public: explicit RasSubeventReflectionFuzzTestRegistrant(std::vector<void(*)(const uint8_t*, size_t)>& fuzz_test_registry) {fuzz_test_registry.push_back(RunRasSubeventReflectionFuzzTest);}}; RasSubeventReflectionFuzzTestRegistrant RasSubevent_reflection_fuzz_test_registrant(REGISTRY);
333 #endif
334
335
Create(SegmentationHeader segmentation_header,RangingHeader ranging_header,const std::vector<uint8_t> & data)336 class FirstRangingDataSegmentBuilder : public PacketBuilder<kLittleEndian> { public: virtual ~FirstRangingDataSegmentBuilder() = default;static std::unique_ptr<FirstRangingDataSegmentBuilder> Create(SegmentationHeader segmentation_header, RangingHeader ranging_header, const std::vector<uint8_t>& data) {auto builder = std::unique_ptr<FirstRangingDataSegmentBuilder>(new FirstRangingDataSegmentBuilder(segmentation_header, ranging_header, data));return builder;}
337
338 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING) || defined(FUZZ_TARGET)
339 static std::unique_ptr<FirstRangingDataSegmentBuilder> FromView(FirstRangingDataSegmentView view) {if (!view.IsValid()) return nullptr;return FirstRangingDataSegmentBuilder::Create(view.GetSegmentationHeader(), view.GetRangingHeader(), view.GetData());}
340 #endif
341
342 protected:void SerializeHeader(BitInserter& i ) const {segmentation_header_.Serialize(i);ranging_header_.Serialize(i);for (const auto& val_ : data_) {i.insert_byte(val_);}
343 }
344
345 void SerializeFooter(BitInserter&) const {}
346
347 public:virtual void Serialize(BitInserter& i) const override {SerializeHeader(i);SerializeFooter(i);}
348
349 protected:size_t BitsOfHeader() const {return 0 + /* Bits: */ 0 + /* Dynamic: */ (segmentation_header_.size() * 8) + /* Bits: */ 0 + /* Dynamic: */ (ranging_header_.size() * 8) + /* Bits: */ 0 + /* Dynamic: */ (static_cast<size_t>(data_.size()) * 8);}
350
351 size_t BitsOfFooter() const {return 0;}
352
353 public:virtual size_t size() const override {return (BitsOfHeader() / 8) + (BitsOfFooter() / 8);}
354
355 protected:
356 explicit FirstRangingDataSegmentBuilder(SegmentationHeader segmentation_header, RangingHeader ranging_header, const std::vector<uint8_t>& data) :segmentation_header_(segmentation_header),ranging_header_(ranging_header),data_(data) {}
357
358
359 SegmentationHeader segmentation_header_{};RangingHeader ranging_header_{};std::vector<uint8_t> data_{};};
360 #ifdef PACKET_TESTING
361 #define DEFINE_AND_INSTANTIATE_FirstRangingDataSegmentReflectionTest(...)class FirstRangingDataSegmentReflectionTest : public testing::TestWithParam<std::vector<uint8_t>> { public: void CompareBytes(std::vector<uint8_t> captured_packet) {FirstRangingDataSegmentView view = FirstRangingDataSegmentView::FromBytes(captured_packet);if (!view.IsValid()) { log::info("Invalid Packet Bytes (size = {})", view.size());for (size_t i = 0; i < view.size(); i++) { log::info("{:5}:{:02x}", i, *(view.begin() + i)); }}ASSERT_TRUE(view.IsValid());auto packet = FirstRangingDataSegmentBuilder::FromView(view);std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();packet_bytes->reserve(packet->size());BitInserter it(*packet_bytes);packet->Serialize(it);ASSERT_EQ(*packet_bytes, captured_packet);}};TEST_P(FirstRangingDataSegmentReflectionTest, generatedReflectionTest) {CompareBytes(GetParam());}INSTANTIATE_TEST_SUITE_P(FirstRangingDataSegment_reflection, FirstRangingDataSegmentReflectionTest, testing::Values(__VA_ARGS__))
362 #endif
363 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING)
364 #define DEFINE_FirstRangingDataSegmentReflectionFuzzTest() void RunFirstRangingDataSegmentReflectionFuzzTest(const uint8_t* data, size_t size) {auto vec = std::vector<uint8_t>(data, data + size);FirstRangingDataSegmentView view = FirstRangingDataSegmentView::FromBytes(vec);if (!view.IsValid()) { return; }auto packet = FirstRangingDataSegmentBuilder::FromView(view);std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();packet_bytes->reserve(packet->size());BitInserter it(*packet_bytes);packet->Serialize(it);}
365 #endif
366
367 #ifdef PACKET_FUZZ_TESTING
368 #define DEFINE_AND_REGISTER_FirstRangingDataSegmentReflectionFuzzTest(REGISTRY) DEFINE_FirstRangingDataSegmentReflectionFuzzTest(); class FirstRangingDataSegmentReflectionFuzzTestRegistrant {public: explicit FirstRangingDataSegmentReflectionFuzzTestRegistrant(std::vector<void(*)(const uint8_t*, size_t)>& fuzz_test_registry) {fuzz_test_registry.push_back(RunFirstRangingDataSegmentReflectionFuzzTest);}}; FirstRangingDataSegmentReflectionFuzzTestRegistrant FirstRangingDataSegment_reflection_fuzz_test_registrant(REGISTRY);
369 #endif
370
371
Create(SegmentationHeader segmentation_header,const std::vector<uint8_t> & data)372 class RangingDataSegmentBuilder : public PacketBuilder<kLittleEndian> { public: virtual ~RangingDataSegmentBuilder() = default;static std::unique_ptr<RangingDataSegmentBuilder> Create(SegmentationHeader segmentation_header, const std::vector<uint8_t>& data) {auto builder = std::unique_ptr<RangingDataSegmentBuilder>(new RangingDataSegmentBuilder(segmentation_header, data));return builder;}
373
374 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING) || defined(FUZZ_TARGET)
375 static std::unique_ptr<RangingDataSegmentBuilder> FromView(RangingDataSegmentView view) {if (!view.IsValid()) return nullptr;return RangingDataSegmentBuilder::Create(view.GetSegmentationHeader(), view.GetData());}
376 #endif
377
378 protected:void SerializeHeader(BitInserter& i ) const {segmentation_header_.Serialize(i);for (const auto& val_ : data_) {i.insert_byte(val_);}
379 }
380
381 void SerializeFooter(BitInserter&) const {}
382
383 public:virtual void Serialize(BitInserter& i) const override {SerializeHeader(i);SerializeFooter(i);}
384
385 protected:size_t BitsOfHeader() const {return 0 + /* Bits: */ 0 + /* Dynamic: */ (segmentation_header_.size() * 8) + /* Bits: */ 0 + /* Dynamic: */ (static_cast<size_t>(data_.size()) * 8);}
386
387 size_t BitsOfFooter() const {return 0;}
388
389 public:virtual size_t size() const override {return (BitsOfHeader() / 8) + (BitsOfFooter() / 8);}
390
391 protected:
392 explicit RangingDataSegmentBuilder(SegmentationHeader segmentation_header, const std::vector<uint8_t>& data) :segmentation_header_(segmentation_header),data_(data) {}
393
394
395 SegmentationHeader segmentation_header_{};std::vector<uint8_t> data_{};};
396 #ifdef PACKET_TESTING
397 #define DEFINE_AND_INSTANTIATE_RangingDataSegmentReflectionTest(...)class RangingDataSegmentReflectionTest : public testing::TestWithParam<std::vector<uint8_t>> { public: void CompareBytes(std::vector<uint8_t> captured_packet) {RangingDataSegmentView view = RangingDataSegmentView::FromBytes(captured_packet);if (!view.IsValid()) { log::info("Invalid Packet Bytes (size = {})", view.size());for (size_t i = 0; i < view.size(); i++) { log::info("{:5}:{:02x}", i, *(view.begin() + i)); }}ASSERT_TRUE(view.IsValid());auto packet = RangingDataSegmentBuilder::FromView(view);std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();packet_bytes->reserve(packet->size());BitInserter it(*packet_bytes);packet->Serialize(it);ASSERT_EQ(*packet_bytes, captured_packet);}};TEST_P(RangingDataSegmentReflectionTest, generatedReflectionTest) {CompareBytes(GetParam());}INSTANTIATE_TEST_SUITE_P(RangingDataSegment_reflection, RangingDataSegmentReflectionTest, testing::Values(__VA_ARGS__))
398 #endif
399 #if defined(PACKET_FUZZ_TESTING) || defined(PACKET_TESTING)
400 #define DEFINE_RangingDataSegmentReflectionFuzzTest() void RunRangingDataSegmentReflectionFuzzTest(const uint8_t* data, size_t size) {auto vec = std::vector<uint8_t>(data, data + size);RangingDataSegmentView view = RangingDataSegmentView::FromBytes(vec);if (!view.IsValid()) { return; }auto packet = RangingDataSegmentBuilder::FromView(view);std::shared_ptr<std::vector<uint8_t>> packet_bytes = std::make_shared<std::vector<uint8_t>>();packet_bytes->reserve(packet->size());BitInserter it(*packet_bytes);packet->Serialize(it);}
401 #endif
402
403 #ifdef PACKET_FUZZ_TESTING
404 #define DEFINE_AND_REGISTER_RangingDataSegmentReflectionFuzzTest(REGISTRY) DEFINE_RangingDataSegmentReflectionFuzzTest(); class RangingDataSegmentReflectionFuzzTestRegistrant {public: explicit RangingDataSegmentReflectionFuzzTestRegistrant(std::vector<void(*)(const uint8_t*, size_t)>& fuzz_test_registry) {fuzz_test_registry.push_back(RunRangingDataSegmentReflectionFuzzTest);}}; RangingDataSegmentReflectionFuzzTestRegistrant RangingDataSegment_reflection_fuzz_test_registrant(REGISTRY);
405 #endif
406
407
408 } //namespace ras
409 } //namespace bluetooth
410 #if __has_include(<bluetooth/log.h>)
411 namespace std {
412 template <>
413 struct formatter<bluetooth::ras::PctFormat> : enum_formatter<bluetooth::ras::PctFormat> {};
414 template <>
415 struct formatter<bluetooth::ras::RangingDoneStatus> : enum_formatter<bluetooth::ras::RangingDoneStatus> {};
416 template <>
417 struct formatter<bluetooth::ras::SubeventDoneStatus> : enum_formatter<bluetooth::ras::SubeventDoneStatus> {};
418 template <>
419 struct formatter<bluetooth::ras::RangingAbortReason> : enum_formatter<bluetooth::ras::RangingAbortReason> {};
420 template <>
421 struct formatter<bluetooth::ras::SubeventAbortReason> : enum_formatter<bluetooth::ras::SubeventAbortReason> {};
422 } // namespace std
423 #endif // __has_include(<bluetooth/log.h>)
424