ceph/src/jaegertracing/opentelemetry-cpp/third_party/nlohmann-json/include/nlohmann/detail/conversions/from_json.hpp

   1 #pragma once
   2
   3 #include <algorithm> // transform
   4 #include <array> // array
   5 #include <forward_list> // forward_list
   6 #include <iterator> // inserter, front_inserter, end
   7 #include <map> // map
   8 #include <string> // string
   9 #include <tuple> // tuple, make_tuple
  10 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
  11 #include <unordered_map> // unordered_map
  12 #include <utility> // pair, declval
  13 #include <valarray> // valarray
  14
  15 #include <nlohmann/detail/exceptions.hpp>
  16 #include <nlohmann/detail/macro_scope.hpp>
  17 #include <nlohmann/detail/meta/cpp_future.hpp>
  18 #include <nlohmann/detail/meta/identity_tag.hpp>
  19 #include <nlohmann/detail/meta/type_traits.hpp>
  20 #include <nlohmann/detail/value_t.hpp>
  21
  22 #if JSON_HAS_EXPERIMENTAL_FILESYSTEM
  23 #include <experimental/filesystem>
  24 namespace nlohmann::detail
  25 {
  26 namespace std_fs = std::experimental::filesystem;
  27 } // namespace nlohmann::detail
  28 #elif JSON_HAS_FILESYSTEM
  29 #include <filesystem>
  30 namespace nlohmann::detail
  31 {
  32 namespace std_fs = std::filesystem;
  33 } // namespace nlohmann::detail
  34 #endif
  35
  36 namespace nlohmann
  37 {
  38 namespace detail
  39 {
  40 template<typename BasicJsonType>
  41 void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
  42 {
  43     if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
  44     {
  45         JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name()), j));
  46     }
  47     n = nullptr;
  48 }
  49
  50 // overloads for basic_json template parameters
  51 template < typename BasicJsonType, typename ArithmeticType,
  52            enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
  53                          !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
  54                          int > = 0 >
  55 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
  56 {
  57     switch (static_cast<value_t>(j))
  58     {
  59         case value_t::number_unsigned:
  60         {
  61             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
  62             break;
  63         }
  64         case value_t::number_integer:
  65         {
  66             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
  67             break;
  68         }
  69         case value_t::number_float:
  70         {
  71             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
  72             break;
  73         }
  74
  75         case value_t::null:
  76         case value_t::object:
  77         case value_t::array:
  78         case value_t::string:
  79         case value_t::boolean:
  80         case value_t::binary:
  81         case value_t::discarded:
  82         default:
  83             JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
  84     }
  85 }
  86
  87 template<typename BasicJsonType>
  88 void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
  89 {
  90     if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
  91     {
  92         JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name()), j));
  93     }
  94     b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
  95 }
  96
  97 template<typename BasicJsonType>
  98 void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
  99 {
 100     if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
 101     {
 102         JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
 103     }
 104     s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
 105 }
 106
 107 template <
 108     typename BasicJsonType, typename ConstructibleStringType,
 109     enable_if_t <
 110         is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
 111         !std::is_same<typename BasicJsonType::string_t,
 112                       ConstructibleStringType>::value,
 113         int > = 0 >
 114 void from_json(const BasicJsonType& j, ConstructibleStringType& s)
 115 {
 116     if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
 117     {
 118         JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
 119     }
 120
 121     s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
 122 }
 123
 124 template<typename BasicJsonType>
 125 void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
 126 {
 127     get_arithmetic_value(j, val);
 128 }
 129
 130 template<typename BasicJsonType>
 131 void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
 132 {
 133     get_arithmetic_value(j, val);
 134 }
 135
 136 template<typename BasicJsonType>
 137 void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
 138 {
 139     get_arithmetic_value(j, val);
 140 }
 141
 142 template<typename BasicJsonType, typename EnumType,
 143          enable_if_t<std::is_enum<EnumType>::value, int> = 0>
 144 void from_json(const BasicJsonType& j, EnumType& e)
 145 {
 146     typename std::underlying_type<EnumType>::type val;
 147     get_arithmetic_value(j, val);
 148     e = static_cast<EnumType>(val);
 149 }
 150
 151 // forward_list doesn't have an insert method
 152 template<typename BasicJsonType, typename T, typename Allocator,
 153          enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
 154 void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
 155 {
 156     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
 157     {
 158         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
 159     }
 160     l.clear();
 161     std::transform(j.rbegin(), j.rend(),
 162                    std::front_inserter(l), [](const BasicJsonType & i)
 163     {
 164         return i.template get<T>();
 165     });
 166 }
 167
 168 // valarray doesn't have an insert method
 169 template<typename BasicJsonType, typename T,
 170          enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
 171 void from_json(const BasicJsonType& j, std::valarray<T>& l)
 172 {
 173     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
 174     {
 175         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
 176     }
 177     l.resize(j.size());
 178     std::transform(j.begin(), j.end(), std::begin(l),
 179                    [](const BasicJsonType & elem)
 180     {
 181         return elem.template get<T>();
 182     });
 183 }
 184
 185 template<typename BasicJsonType, typename T, std::size_t N>
 186 auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
 187 -> decltype(j.template get<T>(), void())
 188 {
 189     for (std::size_t i = 0; i < N; ++i)
 190     {
 191         arr[i] = j.at(i).template get<T>();
 192     }
 193 }
 194
 195 template<typename BasicJsonType>
 196 void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
 197 {
 198     arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
 199 }
 200
 201 template<typename BasicJsonType, typename T, std::size_t N>
 202 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
 203                           priority_tag<2> /*unused*/)
 204 -> decltype(j.template get<T>(), void())
 205 {
 206     for (std::size_t i = 0; i < N; ++i)
 207     {
 208         arr[i] = j.at(i).template get<T>();
 209     }
 210 }
 211
 212 template<typename BasicJsonType, typename ConstructibleArrayType,
 213          enable_if_t<
 214              std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
 215              int> = 0>
 216 auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
 217 -> decltype(
 218     arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
 219     j.template get<typename ConstructibleArrayType::value_type>(),
 220     void())
 221 {
 222     using std::end;
 223
 224     ConstructibleArrayType ret;
 225     ret.reserve(j.size());
 226     std::transform(j.begin(), j.end(),
 227                    std::inserter(ret, end(ret)), [](const BasicJsonType & i)
 228     {
 229         // get<BasicJsonType>() returns *this, this won't call a from_json
 230         // method when value_type is BasicJsonType
 231         return i.template get<typename ConstructibleArrayType::value_type>();
 232     });
 233     arr = std::move(ret);
 234 }
 235
 236 template<typename BasicJsonType, typename ConstructibleArrayType,
 237          enable_if_t<
 238              std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
 239              int> = 0>
 240 void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
 241                           priority_tag<0> /*unused*/)
 242 {
 243     using std::end;
 244
 245     ConstructibleArrayType ret;
 246     std::transform(
 247         j.begin(), j.end(), std::inserter(ret, end(ret)),
 248         [](const BasicJsonType & i)
 249     {
 250         // get<BasicJsonType>() returns *this, this won't call a from_json
 251         // method when value_type is BasicJsonType
 252         return i.template get<typename ConstructibleArrayType::value_type>();
 253     });
 254     arr = std::move(ret);
 255 }
 256
 257 template < typename BasicJsonType, typename ConstructibleArrayType,
 258            enable_if_t <
 259                is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
 260                !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
 261                !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
 262                !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
 263                !is_basic_json<ConstructibleArrayType>::value,
 264                int > = 0 >
 265 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
 266 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
 267 j.template get<typename ConstructibleArrayType::value_type>(),
 268 void())
 269 {
 270     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
 271     {
 272         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
 273     }
 274
 275     from_json_array_impl(j, arr, priority_tag<3> {});
 276 }
 277
 278 template < typename BasicJsonType, typename T, std::size_t... Idx >
 279 std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
 280         identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
 281 {
 282     return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
 283 }
 284
 285 template < typename BasicJsonType, typename T, std::size_t N >
 286 auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
 287 -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
 288 {
 289     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
 290     {
 291         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
 292     }
 293
 294     return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
 295 }
 296
 297 template<typename BasicJsonType>
 298 void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
 299 {
 300     if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
 301     {
 302         JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name()), j));
 303     }
 304
 305     bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
 306 }
 307
 308 template<typename BasicJsonType, typename ConstructibleObjectType,
 309          enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
 310 void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
 311 {
 312     if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
 313     {
 314         JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name()), j));
 315     }
 316
 317     ConstructibleObjectType ret;
 318     const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
 319     using value_type = typename ConstructibleObjectType::value_type;
 320     std::transform(
 321         inner_object->begin(), inner_object->end(),
 322         std::inserter(ret, ret.begin()),
 323         [](typename BasicJsonType::object_t::value_type const & p)
 324     {
 325         return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
 326     });
 327     obj = std::move(ret);
 328 }
 329
 330 // overload for arithmetic types, not chosen for basic_json template arguments
 331 // (BooleanType, etc..); note: Is it really necessary to provide explicit
 332 // overloads for boolean_t etc. in case of a custom BooleanType which is not
 333 // an arithmetic type?
 334 template < typename BasicJsonType, typename ArithmeticType,
 335            enable_if_t <
 336                std::is_arithmetic<ArithmeticType>::value&&
 337                !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
 338                !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
 339                !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
 340                !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
 341                int > = 0 >
 342 void from_json(const BasicJsonType& j, ArithmeticType& val)
 343 {
 344     switch (static_cast<value_t>(j))
 345     {
 346         case value_t::number_unsigned:
 347         {
 348             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
 349             break;
 350         }
 351         case value_t::number_integer:
 352         {
 353             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
 354             break;
 355         }
 356         case value_t::number_float:
 357         {
 358             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
 359             break;
 360         }
 361         case value_t::boolean:
 362         {
 363             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
 364             break;
 365         }
 366
 367         case value_t::null:
 368         case value_t::object:
 369         case value_t::array:
 370         case value_t::string:
 371         case value_t::binary:
 372         case value_t::discarded:
 373         default:
 374             JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
 375     }
 376 }
 377
 378 template<typename BasicJsonType, typename... Args, std::size_t... Idx>
 379 std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
 380 {
 381     return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
 382 }
 383
 384 template < typename BasicJsonType, class A1, class A2 >
 385 std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
 386 {
 387     return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
 388             std::forward<BasicJsonType>(j).at(1).template get<A2>()};
 389 }
 390
 391 template<typename BasicJsonType, typename A1, typename A2>
 392 void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
 393 {
 394     p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
 395 }
 396
 397 template<typename BasicJsonType, typename... Args>
 398 std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
 399 {
 400     return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
 401 }
 402
 403 template<typename BasicJsonType, typename... Args>
 404 void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
 405 {
 406     t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
 407 }
 408
 409 template<typename BasicJsonType, typename TupleRelated>
 410 auto from_json(BasicJsonType&& j, TupleRelated&& t)
 411 -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
 412 {
 413     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
 414     {
 415         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
 416     }
 417
 418     return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
 419 }
 420
 421 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
 422            typename = enable_if_t < !std::is_constructible <
 423                                         typename BasicJsonType::string_t, Key >::value >>
 424 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
 425 {
 426     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
 427     {
 428         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
 429     }
 430     m.clear();
 431     for (const auto& p : j)
 432     {
 433         if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
 434         {
 435             JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
 436         }
 437         m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
 438     }
 439 }
 440
 441 template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
 442            typename = enable_if_t < !std::is_constructible <
 443                                         typename BasicJsonType::string_t, Key >::value >>
 444 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
 445 {
 446     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
 447     {
 448         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
 449     }
 450     m.clear();
 451     for (const auto& p : j)
 452     {
 453         if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
 454         {
 455             JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
 456         }
 457         m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
 458     }
 459 }
 460
 461 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
 462 template<typename BasicJsonType>
 463 void from_json(const BasicJsonType& j, std_fs::path& p)
 464 {
 465     if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
 466     {
 467         JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
 468     }
 469     p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
 470 }
 471 #endif
 472
 473 struct from_json_fn
 474 {
 475     template<typename BasicJsonType, typename T>
 476     auto operator()(const BasicJsonType& j, T&& val) const
 477     noexcept(noexcept(from_json(j, std::forward<T>(val))))
 478     -> decltype(from_json(j, std::forward<T>(val)))
 479     {
 480         return from_json(j, std::forward<T>(val));
 481     }
 482 };
 483 }  // namespace detail
 484
 485 /// namespace to hold default `from_json` function
 486 /// to see why this is required:
 487 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
 488 namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
 489 {
 490 constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value; // NOLINT(misc-definitions-in-headers)
 491 } // namespace
 492 } // namespace nlohmann