xref: /openbmc/telemetry/src/utils/labeled_tuple.hpp (revision f535cad6545d39fe58f50d0f23074359f43f8a03) 
1 #pragma once
2 
3 #include <nlohmann/json.hpp>
4 #include <sdbusplus/message/types.hpp>
5 
6 #include <cmath>
7 #include <limits>
8 
9 namespace utils
10 {
11 
12 namespace numeric_literals
13 {
14 constexpr std::string_view NaN = "NaN";
15 constexpr std::string_view infinity = "inf";
16 constexpr std::string_view infinity_negative = "-inf";
17 } // namespace numeric_literals
18 
19 inline void from_json(const nlohmann::json& j,
20                       sdbusplus::message::object_path& o)
21 {
22     o = j.get<std::string>();
23 }
24 
25 inline void from_json(const nlohmann::json& j,
26                       std::vector<sdbusplus::message::object_path>& o)
27 {
28     o.clear();
29     for (const nlohmann::json& item : j)
30     {
31         o.emplace_back(item.get<std::string>());
32     }
33 }
34 
35 inline void to_json(nlohmann::json& j, const double& val)
36 {
37     if (std::isnan(val))
38     {
39         j = numeric_literals::NaN;
40     }
41     else if (val == std::numeric_limits<double>::infinity())
42     {
43         j = numeric_literals::infinity;
44     }
45     else if (val == -std::numeric_limits<double>::infinity())
46     {
47         j = numeric_literals::infinity_negative;
48     }
49     else
50     {
51         j = val;
52     }
53 }
54 
55 inline void from_json(const nlohmann::json& j, double& val)
56 {
57     if (j.is_number())
58     {
59         val = j.get<double>();
60     }
61     else
62     {
63         auto str_val = j.get<std::string>();
64         if (str_val == numeric_literals::NaN)
65         {
66             val = std::numeric_limits<double>::quiet_NaN();
67         }
68         else if (str_val == numeric_literals::infinity)
69         {
70             val = std::numeric_limits<double>::infinity();
71         }
72         else if (str_val == numeric_literals::infinity_negative)
73         {
74             val = -std::numeric_limits<double>::infinity();
75         }
76         else
77         {
78             throw std::invalid_argument("Unknown numeric literal");
79         }
80     }
81 }
82 
83 namespace detail
84 {
85 
86 template <class T>
87 struct has_utils_from_json
88 {
89     template <class U>
90     static U& ref();
91 
92     template <class U>
93     static std::true_type check(
94         decltype(utils::from_json(ref<const nlohmann::json>(), ref<U>()))*);
95 
96     template <class>
97     static std::false_type check(...);
98 
99     static constexpr bool value =
100         decltype(check<std::decay_t<T>>(nullptr))::value;
101 };
102 
103 template <class T>
104 constexpr bool has_utils_from_json_v = has_utils_from_json<T>::value;
105 
106 template <class T>
107 struct has_utils_to_json
108 {
109     template <class U>
110     static U& ref();
111 
112     template <class U>
113     static std::true_type
114         check(decltype(utils::to_json(ref<nlohmann::json>(), ref<const U>()))*);
115 
116     template <class>
117     static std::false_type check(...);
118 
119     static constexpr bool value =
120         decltype(check<std::decay_t<T>>(nullptr))::value;
121 };
122 
123 template <class T>
124 constexpr bool has_utils_to_json_v = has_utils_to_json<T>::value;
125 
126 bool eq(const auto& a, const auto& b)
127 {
128     if constexpr (std::is_same<std::decay_t<decltype(a)>, double>())
129     {
130         if (std::isnan(a))
131         {
132             return std::isnan(b);
133         }
134     }
135     return a == b;
136 }
137 
138 } // namespace detail
139 
140 template <class, class...>
141 struct LabeledTuple;
142 
143 template <class... Args, class... Labels>
144 struct LabeledTuple<std::tuple<Args...>, Labels...>
145 {
146     static_assert(sizeof...(Args) == sizeof...(Labels));
147 
148     using tuple_type = std::tuple<Args...>;
149 
150     LabeledTuple() = default;
151     LabeledTuple(const LabeledTuple&) = default;
152     LabeledTuple(LabeledTuple&&) = default;
153 
154     explicit LabeledTuple(tuple_type v) : value(std::move(v)) {}
155     LabeledTuple(Args... args) : value(std::move(args)...) {}
156 
157     LabeledTuple& operator=(const LabeledTuple&) = default;
158     LabeledTuple& operator=(LabeledTuple&&) = default;
159 
160     nlohmann::json to_json() const
161     {
162         nlohmann::json j;
163         to_json_all(j, std::make_index_sequence<sizeof...(Args)>());
164         return j;
165     }
166 
167     const tuple_type& to_tuple() const
168     {
169         return value;
170     }
171 
172     void from_json(const nlohmann::json& j)
173     {
174         from_json_all(j, std::make_index_sequence<sizeof...(Args)>());
175     }
176 
177     std::string dump() const
178     {
179         return to_json().dump();
180     }
181 
182     template <size_t Idx>
183     const auto& at_index() const
184     {
185         return std::get<Idx>(value);
186     }
187 
188     template <size_t Idx>
189     auto& at_index()
190     {
191         return std::get<Idx>(value);
192     }
193 
194     template <class Label>
195     const auto& at_label() const
196     {
197         return find_item<0, Label>(*this);
198     }
199 
200     template <class Label>
201     auto& at_label()
202     {
203         return find_item<0, Label>(*this);
204     }
205 
206     bool operator==(const LabeledTuple& other) const
207     {
208         return std::apply([&](auto&&... x) {
209             return std::apply([&](auto&&... y) {
210                 return (true && ... && detail::eq(x, y));
211             }, value);
212         }, other.value);
213     }
214 
215     bool operator<(const LabeledTuple& other) const
216     {
217         return value < other.value;
218     }
219 
220   private:
221     template <size_t... Idx>
222     void to_json_all(nlohmann::json& j, std::index_sequence<Idx...>) const
223     {
224         (to_json_item<Idx>(j), ...);
225     }
226 
227     template <size_t Idx>
228     void to_json_item(nlohmann::json& j) const
229     {
230         using Label = std::tuple_element_t<Idx, std::tuple<Labels...>>;
231         using T = std::tuple_element_t<Idx, tuple_type>;
232         nlohmann::json& item = j[Label::str()];
233         if constexpr (detail::has_utils_to_json_v<T>)
234         {
235             utils::to_json(item, std::get<Idx>(value));
236         }
237         else
238         {
239             item = std::get<Idx>(value);
240         }
241     }
242 
243     template <size_t... Idx>
244     void from_json_all(const nlohmann::json& j, std::index_sequence<Idx...>)
245     {
246         (from_json_item<Idx>(j), ...);
247     }
248 
249     template <size_t Idx>
250     void from_json_item(const nlohmann::json& j)
251     {
252         using Label = std::tuple_element_t<Idx, std::tuple<Labels...>>;
253         using T = std::tuple_element_t<Idx, tuple_type>;
254         const nlohmann::json& item = j.at(Label::str());
255         if constexpr (detail::has_utils_from_json_v<T>)
256         {
257             T& v = std::get<Idx>(value);
258             utils::from_json(item, v);
259         }
260         else
261         {
262             std::get<Idx>(value) = item.get<T>();
263         }
264     }
265 
266     template <size_t Idx, class Label, class Self>
267     static auto& find_item(Self& self)
268     {
269         if constexpr (std::is_same_v<Label, std::tuple_element_t<
270                                                 Idx, std::tuple<Labels...>>>)
271         {
272             return std::get<Idx>(self.value);
273         }
274         else
275         {
276             static_assert(Idx + 1 < sizeof...(Args),
277                           "Label not found in LabeledTuple");
278             return find_item<Idx + 1, Label>(self);
279         }
280     }
281 
282     tuple_type value;
283 };
284 
285 template <class... Args, class... Labels>
286 inline void to_json(nlohmann::json& json,
287                     const LabeledTuple<std::tuple<Args...>, Labels...>& tuple)
288 {
289     json = tuple.to_json();
290 }
291 
292 template <class... Args, class... Labels>
293 inline void from_json(const nlohmann::json& json,
294                       LabeledTuple<std::tuple<Args...>, Labels...>& tuple)
295 {
296     tuple.from_json(json);
297 }
298 
299 } // namespace utils
300