common.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/formats/parse/common.hpp
/// @brief Parsers and converters for std::chrono::seconds,
/// std::chrono::system_clock::time_point and integral types
///
/// @ingroup userver_universal userver_formats_parse
 
#include <chrono>
#include <cmath>
#include <cstdint>
#include <limits>
 
#include <fmt/format.h>
 
#include <userver/formats/common/meta.hpp>
#include <userver/formats/parse/to.hpp>
#include <userver/utils/datetime/from_string_saturating.hpp>
#include <userver/utils/datetime_light.hpp>
#include <userver/utils/meta.hpp>
#include <userver/utils/string_to_duration.hpp>
 
USERVER_NAMESPACE_BEGIN
 
/// Generic parsers and converters
namespace formats::parse {
namespace impl {
 
template <typename T, typename Value>
void CheckInBounds(const Value& value, T x, T min, T max) {
    if (x < min || x > max) {
        throw typename Value::ParseException(
            fmt::format("Value of '{}' is out of bounds ({} <= {} <= {})", value.GetPath(), min, x, max)
        );
    }
}
 
template <typename Value>
void CheckDoubleFitsInFloat(const Value& value, const double dval) {
    if (!std::isfinite(dval)) {
        auto msg = fmt::format(
            "Double value ({}) of '{}' is prohibited for use. Inf and NaN values lead to vulnerabilities in code",
            dval,
            value.GetPath()
        );
        UASSERT_MSG(false, msg);
        throw typename Value::ParseException(std::move(msg));
    }
 
    auto fval = static_cast<float>(dval);
 
    if (!std::isfinite(fval)) {
        throw typename Value::ParseException(
            fmt::format("Double value ({}) of '{}' does not fit into float", dval, value.GetPath())
        );
    }
}
 
template <typename Value>
float NarrowToFloat(double x, const Value& value) {
    impl::CheckDoubleFitsInFloat(value, x);
    return static_cast<float>(x);
}
 
template <typename Dst, typename Value, typename Src>
Dst NarrowToInt(Src x, const Value& value) {
    static_assert(
        std::numeric_limits<Src>::min() <= std::numeric_limits<Dst>::min() &&
            std::numeric_limits<Src>::max() >= std::numeric_limits<Dst>::max(),
        "expanding cast requested"
    );
 
    CheckInBounds<Src>(value, x, std::numeric_limits<Dst>::min(), std::numeric_limits<Dst>::max());
    return static_cast<Dst>(x);
}
 
template <typename Value>
std::chrono::seconds ToSeconds(const std::string& data, const Value& value) {
    const auto ms = utils::StringToDuration(data);
    const auto converted = std::chrono::duration_cast<std::chrono::seconds>(ms);
    if (converted != ms) {
        throw typename Value::ParseException(fmt::format(
            "Value of '{}' = {}ms cannot be represented as "
            "'std::chrono::seconds' without precision loss",
            value.GetPath(),
            ms.count()
        ));
    }
    return converted;
}
 
}  // namespace impl
 
template <typename Value>
float Parse(const Value& value, To<float>) {
    return impl::NarrowToFloat(value.template As<double>(), value);
}
 
template <common::kIsFormatValue Value, meta::kIsInteger T>
T Parse(const Value& value, To<T>) {
    using IntT = std::conditional_t<std::is_signed<T>::value, int64_t, uint64_t>;
    return impl::NarrowToInt<T>(value.template As<IntT>(), value);
}
 
template <common::kIsFormatValue Value, typename Period>
std::chrono::duration<double, Period> Parse(const Value& n, To<std::chrono::duration<double, Period>>) {
    return std::chrono::duration<double, Period>(n.template As<double>());
}
 
template <common::kIsFormatValue Value>
std::chrono::seconds Parse(const Value& n, To<std::chrono::seconds>) {
    return n.IsInt64() ? std::chrono::seconds{n.template As<int64_t>()}
                       : impl::ToSeconds(n.template As<std::string>(), n);
}
 
template <class Value, class Duration>
std::chrono::time_point<std::chrono::system_clock, Duration>
Parse(const Value& n, To<std::chrono::time_point<std::chrono::system_clock, Duration>>) {
    return utils::datetime::FromRfc3339StringSaturating<Duration>(n.template As<std::string>());
}
 
template <class Value>
float Convert(const Value& value, To<float>) {
    return impl::NarrowToFloat(value.template ConvertTo<double>(), value);
}
 
template <typename Value, meta::kIsInteger T>
T Convert(const Value& value, To<T>) {
    using IntT = std::conditional_t<std::is_signed<T>::value, int64_t, uint64_t>;
    return impl::NarrowToInt<T>(value.template ConvertTo<IntT>(), value);
}
 
template <typename Value>
std::chrono::seconds Convert(const Value& n, To<std::chrono::seconds>) {
    return n.IsInt64() ? std::chrono::seconds{n.template ConvertTo<int64_t>()}
                       : impl::ToSeconds(n.template ConvertTo<std::string>(), n);
}
 
}  // namespace formats::parse
 
USERVER_NAMESPACE_END