EchoMap 2026-07-25 6d3977c
An experimental cross-platform digital signal processing application for sound-source localisation.
Loading...
Searching...
No Matches
echomap::JSONDeserialiserHelpers Class Reference

Provides a set of static helpers for parsing Project fields with SIMDJSON. More...

#include <JSONDeserialiserHelpers.hpp>

Static Public Member Functions

template<typename simdjson_value>
static simdjson::error_code get_root (simdjson::ondemand::object &root, simdjson_value &value)
static simdjson::error_code get_metadata (simdjson::ondemand::object &root, Project &project)
static simdjson::error_code get_sensors (simdjson::ondemand::object &root, Project &project, std::unordered_map< std::string_view, id_type > &loaded)
static simdjson::error_code get_mappings (simdjson::ondemand::object &root, Project &project, const std::unordered_map< std::string_view, id_type > &signals, const std::unordered_map< std::string_view, id_type > &sensors)
static void verify_sample_count (std::uint64_t reported_sample_count, const Signal &signal)
template<typename ValueT>
static simdjson::error_code get_or_default (simdjson::ondemand::object &obj, const std::string_view key, ValueT &out, const ValueT &fallback)
static simdjson::error_code get_uniformly_sampled_signal_source (simdjson::ondemand::object &source, const SignalFactory &signal_factory)
static simdjson::error_code get_variably_sampled_signal_source (simdjson::ondemand::object &source, const SignalFactory &signal_factory)

Detailed Description

Provides a set of static helpers for parsing Project fields with SIMDJSON.

Todo
Document member functions and sequence points in the simdjson namespace.

Definition at line 31 of file JSONDeserialiserHelpers.hpp.

Member Function Documentation

◆ get_mappings()

simdjson::error_code echomap::JSONDeserialiserHelpers::get_mappings ( simdjson::ondemand::object & root,
Project & project,
const std::unordered_map< std::string_view, id_type > & signals,
const std::unordered_map< std::string_view, id_type > & sensors )
static

Definition at line 57 of file JSONDeserialiserHelpers.cpp.

67{
68 simdjson::ondemand::array mappings;
69 auto error = root["mappings"].get_array().get(mappings);
70 if (error)
71 return error;
72
73 for (auto mapping : mappings) {
74 simdjson::ondemand::object mapping_obj;
75 if ((error = mapping.get_object().get(mapping_obj)))
76 return error;
77
78 std::string_view signal_name;
79 std::string_view sensor_name;
80
81 if ((error = mapping_obj["signal"].get(signal_name)))
82 return error;
83
84 if ((error = mapping_obj["sensor"].get(sensor_name)))
85 return error;
86
87 const auto signal_it = signals.find(signal_name);
88 if (signal_it == signals.end())
89 throw std::runtime_error(std::format("Channel mapping referred to non-existent signal {}.", signal_name));
90
91 const auto sensor_it = sensors.find(sensor_name);
92 if (sensor_it == sensors.end())
93 throw std::runtime_error(std::format("Channel mapping referred to non-existent sensor {}.", sensor_name));
94
95 project.add_association(signal_it->second, sensor_it->second);
96 }
97
98 return simdjson::SUCCESS;
99}
std::unordered_map::end
T end(T... args)
std::unordered_map::find
T find(T... args)
std::format
T format(T... args)

◆ get_metadata()

simdjson::error_code echomap::JSONDeserialiserHelpers::get_metadata ( simdjson::ondemand::object & root,
Project & project )
static

Definition at line 18 of file JSONDeserialiserHelpers.cpp.

22{
23 simdjson::ondemand::object metadata;
24 auto error = root["metadata"].get_object().get(metadata);
25 if (error)
26 return error;
27
28 std::string project_name;
29 if ((error = metadata["name"].get(project_name)))
30 return error;
31
32 project.set_name(project_name);
33 return simdjson::SUCCESS;
34}

◆ get_or_default()

template<typename ValueT>
simdjson::error_code echomap::JSONDeserialiserHelpers::get_or_default ( simdjson::ondemand::object & obj,
const std::string_view key,
ValueT & out,
const ValueT & fallback )
inlinestatic

Definition at line 93 of file JSONDeserialiserHelpers.hpp.

99 {
100 auto field = obj[key];
101
102 if (field.error() == simdjson::NO_SUCH_FIELD) {
103 out = fallback;
104 return simdjson::SUCCESS;
105 }
106
107 return field.get(out);
108 }

◆ get_root()

template<typename simdjson_value>
simdjson::error_code echomap::JSONDeserialiserHelpers::get_root ( simdjson::ondemand::object & root,
simdjson_value & value )
inlinestatic

Definition at line 35 of file JSONDeserialiserHelpers.hpp.

39 {
40 auto error = value.get_object().get(root);
41 if (error)
42 return error;
43
44 // Schema version check.
45 static constexpr unsigned int expected_schema_version = 1;
46 unsigned int actual_schema_version = 0;
47
48 if ((error = root["schema_version"].get(actual_schema_version)))
49 return error;
50
51 if (actual_schema_version != expected_schema_version)
52 throw std::runtime_error(
53 std::format(
54 "Project file was saved in an incompatible version {} (expected {}).",
55 actual_schema_version,
56 expected_schema_version
57 )
58 );
59
60 return simdjson::SUCCESS;
61 }

◆ get_sensors()

simdjson::error_code echomap::JSONDeserialiserHelpers::get_sensors ( simdjson::ondemand::object & root,
Project & project,
std::unordered_map< std::string_view, id_type > & loaded )
static

Definition at line 36 of file JSONDeserialiserHelpers.cpp.

43{
44 std::vector<std::unique_ptr<Sensor>> sensors;
45 if (const auto error = root["sensors"].get(sensors))
46 return error;
47
48 for (auto&& sensor : sensors) {
49 if (!loaded.emplace(sensor->get_name(), sensor->get_id()).second)
50 throw std::runtime_error(std::format("Project contains duplicate sensor {}.", sensor->get_name()));
51 project.add_sensor(std::move(sensor));
52 }
53
54 return simdjson::SUCCESS;
55}
std::unordered_map::emplace
T emplace(T... args)

◆ get_uniformly_sampled_signal_source()

simdjson::error_code echomap::JSONDeserialiserHelpers::get_uniformly_sampled_signal_source ( simdjson::ondemand::object & source,
const SignalFactory & signal_factory )
static

Definition at line 117 of file JSONDeserialiserHelpers.cpp.

121{
122 std::uint64_t reported_sample_count;
123 auto error = source["sample_count"].get(reported_sample_count);
124 if (error)
125 return error;
126
127 std::size_t sample_rate;
128 if ((error = source["sample_rate"].get(sample_rate)))
129 return error;
130 signal_factory.set_sample_rate(sample_rate);
131
132 float time_offset;
133 if ((error = source["time_offset"].get(time_offset)))
134 return error;
135 signal_factory.set_time_offset(time_offset);
136
137 simdjson::ondemand::array samples;
138 if ((error = source["samples"].get_array().get(samples)))
139 return error;
140
141 for (auto sample_wrapper : samples) {
142 float amplitude;
143 if ((error = sample_wrapper.get(amplitude)))
144 return error;
145 signal_factory.emplace_sample(amplitude);
146 }
147
148 verify_sample_count(reported_sample_count, signal_factory.observe_signal());
149 return error;
150}

◆ get_variably_sampled_signal_source()

simdjson::error_code echomap::JSONDeserialiserHelpers::get_variably_sampled_signal_source ( simdjson::ondemand::object & source,
const SignalFactory & signal_factory )
static

Definition at line 152 of file JSONDeserialiserHelpers.cpp.

156{
157 std::uint64_t reported_sample_count;
158 auto error = source["sample_count"].get(reported_sample_count);
159 if (error)
160 return error;
161
162 std::size_t sample_rate;
163 if ((error = get_or_default(source, "sample_rate", sample_rate, std::size_t{0})))
164 return error;
165 signal_factory.set_sample_rate(sample_rate);
166
167 float time_offset;
168 if ((error = get_or_default(source, "time_offset", time_offset, 0.0f)))
169 return error;
170 signal_factory.set_time_offset(time_offset);
171
172 simdjson::ondemand::array samples;
173 if ((error = source["samples"].get_array().get(samples)))
174 return error;
175
176 for (auto sample_wrapper : samples) {
177 simdjson::ondemand::object sample_obj;
178 if ((error = sample_wrapper.get_object().get(sample_obj)))
179 return error;
180 Signal::Sample sample_data; // NOLINT(*-pro-type-member-init) - Immediately initialised.
181 if ((error = sample_obj["time"].get(sample_data.time)))
182 return error;
183 if ((error = sample_obj["amplitude"].get(sample_data.amplitude)))
184 return error;
185 signal_factory.emplace_sample(sample_data.time, sample_data.amplitude);
186 }
187
188 verify_sample_count(reported_sample_count, signal_factory.observe_signal());
189 return error;
190}

◆ verify_sample_count()

void echomap::JSONDeserialiserHelpers::verify_sample_count ( std::uint64_t reported_sample_count,
const Signal & signal )
static

Definition at line 101 of file JSONDeserialiserHelpers.cpp.

105{
106 if (reported_sample_count != signal.get_sample_count())
107 throw std::runtime_error(
108 std::format(
109 "Embedded signal {} reported the incorrect number of samples: claimed {}, but received {}.",
110 signal.get_name(),
111 reported_sample_count,
112 signal.get_sample_count()
113 )
114 );
115}
std::signal
T signal(T... args)
The documentation for this class was generated from the following files: