Project
Loading...
Searching...
No Matches
PropertyTreeHelpers.cxx
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
12#include "PropertyTreeHelpers.h"
13#include "Framework/ConfigParamSpec.h"
14#include "Framework/VariantPropertyTreeHelpers.h"
15#include "Framework/RuntimeError.h"
16#include "Framework/VariantJSONHelpers.h"
17#include "Framework/Signpost.h"
18
19#include <boost/program_options/variables_map.hpp>
20
21#include <vector>
22#include <string>
23
24O2_DECLARE_DYNAMIC_LOG(configuration);
25
26namespace o2::framework
27{
28namespace
29{
31template <VariantType T>
32inline Variant fromString(std::string const& str)
33{
34 std::stringstream ss;
35 ss.str(str);
36 return VariantJSONHelpers::read<T>(ss);
37}
38} // namespace
39void PropertyTreeHelpers::populateDefaults(std::vector<ConfigParamSpec> const& schema,
40 boost::property_tree::ptree& pt,
41 boost::property_tree::ptree& provenance)
42{
43 O2_SIGNPOST_ID_GENERATE(cid, configuration);
44 O2_SIGNPOST_START(configuration, cid, "populateDefaults", "Filling with defaults");
45 for (auto const& spec : schema) {
46 std::string key = spec.name.substr(0, spec.name.find(','));
47 try {
48 if (spec.defaultValue.type() == VariantType::Empty) {
49 continue;
50 }
51 switch (spec.type) {
52 case VariantType::Int:
53 pt.put(key, spec.defaultValue.get<int>());
54 break;
55 case VariantType::Int8:
56 pt.put(key, spec.defaultValue.get<int8_t>());
57 break;
58 case VariantType::Int16:
59 pt.put(key, spec.defaultValue.get<int16_t>());
60 break;
61 case VariantType::UInt8:
62 pt.put(key, spec.defaultValue.get<uint8_t>());
63 break;
64 case VariantType::UInt16:
65 pt.put(key, spec.defaultValue.get<uint16_t>());
66 break;
67 case VariantType::UInt32:
68 pt.put(key, spec.defaultValue.get<uint32_t>());
69 break;
70 case VariantType::UInt64:
71 pt.put(key, spec.defaultValue.get<uint64_t>());
72 break;
73 case VariantType::Int64:
74 pt.put(key, spec.defaultValue.get<int64_t>());
75 break;
76 case VariantType::Float:
77 pt.put(key, spec.defaultValue.get<float>());
78 break;
79 case VariantType::Double:
80 pt.put(key, spec.defaultValue.get<double>());
81 break;
82 case VariantType::String:
83 pt.put(key, spec.defaultValue.get<std::string>());
84 break;
85 case VariantType::Bool: {
86 bool value = spec.defaultValue.get<bool>();
87 O2_SIGNPOST_EVENT_EMIT(configuration, cid, "populateDefaults", "Setting %{public}s: %{public}s", key.c_str(), value ? "true" : "false");
88 pt.put(key, value);
89 break;
90 }
91 case VariantType::Dict:
92 pt.put_child(key, boost::property_tree::ptree{});
93 break;
94 case VariantType::ArrayInt:
95 pt.put_child(key, vectorToBranch(spec.defaultValue.get<int*>(), spec.defaultValue.size()));
96 break;
97 case VariantType::ArrayFloat:
98 pt.put_child(key, vectorToBranch(spec.defaultValue.get<float*>(), spec.defaultValue.size()));
99 break;
100 case VariantType::ArrayDouble:
101 pt.put_child(key, vectorToBranch(spec.defaultValue.get<double*>(), spec.defaultValue.size()));
102 break;
103 case VariantType::ArrayBool:
104 pt.put_child(key, vectorToBranch(spec.defaultValue.get<bool*>(), spec.defaultValue.size()));
105 break;
106 case VariantType::ArrayString:
107 pt.put_child(key, vectorToBranch(spec.defaultValue.get<std::string*>(), spec.defaultValue.size()));
108 break;
109 case VariantType::Array2DInt:
110 pt.put_child(key, array2DToBranch(spec.defaultValue.get<Array2D<int>>()));
111 break;
112 case VariantType::Array2DFloat:
113 pt.put_child(key, array2DToBranch(spec.defaultValue.get<Array2D<float>>()));
114 break;
115 case VariantType::Array2DDouble:
116 pt.put_child(key, array2DToBranch(spec.defaultValue.get<Array2D<double>>()));
117 break;
118 case VariantType::LabeledArrayInt:
119 pt.put_child(key, labeledArrayToBranch(spec.defaultValue.get<LabeledArray<int>>()));
120 break;
121 case VariantType::LabeledArrayFloat:
122 pt.put_child(key, labeledArrayToBranch(spec.defaultValue.get<LabeledArray<float>>()));
123 break;
124 case VariantType::LabeledArrayDouble:
125 pt.put_child(key, labeledArrayToBranch(spec.defaultValue.get<LabeledArray<double>>()));
126 break;
127 case VariantType::LabeledArrayString:
128 pt.put_child(key, labeledArrayToBranch(spec.defaultValue.get<LabeledArray<std::string>>()));
129 break;
130 case VariantType::Unknown:
131 case VariantType::Empty:
132 default:
133 throw runtime_error_f("Unknown variant type", spec.type);
134 }
135 provenance.put(key, "default");
136 } catch (std::runtime_error& re) {
137 O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populateDefaults", "Aborting because of runtime_error %{public}s", re.what());
138 throw;
139 } catch (std::exception& e) {
140 O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populateDefaults", "Missing option %{public}s (%{public}s)", key.c_str(), e.what());
141 throw std::invalid_argument(std::string("missing option: ") + key + " (" + e.what() + ")");
142 } catch (...) {
143 O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populateDefaults", "Aborting because of missing option %{public}s", key.c_str());
144 throw std::invalid_argument(std::string("missing option: ") + key);
145 }
146 }
147 O2_SIGNPOST_END(configuration, cid, "populateDefaults", "Done");
148}
149
150void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
151 boost::property_tree::ptree& pt,
152 boost::program_options::variables_map const& vmap,
153 boost::property_tree::ptree& provenance)
154{
155 O2_SIGNPOST_ID_GENERATE(cid, configuration);
156 O2_SIGNPOST_START(configuration, cid, "populate", "Filling parameters from variables_map");
157 for (auto const& spec : schema) {
158 // strip short version to get the correct key
159 std::string key = spec.name.substr(0, spec.name.find(','));
160 if (vmap.count(key) == 0) {
161 continue;
162 }
163 try {
164 switch (spec.type) {
165 case VariantType::Int:
166 pt.put(key, vmap[key].as<int>());
167 break;
168 case VariantType::Int8:
169 pt.put(key, vmap[key].as<int8_t>());
170 break;
171 case VariantType::Int16:
172 pt.put(key, vmap[key].as<int16_t>());
173 break;
174 case VariantType::UInt8:
175 pt.put(key, vmap[key].as<uint8_t>());
176 break;
177 case VariantType::UInt16:
178 pt.put(key, vmap[key].as<uint16_t>());
179 break;
180 case VariantType::UInt32:
181 pt.put(key, vmap[key].as<uint32_t>());
182 break;
183 case VariantType::UInt64:
184 pt.put(key, vmap[key].as<uint64_t>());
185 break;
186 case VariantType::Int64:
187 pt.put(key, vmap[key].as<int64_t>());
188 break;
189 case VariantType::Float:
190 pt.put(key, vmap[key].as<float>());
191 break;
192 case VariantType::Double:
193 pt.put(key, vmap[key].as<double>());
194 break;
195 case VariantType::String:
196 if (auto const* v = boost::any_cast<std::string>(&vmap[key].value())) {
197 pt.put(key, *v);
198 }
199 break;
200 case VariantType::Bool: {
201 auto v = vmap[key].as<bool>();
202 O2_SIGNPOST_EVENT_EMIT(configuration, cid, "populate", "Setting %{public}s: %{public}s", key.c_str(), v ? "true" : "false");
203 pt.put(key, v);
204 } break;
205 case VariantType::ArrayInt: {
206 auto v = fromString<VariantType::ArrayInt>(vmap[key].as<std::string>());
207 pt.put_child(key, vectorToBranch<int>(v.get<int*>(), v.size()));
208 } break;
209 case VariantType::ArrayFloat: {
210 auto v = fromString<VariantType::ArrayFloat>(vmap[key].as<std::string>());
211 pt.put_child(key, vectorToBranch<float>(v.get<float*>(), v.size()));
212 } break;
213 case VariantType::ArrayDouble: {
214 auto v = fromString<VariantType::ArrayDouble>(vmap[key].as<std::string>());
215 pt.put_child(key, vectorToBranch<double>(v.get<double*>(), v.size()));
216 } break;
217 case VariantType::ArrayBool:
218 // pt.put_child(key, vectorToBranch<bool>(stringToVector<bool>(vmap[key].as<std::string>())));
219 break;
220 case VariantType::ArrayString: {
221 auto v = fromString<VariantType::ArrayString>(vmap[key].as<std::string>());
222 pt.put_child(key, vectorToBranch<std::string>(v.get<std::string*>(), v.size()));
223 } break;
224 case VariantType::Array2DInt: {
225 auto v = fromString<VariantType::Array2DInt>(vmap[key].as<std::string>());
226 pt.put_child(key, array2DToBranch<int>(v.get<Array2D<int>>()));
227 } break;
228 case VariantType::Array2DFloat: {
229 auto v = fromString<VariantType::Array2DFloat>(vmap[key].as<std::string>());
230 pt.put_child(key, array2DToBranch<float>(v.get<Array2D<float>>()));
231 } break;
232 case VariantType::Array2DDouble: {
233 auto v = fromString<VariantType::Array2DDouble>(vmap[key].as<std::string>());
234 pt.put_child(key, array2DToBranch<double>(v.get<Array2D<double>>()));
235 } break;
236 case VariantType::LabeledArrayInt: {
237 auto v = fromString<VariantType::LabeledArrayInt>(vmap[key].as<std::string>());
238 pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<int>>()));
239 } break;
240 case VariantType::LabeledArrayFloat: {
241 auto v = fromString<VariantType::LabeledArrayFloat>(vmap[key].as<std::string>());
242 pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<float>>()));
243 } break;
244 case VariantType::LabeledArrayDouble: {
245 auto v = fromString<VariantType::LabeledArrayDouble>(vmap[key].as<std::string>());
246 pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<double>>()));
247 } break;
248 case VariantType::LabeledArrayString: {
249 auto v = fromString<VariantType::LabeledArrayString>(vmap[key].as<std::string>());
250 pt.put_child(key, labeledArrayToBranch(v.get<LabeledArray<std::string>>()));
251 } break;
252 case VariantType::Dict:
253 pt.put_child(key, vmap[key].as<boost::property_tree::ptree>());
254 break;
255 case VariantType::Unknown:
256 case VariantType::Empty:
257 default:
258 throw runtime_error("Unknown variant type");
259 }
260 provenance.put(key, "fairmq");
261 } catch (std::runtime_error& re) {
262 O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Aborting because of runtime_error %{public}s", re.what());
263 throw;
264 } catch (std::exception& e) {
265 O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Missing option %{public}s (%{public}s)", key.c_str(), e.what());
266 throw std::invalid_argument(std::string("missing option: ") + key + " (" + e.what() + ")");
267 } catch (...) {
268 O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Aborting because of missing option %{public}s", key.c_str());
269 throw std::invalid_argument(std::string("missing option: ") + key);
270 }
271 }
272 O2_SIGNPOST_END(configuration, cid, "populate", "Done");
273}
274
275template <typename T>
276auto replaceLabels(LabeledArray<T>& input, LabeledArray<T>&& spec)
277{
278 if (!input.getLabelsCols().empty() || !input.getLabelsRows().empty()) {
279 return false;
280 }
281 if (spec.getLabelsCols().empty() == false) {
282 input.replaceLabelsCols(spec.getLabelsCols());
283 }
284 if (spec.getLabelsRows().empty() == false) {
285 input.replaceLabelsRows(spec.getLabelsRows());
286 }
287 return true;
288}
289
290void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
291 boost::property_tree::ptree& pt,
292 boost::property_tree::ptree const& in,
293 boost::property_tree::ptree& provenance,
294 std::string const& provenanceLabel)
295{
296 O2_SIGNPOST_ID_GENERATE(cid, configuration);
297 O2_SIGNPOST_START(configuration, cid, "populate", "Filling parameters from ptree");
298 for (auto const& spec : schema) {
299 // strip short version to get the correct key
300 std::string key = spec.name.substr(0, spec.name.find(','));
301 auto it = in.get_child_optional(key);
302 if (!it) {
303 it = in.get_child_optional(boost::property_tree::path(key, '/'));
304 }
305 if (!it) {
306 continue;
307 }
308 try {
309 switch (spec.type) {
310 case VariantType::Int:
311 pt.put(key, (*it).get_value<int>());
312 break;
313 case VariantType::Int8:
314 pt.put(key, (*it).get_value<int8_t>());
315 break;
316 case VariantType::Int16:
317 pt.put(key, (*it).get_value<int16_t>());
318 break;
319 case VariantType::UInt8:
320 pt.put(key, (*it).get_value<uint8_t>());
321 break;
322 case VariantType::UInt16:
323 pt.put(key, (*it).get_value<uint16_t>());
324 break;
325 case VariantType::UInt32:
326 pt.put(key, (*it).get_value<uint32_t>());
327 break;
328 case VariantType::UInt64:
329 pt.put(key, (*it).get_value<uint64_t>());
330 break;
331 case VariantType::Int64:
332 pt.put(key, (*it).get_value<int64_t>());
333 break;
334 case VariantType::Float:
335 pt.put(key, (*it).get_value<float>());
336 break;
337 case VariantType::Double:
338 pt.put(key, (*it).get_value<double>());
339 break;
340 case VariantType::String:
341 pt.put(key, (*it).get_value<std::string>());
342 break;
343 case VariantType::Bool: {
344 auto v = (*it).get_value<bool>();
345 O2_SIGNPOST_EVENT_EMIT(configuration, cid, "populate", "Setting %{public}s: %{public}s", key.c_str(), v ? "true" : "false");
346 pt.put(key, (*it).get_value<bool>());
347 } break;
348 case VariantType::Dict:
349 case VariantType::ArrayInt:
350 case VariantType::ArrayFloat:
351 case VariantType::ArrayDouble:
352 case VariantType::ArrayBool:
353 case VariantType::ArrayString:
354 case VariantType::Array2DInt:
355 case VariantType::Array2DFloat:
356 case VariantType::Array2DDouble:
357 pt.put_child(key, *it);
358 break;
359 case VariantType::LabeledArrayInt: {
360 auto v = labeledArrayFromBranch<int>(it.value());
361 if (!replaceLabels(v, spec.defaultValue.get<LabeledArray<int>>())) {
362 pt.put_child(key, *it);
363 } else {
364 pt.put_child(key, labeledArrayToBranch(std::move(v)));
365 }
366 }; break;
367 case VariantType::LabeledArrayFloat: {
368 auto v = labeledArrayFromBranch<float>(it.value());
369 if (!replaceLabels(v, spec.defaultValue.get<LabeledArray<float>>())) {
370 pt.put_child(key, *it);
371 } else {
372 pt.put_child(key, labeledArrayToBranch(std::move(v)));
373 }
374 }; break;
375 case VariantType::LabeledArrayDouble: {
376 auto v = labeledArrayFromBranch<double>(it.value());
377 if (!replaceLabels(v, spec.defaultValue.get<LabeledArray<double>>())) {
378 pt.put_child(key, *it);
379 } else {
380 pt.put_child(key, labeledArrayToBranch(std::move(v)));
381 }
382 }; break;
383 case VariantType::LabeledArrayString: {
384 auto v = labeledArrayFromBranch<std::string>(it.value());
385 if (!replaceLabels(v, spec.defaultValue.get<LabeledArray<std::string>>())) {
386 pt.put_child(key, *it);
387 } else {
388 pt.put_child(key, labeledArrayToBranch(std::move(v)));
389 }
390 }; break;
391 case VariantType::Unknown:
392 case VariantType::Empty:
393 default:
394 throw std::runtime_error("Unknown variant type");
395 }
396 provenance.put(key, provenanceLabel);
397 } catch (std::runtime_error& re) {
398 O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Aborting during processing of %{public}s because of runtime_error %{public}s",
399 key.c_str(), re.what());
400 throw;
401 } catch (std::exception& e) {
402 O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Missing option %{public}s (%{public}s)", key.c_str(), e.what());
403 throw std::invalid_argument(std::string("missing option: ") + key + " (" + e.what() + ")");
404 } catch (...) {
405 O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Aborting because of missing option %{public}s", key.c_str());
406 throw std::invalid_argument(std::string("missing option: ") + key);
407 }
408 }
409 O2_SIGNPOST_END(configuration, cid, "populate", "Done");
410}
411
412namespace
413{
414void traverseRecursive(const boost::property_tree::ptree& parent,
415 const boost::property_tree::ptree::path_type& childPath,
416 const boost::property_tree::ptree& child,
417 PropertyTreeHelpers::WalkerFunction<boost::property_tree::ptree>& method)
418{
419 using boost::property_tree::ptree;
420
421 method(parent, childPath, child);
422 for (ptree::const_iterator it = child.begin(); it != child.end(); ++it) {
423 ptree::path_type curPath = childPath / ptree::path_type(it->first);
424 traverseRecursive(parent, curPath, it->second, method);
425 }
426}
427} // namespace
428
429template <>
430void PropertyTreeHelpers::traverse<boost::property_tree::ptree>(const boost::property_tree::ptree& parent, PropertyTreeHelpers::WalkerFunction<boost::property_tree::ptree>& method)
431{
432 traverseRecursive(parent, "", parent, method);
433}
434
435} // namespace o2::framework
schema
std::shared_ptr< arrow::Schema > schema
Definition ExpressionJSONHelpers.cxx:666
O2_DECLARE_DYNAMIC_LOG
#define O2_DECLARE_DYNAMIC_LOG(name)
Definition Signpost.h:489
O2_SIGNPOST_END
#define O2_SIGNPOST_END(log, id, name, format,...)
Definition Signpost.h:608
O2_SIGNPOST_ID_GENERATE
#define O2_SIGNPOST_ID_GENERATE(name, log)
Definition Signpost.h:506
O2_SIGNPOST_EVENT_EMIT
#define O2_SIGNPOST_EVENT_EMIT(log, id, name, format,...)
Definition Signpost.h:522
O2_SIGNPOST_END_WITH_ERROR
#define O2_SIGNPOST_END_WITH_ERROR(log, id, name, format,...)
Definition Signpost.h:616
O2_SIGNPOST_START
#define O2_SIGNPOST_START(log, id, name, format,...)
Definition Signpost.h:602
labeledArrayFromBranch< std::string >
template o2::framework::LabeledArray< std::string > o2::framework::labeledArrayFromBranch< std::string >(boost::property_tree::ptree const &tree)
key
StringRef key
Definition catch_amalgamated.cxx:4853
o2::framework::LabeledArray::replaceLabelsRows
void replaceLabelsRows(std::vector< std::string > const &labels)
Definition Array2D.h:260
o2::framework::LabeledArray::replaceLabelsCols
void replaceLabelsCols(std::vector< std::string > const &labels)
Definition Array2D.h:265
v
const GLdouble * v
Definition glcorearb.h:832
value
GLsizei const GLfloat * value
Definition glcorearb.h:819
o2::framework
Defining PrimaryVertex explicitly as messageable.
Definition BunchFilling.h:112
o2::framework::runtime_error
RuntimeErrorRef runtime_error(const char *)
Definition RuntimeError.cxx:81
o2::framework::labeledArrayToBranch
boost::property_tree::ptree labeledArrayToBranch(LabeledArray< T > &&array)
Definition VariantPropertyTreeHelpers.h:134
o2::framework::replaceLabels
auto replaceLabels(LabeledArray< T > &input, LabeledArray< T > &&spec)
Definition PropertyTreeHelpers.cxx:276
o2::framework::array2DToBranch
boost::property_tree::ptree array2DToBranch(Array2D< T > &&array)
Definition VariantPropertyTreeHelpers.h:69
o2::framework::runtime_error_f
RuntimeErrorRef runtime_error_f(const char *,...)
Definition RuntimeError.cxx:60
o2::framework::vectorToBranch
boost::property_tree::ptree vectorToBranch(T const *values, size_t size)
Definition VariantPropertyTreeHelpers.h:39
o2::framework::LabelMap::getLabelsRows
auto getLabelsRows() const
Definition Array2D.h:147
o2::framework::LabelMap::getLabelsCols
auto getLabelsCols() const
Definition Array2D.h:152
o2::framework::PropertyTreeHelpers::populate
static void populate(std::vector< ConfigParamSpec > const &schema, boost::property_tree::ptree &tree, boost::program_options::variables_map const &vmap, boost::property_tree::ptree &provenance)
Definition PropertyTreeHelpers.cxx:150
o2::framework::PropertyTreeHelpers::WalkerFunction
std::function< void(boost::property_tree::ptree const &, typename T::path_type, boost::property_tree::ptree const &)> WalkerFunction
Definition PropertyTreeHelpers.h:54
o2::framework::PropertyTreeHelpers::populateDefaults
static void populateDefaults(std::vector< ConfigParamSpec > const &schema, boost::property_tree::ptree &tree, boost::property_tree::ptree &provenance)
Definition PropertyTreeHelpers.cxx:39
str
const std::string str
Definition test_ransEncodeDecode.cxx:37