318
+ − 1 // Copyright Toru Niina 2017.
+ − 2 // Distributed under the MIT License.
+ − 3 #ifndef TOML11_GET_HPP
+ − 4 #define TOML11_GET_HPP
+ − 5 #include <algorithm>
+ − 6
+ − 7 #include "from.hpp"
+ − 8 #include "result.hpp"
+ − 9 #include "value.hpp"
+ − 10
+ − 11 namespace toml
+ − 12 {
+ − 13
+ − 14 // ============================================================================
+ − 15 // exact toml::* type
+ − 16
+ − 17 template<typename T, typename C,
+ − 18 template<typename ...> class M, template<typename ...> class V>
+ − 19 detail::enable_if_t<detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T> &
+ − 20 get(basic_value<C, M, V>& v)
+ − 21 {
+ − 22 return v.template cast<detail::type_to_enum<T, basic_value<C, M, V>>::value>();
+ − 23 }
+ − 24
+ − 25 template<typename T, typename C,
+ − 26 template<typename ...> class M, template<typename ...> class V>
+ − 27 detail::enable_if_t<detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T> const&
+ − 28 get(const basic_value<C, M, V>& v)
+ − 29 {
+ − 30 return v.template cast<detail::type_to_enum<T, basic_value<C, M, V>>::value>();
+ − 31 }
+ − 32
+ − 33 template<typename T, typename C,
+ − 34 template<typename ...> class M, template<typename ...> class V>
+ − 35 detail::enable_if_t<detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T>
+ − 36 get(basic_value<C, M, V>&& v)
+ − 37 {
+ − 38 return T(std::move(v).template cast<detail::type_to_enum<T, basic_value<C, M, V>>::value>());
+ − 39 }
+ − 40
+ − 41 // ============================================================================
+ − 42 // T == toml::value; identity transformation.
+ − 43
+ − 44 template<typename T, typename C,
+ − 45 template<typename ...> class M, template<typename ...> class V>
+ − 46 inline detail::enable_if_t<std::is_same<T, basic_value<C, M, V>>::value, T>&
+ − 47 get(basic_value<C, M, V>& v)
+ − 48 {
+ − 49 return v;
+ − 50 }
+ − 51
+ − 52 template<typename T, typename C,
+ − 53 template<typename ...> class M, template<typename ...> class V>
+ − 54 inline detail::enable_if_t<std::is_same<T, basic_value<C, M, V>>::value, T> const&
+ − 55 get(const basic_value<C, M, V>& v)
+ − 56 {
+ − 57 return v;
+ − 58 }
+ − 59
+ − 60 template<typename T, typename C,
+ − 61 template<typename ...> class M, template<typename ...> class V>
+ − 62 inline detail::enable_if_t<std::is_same<T, basic_value<C, M, V>>::value, T>
+ − 63 get(basic_value<C, M, V>&& v)
+ − 64 {
+ − 65 return basic_value<C, M, V>(std::move(v));
+ − 66 }
+ − 67
+ − 68 // ============================================================================
+ − 69 // T == toml::basic_value<C2, M2, V2>; basic_value -> basic_value
+ − 70
+ − 71 template<typename T, typename C,
+ − 72 template<typename ...> class M, template<typename ...> class V>
+ − 73 inline detail::enable_if_t<detail::conjunction<detail::is_basic_value<T>,
+ − 74 detail::negation<std::is_same<T, basic_value<C, M, V>>>
+ − 75 >::value, T>
+ − 76 get(const basic_value<C, M, V>& v)
+ − 77 {
+ − 78 return T(v);
+ − 79 }
+ − 80
+ − 81 // ============================================================================
+ − 82 // integer convertible from toml::Integer
+ − 83
+ − 84 template<typename T, typename C,
+ − 85 template<typename ...> class M, template<typename ...> class V>
+ − 86 inline detail::enable_if_t<detail::conjunction<
+ − 87 std::is_integral<T>, // T is integral
+ − 88 detail::negation<std::is_same<T, bool>>, // but not bool
+ − 89 detail::negation< // but not toml::integer
+ − 90 detail::is_exact_toml_type<T, basic_value<C, M, V>>>
+ − 91 >::value, T>
+ − 92 get(const basic_value<C, M, V>& v)
+ − 93 {
+ − 94 return static_cast<T>(v.as_integer());
+ − 95 }
+ − 96
+ − 97 // ============================================================================
+ − 98 // floating point convertible from toml::Float
+ − 99
+ − 100 template<typename T, typename C,
+ − 101 template<typename ...> class M, template<typename ...> class V>
+ − 102 inline detail::enable_if_t<detail::conjunction<
+ − 103 std::is_floating_point<T>, // T is floating_point
+ − 104 detail::negation< // but not toml::floating
+ − 105 detail::is_exact_toml_type<T, basic_value<C, M, V>>>
+ − 106 >::value, T>
+ − 107 get(const basic_value<C, M, V>& v)
+ − 108 {
+ − 109 return static_cast<T>(v.as_floating());
+ − 110 }
+ − 111
+ − 112 // ============================================================================
+ − 113 // std::string; toml uses its own toml::string, but it should be convertible to
+ − 114 // std::string seamlessly
+ − 115
+ − 116 template<typename T, typename C,
+ − 117 template<typename ...> class M, template<typename ...> class V>
+ − 118 inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string>&
+ − 119 get(basic_value<C, M, V>& v)
+ − 120 {
+ − 121 return v.as_string().str;
+ − 122 }
+ − 123
+ − 124 template<typename T, typename C,
+ − 125 template<typename ...> class M, template<typename ...> class V>
+ − 126 inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string> const&
+ − 127 get(const basic_value<C, M, V>& v)
+ − 128 {
+ − 129 return v.as_string().str;
+ − 130 }
+ − 131
+ − 132 template<typename T, typename C,
+ − 133 template<typename ...> class M, template<typename ...> class V>
+ − 134 inline detail::enable_if_t<std::is_same<T, std::string>::value, std::string>
+ − 135 get(basic_value<C, M, V>&& v)
+ − 136 {
+ − 137 return std::string(std::move(v.as_string().str));
+ − 138 }
+ − 139
+ − 140 // ============================================================================
+ − 141 // std::string_view
+ − 142
+ − 143 #if defined(TOML11_USING_STRING_VIEW) && TOML11_USING_STRING_VIEW>0
+ − 144 template<typename T, typename C,
+ − 145 template<typename ...> class M, template<typename ...> class V>
+ − 146 inline detail::enable_if_t<std::is_same<T, std::string_view>::value, std::string_view>
+ − 147 get(const basic_value<C, M, V>& v)
+ − 148 {
+ − 149 return std::string_view(v.as_string().str);
+ − 150 }
+ − 151 #endif
+ − 152
+ − 153 // ============================================================================
+ − 154 // std::chrono::duration from toml::local_time.
+ − 155
+ − 156 template<typename T, typename C,
+ − 157 template<typename ...> class M, template<typename ...> class V>
+ − 158 inline detail::enable_if_t<detail::is_chrono_duration<T>::value, T>
+ − 159 get(const basic_value<C, M, V>& v)
+ − 160 {
+ − 161 return std::chrono::duration_cast<T>(
+ − 162 std::chrono::nanoseconds(v.as_local_time()));
+ − 163 }
+ − 164
+ − 165 // ============================================================================
+ − 166 // std::chrono::system_clock::time_point from toml::datetime variants
+ − 167
+ − 168 template<typename T, typename C,
+ − 169 template<typename ...> class M, template<typename ...> class V>
+ − 170 inline detail::enable_if_t<
+ − 171 std::is_same<std::chrono::system_clock::time_point, T>::value, T>
+ − 172 get(const basic_value<C, M, V>& v)
+ − 173 {
+ − 174 switch(v.type())
+ − 175 {
+ − 176 case value_t::local_date:
+ − 177 {
+ − 178 return std::chrono::system_clock::time_point(v.as_local_date());
+ − 179 }
+ − 180 case value_t::local_datetime:
+ − 181 {
+ − 182 return std::chrono::system_clock::time_point(v.as_local_datetime());
+ − 183 }
+ − 184 case value_t::offset_datetime:
+ − 185 {
+ − 186 return std::chrono::system_clock::time_point(v.as_offset_datetime());
+ − 187 }
+ − 188 default:
+ − 189 {
+ − 190 throw type_error(detail::format_underline("toml::value: "
+ − 191 "bad_cast to std::chrono::system_clock::time_point", {
+ − 192 {v.location(), concat_to_string("the actual type is ", v.type())}
+ − 193 }), v.location());
+ − 194 }
+ − 195 }
+ − 196 }
+ − 197
+ − 198 // ============================================================================
+ − 199 // forward declaration to use this recursively. ignore this and go ahead.
+ − 200
+ − 201 // array-like type with push_back(value) method
+ − 202 template<typename T, typename C,
+ − 203 template<typename ...> class M, template<typename ...> class V>
+ − 204 detail::enable_if_t<detail::conjunction<
+ − 205 detail::is_container<T>, // T is a container
+ − 206 detail::has_push_back_method<T>, // T::push_back(value) works
+ − 207 detail::negation< // but not toml::array
+ − 208 detail::is_exact_toml_type<T, basic_value<C, M, V>>>
+ − 209 >::value, T>
+ − 210 get(const basic_value<C, M, V>&);
+ − 211
+ − 212 // array-like type without push_back(value) method
+ − 213 template<typename T, typename C,
+ − 214 template<typename ...> class M, template<typename ...> class V>
+ − 215 detail::enable_if_t<detail::conjunction<
+ − 216 detail::is_container<T>, // T is a container
+ − 217 detail::negation<detail::has_push_back_method<T>>, // w/o push_back(...)
+ − 218 detail::negation<detail::has_specialized_from<T>>, // T does not have special conversion
+ − 219 detail::negation< // not toml::array
+ − 220 detail::is_exact_toml_type<T, basic_value<C, M, V>>>
+ − 221 >::value, T>
+ − 222 get(const basic_value<C, M, V>&);
+ − 223
+ − 224 // std::pair<T1, T2>
+ − 225 template<typename T, typename C,
+ − 226 template<typename ...> class M, template<typename ...> class V>
+ − 227 detail::enable_if_t<detail::is_std_pair<T>::value, T>
+ − 228 get(const basic_value<C, M, V>&);
+ − 229
+ − 230 // std::tuple<T1, T2, ...>
+ − 231 template<typename T, typename C,
+ − 232 template<typename ...> class M, template<typename ...> class V>
+ − 233 detail::enable_if_t<detail::is_std_tuple<T>::value, T>
+ − 234 get(const basic_value<C, M, V>&);
+ − 235
+ − 236 // map-like classes
+ − 237 template<typename T, typename C,
+ − 238 template<typename ...> class M, template<typename ...> class V>
+ − 239 detail::enable_if_t<detail::conjunction<
+ − 240 detail::is_map<T>, // T is map
+ − 241 detail::negation< // but not toml::table
+ − 242 detail::is_exact_toml_type<T, basic_value<C, M, V>>>
+ − 243 >::value, T>
+ − 244 get(const basic_value<C, M, V>&);
+ − 245
+ − 246 // T.from_toml(v)
+ − 247 template<typename T, typename C,
+ − 248 template<typename ...> class M, template<typename ...> class V>
+ − 249 detail::enable_if_t<detail::conjunction<
+ − 250 detail::negation< // not a toml::* type
+ − 251 detail::is_exact_toml_type<T, basic_value<C, M, V>>>,
+ − 252 detail::has_from_toml_method<T, C, M, V>, // but has from_toml(toml::value)
+ − 253 std::is_default_constructible<T> // and default constructible
+ − 254 >::value, T>
+ − 255 get(const basic_value<C, M, V>&);
+ − 256
+ − 257 // toml::from<T>::from_toml(v)
+ − 258 template<typename T, typename C,
+ − 259 template<typename ...> class M, template<typename ...> class V>
+ − 260 detail::enable_if_t<detail::has_specialized_from<T>::value, T>
+ − 261 get(const basic_value<C, M, V>&);
+ − 262
+ − 263 template<typename T, typename C,
+ − 264 template<typename ...> class M, template<typename ...> class V>
+ − 265 detail::enable_if_t<detail::has_specialized_from<T>::value, T>
+ − 266 get(basic_value<C, M, V>&);
+ − 267
+ − 268 // T(const toml::value&) and T is not toml::basic_value,
+ − 269 // and it does not have `from<T>` nor `from_toml`.
+ − 270 template<typename T, typename C,
+ − 271 template<typename ...> class M, template<typename ...> class V>
+ − 272 detail::enable_if_t<detail::conjunction<
+ − 273 detail::negation<detail::is_basic_value<T>>,
+ − 274 std::is_constructible<T, const basic_value<C, M, V>&>,
+ − 275 detail::negation<detail::has_from_toml_method<T, C, M, V>>,
+ − 276 detail::negation<detail::has_specialized_from<T>>
+ − 277 >::value, T>
+ − 278 get(const basic_value<C, M, V>&);
+ − 279
+ − 280 template<typename T, typename C,
+ − 281 template<typename ...> class M, template<typename ...> class V>
+ − 282 detail::enable_if_t<detail::conjunction<
+ − 283 detail::negation<detail::is_basic_value<T>>,
+ − 284 std::is_constructible<T, basic_value<C, M, V>&>,
+ − 285 detail::negation<detail::has_from_toml_method<T, C, M, V>>,
+ − 286 detail::negation<detail::has_specialized_from<T>>
+ − 287 >::value, T>
+ − 288 get(basic_value<C, M, V>&);
+ − 289
+ − 290 // ============================================================================
+ − 291 // array-like types; most likely STL container, like std::vector, etc.
+ − 292
+ − 293 template<typename T, typename C,
+ − 294 template<typename ...> class M, template<typename ...> class V>
+ − 295 detail::enable_if_t<detail::conjunction<
+ − 296 detail::is_container<T>, // T is a container
+ − 297 detail::has_push_back_method<T>, // container.push_back(elem) works
+ − 298 detail::negation< // but not toml::array
+ − 299 detail::is_exact_toml_type<T, basic_value<C, M, V>>>
+ − 300 >::value, T>
+ − 301 get(const basic_value<C, M, V>& v)
+ − 302 {
+ − 303 using value_type = typename T::value_type;
+ − 304 const auto& ary = v.as_array();
+ − 305
+ − 306 T container;
+ − 307 try_reserve(container, ary.size());
+ − 308
+ − 309 for(const auto& elem : ary)
+ − 310 {
+ − 311 container.push_back(get<value_type>(elem));
+ − 312 }
+ − 313 return container;
+ − 314 }
+ − 315
+ − 316 // ============================================================================
+ − 317 // std::forward_list does not have push_back, insert, or emplace.
+ − 318 // It has insert_after, emplace_after, push_front.
+ − 319
+ − 320 template<typename T, typename C,
+ − 321 template<typename ...> class M, template<typename ...> class V>
+ − 322 detail::enable_if_t<detail::is_std_forward_list<T>::value, T>
+ − 323 get(const basic_value<C, M, V>& v)
+ − 324 {
+ − 325 using value_type = typename T::value_type;
+ − 326 T container;
+ − 327 for(const auto& elem : v.as_array())
+ − 328 {
+ − 329 container.push_front(get<value_type>(elem));
+ − 330 }
+ − 331 container.reverse();
+ − 332 return container;
+ − 333 }
+ − 334
+ − 335 // ============================================================================
+ − 336 // array-like types, without push_back(). most likely [std|boost]::array.
+ − 337
+ − 338 template<typename T, typename C,
+ − 339 template<typename ...> class M, template<typename ...> class V>
+ − 340 detail::enable_if_t<detail::conjunction<
+ − 341 detail::is_container<T>, // T is a container
+ − 342 detail::negation<detail::has_push_back_method<T>>, // w/o push_back
+ − 343 detail::negation<detail::has_specialized_from<T>>, // T does not have special conversion
+ − 344 detail::negation< // T is not toml::array
+ − 345 detail::is_exact_toml_type<T, basic_value<C, M, V>>>
+ − 346 >::value, T>
+ − 347 get(const basic_value<C, M, V>& v)
+ − 348 {
+ − 349 using value_type = typename T::value_type;
+ − 350 const auto& ar = v.as_array();
+ − 351
+ − 352 T container;
+ − 353 if(ar.size() != container.size())
+ − 354 {
+ − 355 throw std::out_of_range(detail::format_underline(concat_to_string(
+ − 356 "toml::get: specified container size is ", container.size(),
+ − 357 " but there are ", ar.size(), " elements in toml array."), {
+ − 358 {v.location(), "here"}
+ − 359 }));
+ − 360 }
+ − 361 for(std::size_t i=0; i<ar.size(); ++i)
+ − 362 {
+ − 363 container[i] = ::toml::get<value_type>(ar[i]);
+ − 364 }
+ − 365 return container;
+ − 366 }
+ − 367
+ − 368 // ============================================================================
+ − 369 // std::pair.
+ − 370
+ − 371 template<typename T, typename C,
+ − 372 template<typename ...> class M, template<typename ...> class V>
+ − 373 detail::enable_if_t<detail::is_std_pair<T>::value, T>
+ − 374 get(const basic_value<C, M, V>& v)
+ − 375 {
+ − 376 using first_type = typename T::first_type;
+ − 377 using second_type = typename T::second_type;
+ − 378
+ − 379 const auto& ar = v.as_array();
+ − 380 if(ar.size() != 2)
+ − 381 {
+ − 382 throw std::out_of_range(detail::format_underline(concat_to_string(
+ − 383 "toml::get: specified std::pair but there are ", ar.size(),
+ − 384 " elements in toml array."), {{v.location(), "here"}}));
+ − 385 }
+ − 386 return std::make_pair(::toml::get<first_type >(ar.at(0)),
+ − 387 ::toml::get<second_type>(ar.at(1)));
+ − 388 }
+ − 389
+ − 390 // ============================================================================
+ − 391 // std::tuple.
+ − 392
+ − 393 namespace detail
+ − 394 {
+ − 395 template<typename T, typename Array, std::size_t ... I>
+ − 396 T get_tuple_impl(const Array& a, index_sequence<I...>)
+ − 397 {
+ − 398 return std::make_tuple(
+ − 399 ::toml::get<typename std::tuple_element<I, T>::type>(a.at(I))...);
+ − 400 }
+ − 401 } // detail
+ − 402
+ − 403 template<typename T, typename C,
+ − 404 template<typename ...> class M, template<typename ...> class V>
+ − 405 detail::enable_if_t<detail::is_std_tuple<T>::value, T>
+ − 406 get(const basic_value<C, M, V>& v)
+ − 407 {
+ − 408 const auto& ar = v.as_array();
+ − 409 if(ar.size() != std::tuple_size<T>::value)
+ − 410 {
+ − 411 throw std::out_of_range(detail::format_underline(concat_to_string(
+ − 412 "toml::get: specified std::tuple with ",
+ − 413 std::tuple_size<T>::value, " elements, but there are ", ar.size(),
+ − 414 " elements in toml array."), {{v.location(), "here"}}));
+ − 415 }
+ − 416 return detail::get_tuple_impl<T>(ar,
+ − 417 detail::make_index_sequence<std::tuple_size<T>::value>{});
+ − 418 }
+ − 419
+ − 420 // ============================================================================
+ − 421 // map-like types; most likely STL map, like std::map or std::unordered_map.
+ − 422
+ − 423 template<typename T, typename C,
+ − 424 template<typename ...> class M, template<typename ...> class V>
+ − 425 detail::enable_if_t<detail::conjunction<
+ − 426 detail::is_map<T>, // T is map
+ − 427 detail::negation< // but not toml::array
+ − 428 detail::is_exact_toml_type<T, basic_value<C, M, V>>>
+ − 429 >::value, T>
+ − 430 get(const basic_value<C, M, V>& v)
+ − 431 {
+ − 432 using key_type = typename T::key_type;
+ − 433 using mapped_type = typename T::mapped_type;
+ − 434 static_assert(std::is_convertible<std::string, key_type>::value,
+ − 435 "toml::get only supports map type of which key_type is "
+ − 436 "convertible from std::string.");
+ − 437 T map;
+ − 438 for(const auto& kv : v.as_table())
+ − 439 {
+ − 440 map.emplace(key_type(kv.first), get<mapped_type>(kv.second));
+ − 441 }
+ − 442 return map;
+ − 443 }
+ − 444
+ − 445 // ============================================================================
+ − 446 // user-defined, but compatible types.
+ − 447
+ − 448 template<typename T, typename C,
+ − 449 template<typename ...> class M, template<typename ...> class V>
+ − 450 detail::enable_if_t<detail::conjunction<
+ − 451 detail::negation< // not a toml::* type
+ − 452 detail::is_exact_toml_type<T, basic_value<C, M, V>>>,
+ − 453 detail::has_from_toml_method<T, C, M, V>, // but has from_toml(toml::value) memfn
+ − 454 std::is_default_constructible<T> // and default constructible
+ − 455 >::value, T>
+ − 456 get(const basic_value<C, M, V>& v)
+ − 457 {
+ − 458 T ud;
+ − 459 ud.from_toml(v);
+ − 460 return ud;
+ − 461 }
+ − 462 template<typename T, typename C,
+ − 463 template<typename ...> class M, template<typename ...> class V>
+ − 464 detail::enable_if_t<detail::has_specialized_from<T>::value, T>
+ − 465 get(const basic_value<C, M, V>& v)
+ − 466 {
+ − 467 return ::toml::from<T>::from_toml(v);
+ − 468 }
+ − 469 template<typename T, typename C,
+ − 470 template<typename ...> class M, template<typename ...> class V>
+ − 471 detail::enable_if_t<detail::has_specialized_from<T>::value, T>
+ − 472 get(basic_value<C, M, V>& v)
+ − 473 {
+ − 474 return ::toml::from<T>::from_toml(v);
+ − 475 }
+ − 476
+ − 477 template<typename T, typename C,
+ − 478 template<typename ...> class M, template<typename ...> class V>
+ − 479 detail::enable_if_t<detail::conjunction<
+ − 480 detail::negation<detail::is_basic_value<T>>, // T is not a toml::value
+ − 481 std::is_constructible<T, const basic_value<C, M, V>&>, // T is constructible from toml::value
+ − 482 detail::negation<detail::has_from_toml_method<T, C, M, V>>, // and T does not have T.from_toml(v);
+ − 483 detail::negation<detail::has_specialized_from<T>> // and T does not have toml::from<T>{};
+ − 484 >::value, T>
+ − 485 get(const basic_value<C, M, V>& v)
+ − 486 {
+ − 487 return T(v);
+ − 488 }
+ − 489
+ − 490 template<typename T, typename C,
+ − 491 template<typename ...> class M, template<typename ...> class V>
+ − 492 detail::enable_if_t<detail::conjunction<
+ − 493 detail::negation<detail::is_basic_value<T>>, // T is not a toml::value
+ − 494 std::is_constructible<T, basic_value<C, M, V>&>, // T is constructible from toml::value
+ − 495 detail::negation<detail::has_from_toml_method<T, C, M, V>>, // and T does not have T.from_toml(v);
+ − 496 detail::negation<detail::has_specialized_from<T>> // and T does not have toml::from<T>{};
+ − 497 >::value, T>
+ − 498 get(basic_value<C, M, V>& v)
+ − 499 {
+ − 500 return T(v);
+ − 501 }
+ − 502
+ − 503 // ============================================================================
+ − 504 // find
+ − 505
+ − 506 // ----------------------------------------------------------------------------
+ − 507 // these overloads do not require to set T. and returns value itself.
+ − 508 template<typename C,
+ − 509 template<typename ...> class M, template<typename ...> class V>
+ − 510 basic_value<C, M, V> const& find(const basic_value<C, M, V>& v, const key& ky)
+ − 511 {
+ − 512 const auto& tab = v.as_table();
+ − 513 if(tab.count(ky) == 0)
+ − 514 {
+ − 515 detail::throw_key_not_found_error(v, ky);
+ − 516 }
+ − 517 return tab.at(ky);
+ − 518 }
+ − 519 template<typename C,
+ − 520 template<typename ...> class M, template<typename ...> class V>
+ − 521 basic_value<C, M, V>& find(basic_value<C, M, V>& v, const key& ky)
+ − 522 {
+ − 523 auto& tab = v.as_table();
+ − 524 if(tab.count(ky) == 0)
+ − 525 {
+ − 526 detail::throw_key_not_found_error(v, ky);
+ − 527 }
+ − 528 return tab.at(ky);
+ − 529 }
+ − 530 template<typename C,
+ − 531 template<typename ...> class M, template<typename ...> class V>
+ − 532 basic_value<C, M, V> find(basic_value<C, M, V>&& v, const key& ky)
+ − 533 {
+ − 534 typename basic_value<C, M, V>::table_type tab = std::move(v).as_table();
+ − 535 if(tab.count(ky) == 0)
+ − 536 {
+ − 537 detail::throw_key_not_found_error(v, ky);
+ − 538 }
+ − 539 return basic_value<C, M, V>(std::move(tab.at(ky)));
+ − 540 }
+ − 541
+ − 542 // ----------------------------------------------------------------------------
+ − 543 // find(value, idx)
+ − 544 template<typename C,
+ − 545 template<typename ...> class M, template<typename ...> class V>
+ − 546 basic_value<C, M, V> const&
+ − 547 find(const basic_value<C, M, V>& v, const std::size_t idx)
+ − 548 {
+ − 549 const auto& ary = v.as_array();
+ − 550 if(ary.size() <= idx)
+ − 551 {
+ − 552 throw std::out_of_range(detail::format_underline(concat_to_string(
+ − 553 "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+ − 554 }
+ − 555 return ary.at(idx);
+ − 556 }
+ − 557 template<typename C,
+ − 558 template<typename ...> class M, template<typename ...> class V>
+ − 559 basic_value<C, M, V>& find(basic_value<C, M, V>& v, const std::size_t idx)
+ − 560 {
+ − 561 auto& ary = v.as_array();
+ − 562 if(ary.size() <= idx)
+ − 563 {
+ − 564 throw std::out_of_range(detail::format_underline(concat_to_string(
+ − 565 "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+ − 566 }
+ − 567 return ary.at(idx);
+ − 568 }
+ − 569 template<typename C,
+ − 570 template<typename ...> class M, template<typename ...> class V>
+ − 571 basic_value<C, M, V> find(basic_value<C, M, V>&& v, const std::size_t idx)
+ − 572 {
+ − 573 auto& ary = v.as_array();
+ − 574 if(ary.size() <= idx)
+ − 575 {
+ − 576 throw std::out_of_range(detail::format_underline(concat_to_string(
+ − 577 "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+ − 578 }
+ − 579 return basic_value<C, M, V>(std::move(ary.at(idx)));
+ − 580 }
+ − 581
+ − 582 // ----------------------------------------------------------------------------
+ − 583 // find<T>(value, key);
+ − 584
+ − 585 template<typename T, typename C,
+ − 586 template<typename ...> class M, template<typename ...> class V>
+ − 587 decltype(::toml::get<T>(std::declval<basic_value<C, M, V> const&>()))
+ − 588 find(const basic_value<C, M, V>& v, const key& ky)
+ − 589 {
+ − 590 const auto& tab = v.as_table();
+ − 591 if(tab.count(ky) == 0)
+ − 592 {
+ − 593 detail::throw_key_not_found_error(v, ky);
+ − 594 }
+ − 595 return ::toml::get<T>(tab.at(ky));
+ − 596 }
+ − 597
+ − 598 template<typename T, typename C,
+ − 599 template<typename ...> class M, template<typename ...> class V>
+ − 600 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&>()))
+ − 601 find(basic_value<C, M, V>& v, const key& ky)
+ − 602 {
+ − 603 auto& tab = v.as_table();
+ − 604 if(tab.count(ky) == 0)
+ − 605 {
+ − 606 detail::throw_key_not_found_error(v, ky);
+ − 607 }
+ − 608 return ::toml::get<T>(tab.at(ky));
+ − 609 }
+ − 610
+ − 611 template<typename T, typename C,
+ − 612 template<typename ...> class M, template<typename ...> class V>
+ − 613 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&&>()))
+ − 614 find(basic_value<C, M, V>&& v, const key& ky)
+ − 615 {
+ − 616 typename basic_value<C, M, V>::table_type tab = std::move(v).as_table();
+ − 617 if(tab.count(ky) == 0)
+ − 618 {
+ − 619 detail::throw_key_not_found_error(v, ky);
+ − 620 }
+ − 621 return ::toml::get<T>(std::move(tab.at(ky)));
+ − 622 }
+ − 623
+ − 624 // ----------------------------------------------------------------------------
+ − 625 // find<T>(value, idx)
+ − 626 template<typename T, typename C,
+ − 627 template<typename ...> class M, template<typename ...> class V>
+ − 628 decltype(::toml::get<T>(std::declval<basic_value<C, M, V> const&>()))
+ − 629 find(const basic_value<C, M, V>& v, const std::size_t idx)
+ − 630 {
+ − 631 const auto& ary = v.as_array();
+ − 632 if(ary.size() <= idx)
+ − 633 {
+ − 634 throw std::out_of_range(detail::format_underline(concat_to_string(
+ − 635 "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+ − 636 }
+ − 637 return ::toml::get<T>(ary.at(idx));
+ − 638 }
+ − 639 template<typename T, typename C,
+ − 640 template<typename ...> class M, template<typename ...> class V>
+ − 641 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&>()))
+ − 642 find(basic_value<C, M, V>& v, const std::size_t idx)
+ − 643 {
+ − 644 auto& ary = v.as_array();
+ − 645 if(ary.size() <= idx)
+ − 646 {
+ − 647 throw std::out_of_range(detail::format_underline(concat_to_string(
+ − 648 "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+ − 649 }
+ − 650 return ::toml::get<T>(ary.at(idx));
+ − 651 }
+ − 652 template<typename T, typename C,
+ − 653 template<typename ...> class M, template<typename ...> class V>
+ − 654 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&&>()))
+ − 655 find(basic_value<C, M, V>&& v, const std::size_t idx)
+ − 656 {
+ − 657 typename basic_value<C, M, V>::array_type ary = std::move(v).as_array();
+ − 658 if(ary.size() <= idx)
+ − 659 {
+ − 660 throw std::out_of_range(detail::format_underline(concat_to_string(
+ − 661 "index ", idx, " is out of range"), {{v.location(), "in this array"}}));
+ − 662 }
+ − 663 return ::toml::get<T>(std::move(ary.at(idx)));
+ − 664 }
+ − 665
+ − 666 // --------------------------------------------------------------------------
+ − 667 // toml::find(toml::value, toml::key, Ts&& ... keys)
+ − 668
+ − 669 namespace detail
+ − 670 {
+ − 671 // It suppresses warnings by -Wsign-conversion. Let's say we have the following
+ − 672 // code.
+ − 673 // ```cpp
+ − 674 // const auto x = toml::find<std::string>(data, "array", 0);
+ − 675 // ```
+ − 676 // Here, the type of literal number `0` is `int`. `int` is a signed integer.
+ − 677 // `toml::find` takes `std::size_t` as an index. So it causes implicit sign
+ − 678 // conversion and `-Wsign-conversion` warns about it. Using `0u` instead of `0`
+ − 679 // suppresses the warning, but it makes user code messy.
+ − 680 // To suppress this warning, we need to be aware of type conversion caused
+ − 681 // by `toml::find(v, key1, key2, ... keys)`. But the thing is that the types of
+ − 682 // keys can be any combination of {string-like, size_t-like}. Of course we can't
+ − 683 // write down all the combinations. Thus we need to use some function that
+ − 684 // recognize the type of argument and cast it into `std::string` or
+ − 685 // `std::size_t` depending on the context.
+ − 686 // `key_cast` does the job. It has 2 overloads. One is invoked when the
+ − 687 // argument type is an integer and cast the argument into `std::size_t`. The
+ − 688 // other is invoked when the argument type is not an integer, possibly one of
+ − 689 // std::string, const char[N] or const char*, and construct std::string from
+ − 690 // the argument.
+ − 691 // `toml::find(v, k1, k2, ... ks)` uses `key_cast` before passing `ks` to
+ − 692 // `toml::find(v, k)` to suppress -Wsign-conversion.
+ − 693
+ − 694 template<typename T>
+ − 695 enable_if_t<conjunction<std::is_integral<remove_cvref_t<T>>,
+ − 696 negation<std::is_same<remove_cvref_t<T>, bool>>>::value, std::size_t>
+ − 697 key_cast(T&& v) noexcept
+ − 698 {
+ − 699 return std::size_t(v);
+ − 700 }
+ − 701 template<typename T>
+ − 702 enable_if_t<negation<conjunction<std::is_integral<remove_cvref_t<T>>,
+ − 703 negation<std::is_same<remove_cvref_t<T>, bool>>>>::value, std::string>
+ − 704 key_cast(T&& v) noexcept
+ − 705 {
+ − 706 return std::string(std::forward<T>(v));
+ − 707 }
+ − 708 } // detail
+ − 709
+ − 710 template<typename C,
+ − 711 template<typename ...> class M, template<typename ...> class V,
+ − 712 typename Key1, typename Key2, typename ... Keys>
+ − 713 const basic_value<C, M, V>&
+ − 714 find(const basic_value<C, M, V>& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
+ − 715 {
+ − 716 return ::toml::find(::toml::find(v, detail::key_cast(k1)),
+ − 717 detail::key_cast(k2), std::forward<Keys>(keys)...);
+ − 718 }
+ − 719 template<typename C,
+ − 720 template<typename ...> class M, template<typename ...> class V,
+ − 721 typename Key1, typename Key2, typename ... Keys>
+ − 722 basic_value<C, M, V>&
+ − 723 find(basic_value<C, M, V>& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
+ − 724 {
+ − 725 return ::toml::find(::toml::find(v, detail::key_cast(k1)),
+ − 726 detail::key_cast(k2), std::forward<Keys>(keys)...);
+ − 727 }
+ − 728 template<typename C,
+ − 729 template<typename ...> class M, template<typename ...> class V,
+ − 730 typename Key1, typename Key2, typename ... Keys>
+ − 731 basic_value<C, M, V>
+ − 732 find(basic_value<C, M, V>&& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
+ − 733 {
+ − 734 return ::toml::find(::toml::find(std::move(v), std::forward<Key1>(k1)),
+ − 735 detail::key_cast(k2), std::forward<Keys>(keys)...);
+ − 736 }
+ − 737
+ − 738 template<typename T, typename C,
+ − 739 template<typename ...> class M, template<typename ...> class V,
+ − 740 typename Key1, typename Key2, typename ... Keys>
+ − 741 decltype(::toml::get<T>(std::declval<const basic_value<C, M, V>&>()))
+ − 742 find(const basic_value<C, M, V>& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
+ − 743 {
+ − 744 return ::toml::find<T>(::toml::find(v, detail::key_cast(k1)),
+ − 745 detail::key_cast(k2), std::forward<Keys>(keys)...);
+ − 746 }
+ − 747 template<typename T, typename C,
+ − 748 template<typename ...> class M, template<typename ...> class V,
+ − 749 typename Key1, typename Key2, typename ... Keys>
+ − 750 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&>()))
+ − 751 find(basic_value<C, M, V>& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
+ − 752 {
+ − 753 return ::toml::find<T>(::toml::find(v, detail::key_cast(k1)),
+ − 754 detail::key_cast(k2), std::forward<Keys>(keys)...);
+ − 755 }
+ − 756 template<typename T, typename C,
+ − 757 template<typename ...> class M, template<typename ...> class V,
+ − 758 typename Key1, typename Key2, typename ... Keys>
+ − 759 decltype(::toml::get<T>(std::declval<basic_value<C, M, V>&&>()))
+ − 760 find(basic_value<C, M, V>&& v, Key1&& k1, Key2&& k2, Keys&& ... keys)
+ − 761 {
+ − 762 return ::toml::find<T>(::toml::find(std::move(v), detail::key_cast(k1)),
+ − 763 detail::key_cast(k2), std::forward<Keys>(keys)...);
+ − 764 }
+ − 765
+ − 766 // ============================================================================
+ − 767 // get_or(value, fallback)
+ − 768
+ − 769 template<typename C,
+ − 770 template<typename ...> class M, template<typename ...> class V>
+ − 771 basic_value<C, M, V> const&
+ − 772 get_or(const basic_value<C, M, V>& v, const basic_value<C, M, V>&)
+ − 773 {
+ − 774 return v;
+ − 775 }
+ − 776 template<typename C,
+ − 777 template<typename ...> class M, template<typename ...> class V>
+ − 778 basic_value<C, M, V>&
+ − 779 get_or(basic_value<C, M, V>& v, basic_value<C, M, V>&)
+ − 780 {
+ − 781 return v;
+ − 782 }
+ − 783 template<typename C,
+ − 784 template<typename ...> class M, template<typename ...> class V>
+ − 785 basic_value<C, M, V>
+ − 786 get_or(basic_value<C, M, V>&& v, basic_value<C, M, V>&&)
+ − 787 {
+ − 788 return v;
+ − 789 }
+ − 790
+ − 791 // ----------------------------------------------------------------------------
+ − 792 // specialization for the exact toml types (return type becomes lvalue ref)
+ − 793
+ − 794 template<typename T, typename C,
+ − 795 template<typename ...> class M, template<typename ...> class V>
+ − 796 detail::enable_if_t<
+ − 797 detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T> const&
+ − 798 get_or(const basic_value<C, M, V>& v, const T& opt)
+ − 799 {
+ − 800 try
+ − 801 {
+ − 802 return get<detail::remove_cvref_t<T>>(v);
+ − 803 }
+ − 804 catch(...)
+ − 805 {
+ − 806 return opt;
+ − 807 }
+ − 808 }
+ − 809 template<typename T, typename C,
+ − 810 template<typename ...> class M, template<typename ...> class V>
+ − 811 detail::enable_if_t<
+ − 812 detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T>&
+ − 813 get_or(basic_value<C, M, V>& v, T& opt)
+ − 814 {
+ − 815 try
+ − 816 {
+ − 817 return get<detail::remove_cvref_t<T>>(v);
+ − 818 }
+ − 819 catch(...)
+ − 820 {
+ − 821 return opt;
+ − 822 }
+ − 823 }
+ − 824 template<typename T, typename C,
+ − 825 template<typename ...> class M, template<typename ...> class V>
+ − 826 detail::enable_if_t<detail::is_exact_toml_type<detail::remove_cvref_t<T>,
+ − 827 basic_value<C, M, V>>::value, detail::remove_cvref_t<T>>
+ − 828 get_or(basic_value<C, M, V>&& v, T&& opt)
+ − 829 {
+ − 830 try
+ − 831 {
+ − 832 return get<detail::remove_cvref_t<T>>(std::move(v));
+ − 833 }
+ − 834 catch(...)
+ − 835 {
+ − 836 return detail::remove_cvref_t<T>(std::forward<T>(opt));
+ − 837 }
+ − 838 }
+ − 839
+ − 840 // ----------------------------------------------------------------------------
+ − 841 // specialization for std::string (return type becomes lvalue ref)
+ − 842
+ − 843 template<typename T, typename C,
+ − 844 template<typename ...> class M, template<typename ...> class V>
+ − 845 detail::enable_if_t<std::is_same<detail::remove_cvref_t<T>, std::string>::value,
+ − 846 std::string> const&
+ − 847 get_or(const basic_value<C, M, V>& v, const T& opt)
+ − 848 {
+ − 849 try
+ − 850 {
+ − 851 return v.as_string().str;
+ − 852 }
+ − 853 catch(...)
+ − 854 {
+ − 855 return opt;
+ − 856 }
+ − 857 }
+ − 858 template<typename T, typename C,
+ − 859 template<typename ...> class M, template<typename ...> class V>
+ − 860 detail::enable_if_t<std::is_same<T, std::string>::value, std::string>&
+ − 861 get_or(basic_value<C, M, V>& v, T& opt)
+ − 862 {
+ − 863 try
+ − 864 {
+ − 865 return v.as_string().str;
+ − 866 }
+ − 867 catch(...)
+ − 868 {
+ − 869 return opt;
+ − 870 }
+ − 871 }
+ − 872 template<typename T, typename C,
+ − 873 template<typename ...> class M, template<typename ...> class V>
+ − 874 detail::enable_if_t<
+ − 875 std::is_same<detail::remove_cvref_t<T>, std::string>::value, std::string>
+ − 876 get_or(basic_value<C, M, V>&& v, T&& opt)
+ − 877 {
+ − 878 try
+ − 879 {
+ − 880 return std::move(v.as_string().str);
+ − 881 }
+ − 882 catch(...)
+ − 883 {
+ − 884 return std::string(std::forward<T>(opt));
+ − 885 }
+ − 886 }
+ − 887
+ − 888 // ----------------------------------------------------------------------------
+ − 889 // specialization for string literal
+ − 890
+ − 891 template<typename T, typename C,
+ − 892 template<typename ...> class M, template<typename ...> class V>
+ − 893 detail::enable_if_t<detail::is_string_literal<
+ − 894 typename std::remove_reference<T>::type>::value, std::string>
+ − 895 get_or(const basic_value<C, M, V>& v, T&& opt)
+ − 896 {
+ − 897 try
+ − 898 {
+ − 899 return std::move(v.as_string().str);
+ − 900 }
+ − 901 catch(...)
+ − 902 {
+ − 903 return std::string(std::forward<T>(opt));
+ − 904 }
+ − 905 }
+ − 906
+ − 907 // ----------------------------------------------------------------------------
+ − 908 // others (require type conversion and return type cannot be lvalue reference)
+ − 909
+ − 910 template<typename T, typename C,
+ − 911 template<typename ...> class M, template<typename ...> class V>
+ − 912 detail::enable_if_t<detail::conjunction<
+ − 913 detail::negation<detail::is_exact_toml_type<detail::remove_cvref_t<T>,
+ − 914 basic_value<C, M, V>>>,
+ − 915 detail::negation<std::is_same<std::string, detail::remove_cvref_t<T>>>,
+ − 916 detail::negation<detail::is_string_literal<
+ − 917 typename std::remove_reference<T>::type>>
+ − 918 >::value, detail::remove_cvref_t<T>>
+ − 919 get_or(const basic_value<C, M, V>& v, T&& opt)
+ − 920 {
+ − 921 try
+ − 922 {
+ − 923 return get<detail::remove_cvref_t<T>>(v);
+ − 924 }
+ − 925 catch(...)
+ − 926 {
+ − 927 return detail::remove_cvref_t<T>(std::forward<T>(opt));
+ − 928 }
+ − 929 }
+ − 930
+ − 931 // ===========================================================================
+ − 932 // find_or(value, key, fallback)
+ − 933
+ − 934 template<typename C,
+ − 935 template<typename ...> class M, template<typename ...> class V>
+ − 936 basic_value<C, M, V> const&
+ − 937 find_or(const basic_value<C, M, V>& v, const key& ky,
+ − 938 const basic_value<C, M, V>& opt)
+ − 939 {
+ − 940 if(!v.is_table()) {return opt;}
+ − 941 const auto& tab = v.as_table();
+ − 942 if(tab.count(ky) == 0) {return opt;}
+ − 943 return tab.at(ky);
+ − 944 }
+ − 945
+ − 946 template<typename C,
+ − 947 template<typename ...> class M, template<typename ...> class V>
+ − 948 basic_value<C, M, V>&
+ − 949 find_or(basic_value<C, M, V>& v, const toml::key& ky, basic_value<C, M, V>& opt)
+ − 950 {
+ − 951 if(!v.is_table()) {return opt;}
+ − 952 auto& tab = v.as_table();
+ − 953 if(tab.count(ky) == 0) {return opt;}
+ − 954 return tab.at(ky);
+ − 955 }
+ − 956
+ − 957 template<typename C,
+ − 958 template<typename ...> class M, template<typename ...> class V>
+ − 959 basic_value<C, M, V>
+ − 960 find_or(basic_value<C, M, V>&& v, const toml::key& ky, basic_value<C, M, V>&& opt)
+ − 961 {
+ − 962 if(!v.is_table()) {return opt;}
+ − 963 auto tab = std::move(v).as_table();
+ − 964 if(tab.count(ky) == 0) {return opt;}
+ − 965 return basic_value<C, M, V>(std::move(tab.at(ky)));
+ − 966 }
+ − 967
+ − 968 // ---------------------------------------------------------------------------
+ − 969 // exact types (return type can be a reference)
+ − 970 template<typename T, typename C,
+ − 971 template<typename ...> class M, template<typename ...> class V>
+ − 972 detail::enable_if_t<
+ − 973 detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T> const&
+ − 974 find_or(const basic_value<C, M, V>& v, const key& ky, const T& opt)
+ − 975 {
+ − 976 if(!v.is_table()) {return opt;}
+ − 977 const auto& tab = v.as_table();
+ − 978 if(tab.count(ky) == 0) {return opt;}
+ − 979 return get_or(tab.at(ky), opt);
+ − 980 }
+ − 981
+ − 982 template<typename T, typename C,
+ − 983 template<typename ...> class M, template<typename ...> class V>
+ − 984 detail::enable_if_t<
+ − 985 detail::is_exact_toml_type<T, basic_value<C, M, V>>::value, T>&
+ − 986 find_or(basic_value<C, M, V>& v, const toml::key& ky, T& opt)
+ − 987 {
+ − 988 if(!v.is_table()) {return opt;}
+ − 989 auto& tab = v.as_table();
+ − 990 if(tab.count(ky) == 0) {return opt;}
+ − 991 return get_or(tab.at(ky), opt);
+ − 992 }
+ − 993
+ − 994 template<typename T, typename C,
+ − 995 template<typename ...> class M, template<typename ...> class V>
+ − 996 detail::enable_if_t<
+ − 997 detail::is_exact_toml_type<T, basic_value<C, M, V>>::value,
+ − 998 detail::remove_cvref_t<T>>
+ − 999 find_or(basic_value<C, M, V>&& v, const toml::key& ky, T&& opt)
+ − 1000 {
+ − 1001 if(!v.is_table()) {return std::forward<T>(opt);}
+ − 1002 auto tab = std::move(v).as_table();
+ − 1003 if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+ − 1004 return get_or(std::move(tab.at(ky)), std::forward<T>(opt));
+ − 1005 }
+ − 1006
+ − 1007 // ---------------------------------------------------------------------------
+ − 1008 // std::string (return type can be a reference)
+ − 1009
+ − 1010 template<typename T, typename C,
+ − 1011 template<typename ...> class M, template<typename ...> class V>
+ − 1012 detail::enable_if_t<std::is_same<T, std::string>::value, std::string> const&
+ − 1013 find_or(const basic_value<C, M, V>& v, const key& ky, const T& opt)
+ − 1014 {
+ − 1015 if(!v.is_table()) {return opt;}
+ − 1016 const auto& tab = v.as_table();
+ − 1017 if(tab.count(ky) == 0) {return opt;}
+ − 1018 return get_or(tab.at(ky), opt);
+ − 1019 }
+ − 1020 template<typename T, typename C,
+ − 1021 template<typename ...> class M, template<typename ...> class V>
+ − 1022 detail::enable_if_t<std::is_same<T, std::string>::value, std::string>&
+ − 1023 find_or(basic_value<C, M, V>& v, const toml::key& ky, T& opt)
+ − 1024 {
+ − 1025 if(!v.is_table()) {return opt;}
+ − 1026 auto& tab = v.as_table();
+ − 1027 if(tab.count(ky) == 0) {return opt;}
+ − 1028 return get_or(tab.at(ky), opt);
+ − 1029 }
+ − 1030 template<typename T, typename C,
+ − 1031 template<typename ...> class M, template<typename ...> class V>
+ − 1032 detail::enable_if_t<std::is_same<T, std::string>::value, std::string>
+ − 1033 find_or(basic_value<C, M, V>&& v, const toml::key& ky, T&& opt)
+ − 1034 {
+ − 1035 if(!v.is_table()) {return std::forward<T>(opt);}
+ − 1036 auto tab = std::move(v).as_table();
+ − 1037 if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+ − 1038 return get_or(std::move(tab.at(ky)), std::forward<T>(opt));
+ − 1039 }
+ − 1040
+ − 1041 // ---------------------------------------------------------------------------
+ − 1042 // string literal (deduced as std::string)
+ − 1043 template<typename T, typename C,
+ − 1044 template<typename ...> class M, template<typename ...> class V>
+ − 1045 detail::enable_if_t<
+ − 1046 detail::is_string_literal<typename std::remove_reference<T>::type>::value,
+ − 1047 std::string>
+ − 1048 find_or(const basic_value<C, M, V>& v, const toml::key& ky, T&& opt)
+ − 1049 {
+ − 1050 if(!v.is_table()) {return std::string(opt);}
+ − 1051 const auto& tab = v.as_table();
+ − 1052 if(tab.count(ky) == 0) {return std::string(opt);}
+ − 1053 return get_or(tab.at(ky), std::forward<T>(opt));
+ − 1054 }
+ − 1055
+ − 1056 // ---------------------------------------------------------------------------
+ − 1057 // others (require type conversion and return type cannot be lvalue reference)
+ − 1058 template<typename T, typename C,
+ − 1059 template<typename ...> class M, template<typename ...> class V>
+ − 1060 detail::enable_if_t<detail::conjunction<
+ − 1061 // T is not an exact toml type
+ − 1062 detail::negation<detail::is_exact_toml_type<
+ − 1063 detail::remove_cvref_t<T>, basic_value<C, M, V>>>,
+ − 1064 // T is not std::string
+ − 1065 detail::negation<std::is_same<std::string, detail::remove_cvref_t<T>>>,
+ − 1066 // T is not a string literal
+ − 1067 detail::negation<detail::is_string_literal<
+ − 1068 typename std::remove_reference<T>::type>>
+ − 1069 >::value, detail::remove_cvref_t<T>>
+ − 1070 find_or(const basic_value<C, M, V>& v, const toml::key& ky, T&& opt)
+ − 1071 {
+ − 1072 if(!v.is_table()) {return std::forward<T>(opt);}
+ − 1073 const auto& tab = v.as_table();
+ − 1074 if(tab.count(ky) == 0) {return std::forward<T>(opt);}
+ − 1075 return get_or(tab.at(ky), std::forward<T>(opt));
+ − 1076 }
+ − 1077
+ − 1078 // ---------------------------------------------------------------------------
+ − 1079 // recursive find-or with type deduction (find_or(value, keys, opt))
+ − 1080
+ − 1081 template<typename Value, typename ... Ks,
+ − 1082 typename detail::enable_if_t<(sizeof...(Ks) > 1), std::nullptr_t> = nullptr>
+ − 1083 // here we need to add SFINAE in the template parameter to avoid
+ − 1084 // infinite recursion in type deduction on gcc
+ − 1085 auto find_or(Value&& v, const toml::key& ky, Ks&& ... keys)
+ − 1086 -> decltype(find_or(std::forward<Value>(v), ky, detail::last_one(std::forward<Ks>(keys)...)))
+ − 1087 {
+ − 1088 if(!v.is_table())
+ − 1089 {
+ − 1090 return detail::last_one(std::forward<Ks>(keys)...);
+ − 1091 }
+ − 1092 auto&& tab = std::forward<Value>(v).as_table();
+ − 1093 if(tab.count(ky) == 0)
+ − 1094 {
+ − 1095 return detail::last_one(std::forward<Ks>(keys)...);
+ − 1096 }
+ − 1097 return find_or(std::forward<decltype(tab)>(tab).at(ky), std::forward<Ks>(keys)...);
+ − 1098 }
+ − 1099
+ − 1100 // ---------------------------------------------------------------------------
+ − 1101 // recursive find_or with explicit type specialization, find_or<int>(value, keys...)
+ − 1102
+ − 1103 template<typename T, typename Value, typename ... Ks,
+ − 1104 typename detail::enable_if_t<(sizeof...(Ks) > 1), std::nullptr_t> = nullptr>
+ − 1105 // here we need to add SFINAE in the template parameter to avoid
+ − 1106 // infinite recursion in type deduction on gcc
+ − 1107 auto find_or(Value&& v, const toml::key& ky, Ks&& ... keys)
+ − 1108 -> decltype(find_or<T>(std::forward<Value>(v), ky, detail::last_one(std::forward<Ks>(keys)...)))
+ − 1109 {
+ − 1110 if(!v.is_table())
+ − 1111 {
+ − 1112 return detail::last_one(std::forward<Ks>(keys)...);
+ − 1113 }
+ − 1114 auto&& tab = std::forward<Value>(v).as_table();
+ − 1115 if(tab.count(ky) == 0)
+ − 1116 {
+ − 1117 return detail::last_one(std::forward<Ks>(keys)...);
+ − 1118 }
+ − 1119 return find_or(std::forward<decltype(tab)>(tab).at(ky), std::forward<Ks>(keys)...);
+ − 1120 }
+ − 1121
+ − 1122 // ============================================================================
+ − 1123 // expect
+ − 1124
+ − 1125 template<typename T, typename C,
+ − 1126 template<typename ...> class M, template<typename ...> class V>
+ − 1127 result<T, std::string> expect(const basic_value<C, M, V>& v) noexcept
+ − 1128 {
+ − 1129 try
+ − 1130 {
+ − 1131 return ok(get<T>(v));
+ − 1132 }
+ − 1133 catch(const std::exception& e)
+ − 1134 {
+ − 1135 return err(e.what());
+ − 1136 }
+ − 1137 }
+ − 1138 template<typename T, typename C,
+ − 1139 template<typename ...> class M, template<typename ...> class V>
+ − 1140 result<T, std::string>
+ − 1141 expect(const basic_value<C, M, V>& v, const toml::key& k) noexcept
+ − 1142 {
+ − 1143 try
+ − 1144 {
+ − 1145 return ok(find<T>(v, k));
+ − 1146 }
+ − 1147 catch(const std::exception& e)
+ − 1148 {
+ − 1149 return err(e.what());
+ − 1150 }
+ − 1151 }
+ − 1152
+ − 1153 } // toml
+ − 1154 #endif// TOML11_GET