cc userver: use C++20 requires clause instead of std::enable_if_t

commit_hash:1fa571afee67adfc78ef513671961447b681d272

Author: Anton3

core/include/userver/baggage/baggage.hpp

@@ -144,7 +144,7 @@ std::optional<Baggage> TryMakeBaggage(std::string header, std::unordered_set<std
 
 template <typename T>
 bool HasInvalidSymbols(const T& obj) {
-    return std::find_if(obj.begin(), obj.end(), [](unsigned char x) {
+    return std::ranges::find_if(obj, [](unsigned char x) {
                return x == ',' || x == ';' || x == '=' || std::isspace(x);
            }) != obj.end();
 }

core/include/userver/clients/http/request.hpp

@@ -329,7 +329,8 @@ class Request final {
 
     /// @overload
     template <typename T>
-    std::enable_if_t<std::is_same_v<ConnectTo, T>, Request&> connect_to(T&&) {
+    requires std::is_same_v<ConnectTo, T>
+    Request& connect_to(T&&) {
         static_assert(!sizeof(T), "ConnectTo argument must not be temporary, it must outlive Request");
         return *this;
     }

core/include/userver/components/container.hpp

@@ -24,16 +24,13 @@ class Container;
 
 namespace impl {
 
-template <typename T, typename = void>
-struct ContainerHasName : std::false_type {};
-
 template <typename T>
-struct ContainerHasName<T, utils::void_t<decltype(ContainerName(Of<T>()))>> : std::true_type {};
+concept ContainerHasName = requires { ContainerName(Of<T>{}); };
 
 template <typename T>
 constexpr std::string_view GetContainerName()
 {
-    if constexpr (ContainerHasName<T>::value) {
+    if constexpr (ContainerHasName<T>) {
         return ContainerName(Of<T>());
     } else {
         static_assert(!sizeof(T), "Container name is not registered. Forgot to define ContainerName(Of<T>)?");
@@ -62,12 +59,14 @@ struct DependencyLocator {
         && !!sizeof(LocateDependencyResult<T>)             // 2) U is locate'able
         ;
 
-    template <typename T, typename = std::enable_if_t<!kIsReference<T> && kIsLocatable<T>>>
+    template <typename T>
+    requires(!kIsReference<T> && kIsLocatable<T>)
     operator T() const {
         return LocateDependency(WithType<std::decay_t<T>>{}, config, context);
     }
 
-    template <typename T, typename = std::enable_if_t<kIsReference<T> && kIsLocatable<T>>>
+    template <typename T>
+    requires(kIsReference<T> && kIsLocatable<T>)
     operator T&() const {
         return LocateDependency(WithType<std::decay_t<T>>{}, config, context);
     }
@@ -93,21 +92,15 @@ T LocateDependency(WithType<T>, const ComponentConfig& config, const ComponentCo
 }
 
 template <typename T>
-std::enable_if_t<impl::ContainerHasName<T>::value, T&> LocateDependency(
-    WithType<T>,
-    const ComponentConfig&,
-    const ComponentContext& context
-)
+requires impl::ContainerHasName<T>
+T& LocateDependency(WithType<T>, const ComponentConfig&, const ComponentContext& context)
 {
     return context.FindComponent<Container<T>>().Get();
 }
 
 template <typename T>
-std::enable_if_t<std::is_base_of_v<RawComponentBase, T>, T&> LocateDependency(
-    WithType<T>,
-    const ComponentConfig&,
-    const ComponentContext& context
-)
+requires std::is_base_of_v<RawComponentBase, T>
+T& LocateDependency(WithType<T>, const ComponentConfig&, const ComponentContext& context)
 {
     return context.FindComponent<T>();
 }

core/include/userver/components/raw_component_base.hpp

@@ -4,7 +4,6 @@
 /// @brief @copybrief components::RawComponentBase
 
 #include <type_traits>
-#include <userver/utils/void_t.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -76,12 +75,12 @@ inline constexpr bool kForceNoValidation = false;
 
 namespace impl {
 
-template <typename Component, typename = void>
+template <typename Component>
 inline constexpr auto kDefaultConfigFileMode = ConfigFileMode::kRequired;
 
 template <typename Component>
-inline constexpr auto
-    kDefaultConfigFileMode<Component, utils::void_t<decltype(Component::kConfigFileMode)>> = Component::kConfigFileMode;
+requires requires { Component::kConfigFileMode; }
+inline constexpr auto kDefaultConfigFileMode<Component> = Component::kConfigFileMode;
 }  // namespace impl
 
 /// Specialize this to customize the loading of component settings

core/include/userver/dump/aggregates.hpp

@@ -68,7 +68,8 @@ T ReadAggregate(Reader& reader, std::index_sequence<Indices...>) {
 ///
 /// @warning Don't forget to increment format-version if data layout changes
 template <typename T>
-std::enable_if_t<impl::IsDumpableAggregate<T>()> Write(Writer& writer, const T& value) {
+requires(impl::IsDumpableAggregate<T>())
+void Write(Writer& writer, const T& value) {
     boost::pfr::for_each_field(value, [&writer](const auto& field) { writer.Write(field); });
 }
 
@@ -83,7 +84,8 @@ std::enable_if_t<impl::IsDumpableAggregate<T>()> Write(Writer& writer, const T&
 ///
 /// @warning Don't forget to increment format-version if data layout changes
 template <typename T>
-std::enable_if_t<impl::IsDumpableAggregate<T>(), T> Read(Reader& reader, To<T>) {
+requires(impl::IsDumpableAggregate<T>())
+T Read(Reader& reader, To<T>) {
     constexpr auto kSize = boost::pfr::tuple_size_v<T>;
     return impl::ReadAggregate<T>(reader, std::make_index_sequence<kSize>{});
 }

core/include/userver/dump/common.hpp

@@ -84,7 +84,8 @@ void Write(Writer& writer, const char* value);
 
 /// @brief Integral types serialization support
 template <typename T>
-std::enable_if_t<meta::kIsInteger<T>> Write(Writer& writer, T value) {
+requires meta::kIsInteger<T>
+void Write(Writer& writer, T value) {
     if constexpr (sizeof(T) == 1) {
         impl::WriteTrivial(writer, value);
     } else {
@@ -94,7 +95,8 @@ std::enable_if_t<meta::kIsInteger<T>> Write(Writer& writer, T value) {
 
 /// @brief Integral types deserialization support
 template <typename T>
-std::enable_if_t<meta::kIsInteger<T>, T> Read(Reader& reader, To<T>) {
+requires meta::kIsInteger<T>
+T Read(Reader& reader, To<T>) {
     if constexpr (sizeof(T) == 1) {
         return impl::ReadTrivial<T>(reader);
     }
@@ -110,13 +112,15 @@ std::enable_if_t<meta::kIsInteger<T>, T> Read(Reader& reader, To<T>) {
 
 /// @brief Floating-point serialization support
 template <typename T>
-std::enable_if_t<std::is_floating_point_v<T>> Write(Writer& writer, T value) {
+requires std::is_floating_point_v<T>
+void Write(Writer& writer, T value) {
     impl::WriteTrivial(writer, value);
 }
 
 /// @brief Floating-point deserialization support
 template <typename T>
-std::enable_if_t<std::is_floating_point_v<T>, T> Read(Reader& reader, To<T>) {
+requires std::is_floating_point_v<T>
+T Read(Reader& reader, To<T>) {
     return impl::ReadTrivial<T>(reader);
 }
 
@@ -128,13 +132,15 @@ bool Read(Reader& reader, To<bool>);
 
 /// @brief enum serialization support
 template <typename T>
-std::enable_if_t<std::is_enum_v<T>> Write(Writer& writer, T value) {
+requires std::is_enum_v<T>
+void Write(Writer& writer, T value) {
     writer.Write(static_cast<std::underlying_type_t<T>>(value));
 }
 
 /// @brief enum deserialization support
 template <typename T>
-std::enable_if_t<std::is_enum_v<T>, T> Read(Reader& reader, To<T>) {
+requires std::is_enum_v<T>
+T Read(Reader& reader, To<T>) {
     return static_cast<T>(reader.Read<std::underlying_type_t<T>>());
 }
 

core/include/userver/dump/common_containers.hpp

@@ -93,7 +93,8 @@ VariantType ReadVariant(Reader& reader, std::size_t index) {
 
 /// @brief Container serialization support
 template <typename T>
-std::enable_if_t<kIsContainer<T> && kIsWritable<meta::RangeValueType<T>>> Write(Writer& writer, const T& value) {
+requires(kIsContainer<T> && kIsWritable<meta::RangeValueType<T>>)
+void Write(Writer& writer, const T& value) {
     writer.Write(std::size(value));
     for (const auto& item : value) {
         // explicit cast for vector<bool> shenanigans
@@ -103,7 +104,8 @@ std::enable_if_t<kIsContainer<T> && kIsWritable<meta::RangeValueType<T>>> Write(
 
 /// @brief Container deserialization support
 template <typename T>
-std::enable_if_t<kIsContainer<T> && kIsReadable<meta::RangeValueType<T>>, T> Read(Reader& reader, To<T>) {
+requires(kIsContainer<T> && kIsReadable<meta::RangeValueType<T>>)
+T Read(Reader& reader, To<T>) {
     const auto size = reader.Read<std::size_t>();
     T result{};
     if constexpr (meta::kIsReservable<T>) {
@@ -117,20 +119,23 @@ std::enable_if_t<kIsContainer<T> && kIsReadable<meta::RangeValueType<T>>, T> Rea
 
 /// @brief Pair serialization support (for maps)
 template <typename T, typename U>
-std::enable_if_t<kIsWritable<T> && kIsWritable<U>, void> Write(Writer& writer, const std::pair<T, U>& value) {
+requires(kIsWritable<T> && kIsWritable<U>)
+void Write(Writer& writer, const std::pair<T, U>& value) {
     writer.Write(value.first);
     writer.Write(value.second);
 }
 
 /// @brief Pair deserialization support (for maps)
 template <typename T, typename U>
-std::enable_if_t<kIsReadable<T> && kIsReadable<U>, std::pair<T, U>> Read(Reader& reader, To<std::pair<T, U>>) {
+requires(kIsReadable<T> && kIsReadable<U>)
+std::pair<T, U> Read(Reader& reader, To<std::pair<T, U>>) {
     return {reader.Read<T>(), reader.Read<U>()};
 }
 
 /// @brief `std::optional` serialization support
 template <typename T>
-std::enable_if_t<kIsWritable<T>> Write(Writer& writer, const std::optional<T>& value) {
+requires kIsWritable<T>
+void Write(Writer& writer, const std::optional<T>& value) {
     writer.Write(value.has_value());
     if (value) {
         writer.Write(*value);
@@ -139,7 +144,8 @@ std::enable_if_t<kIsWritable<T>> Write(Writer& writer, const std::optional<T>& v
 
 /// @brief `std::optional` deserialization support
 template <typename T>
-std::enable_if_t<kIsReadable<T>, std::optional<T>> Read(Reader& reader, To<std::optional<T>>) {
+requires kIsReadable<T>
+std::optional<T> Read(Reader& reader, To<std::optional<T>>) {
     if (!reader.Read<bool>()) {
         return std::nullopt;
     }
@@ -148,15 +154,16 @@ std::enable_if_t<kIsReadable<T>, std::optional<T>> Read(Reader& reader, To<std::
 
 /// @brief `std::variant` serialization support
 template <typename... Args>
-std::enable_if_t<(true && ... && kIsWritable<Args>)> Write(Writer& writer, const std::variant<Args...>& value) {
+requires(true && ... && kIsWritable<Args>)
+void Write(Writer& writer, const std::variant<Args...>& value) {
     writer.Write(value.index());
     std::visit([&writer](const auto& inner) { writer.Write(inner); }, value);
 }
 
 /// @brief `std::variant` deserialization support
 template <typename... Args>
-std::enable_if_t<(true && ... && (std::is_move_constructible_v<Args> && kIsReadable<Args>)), std::variant<Args...>>
-Read(Reader& reader, To<std::variant<Args...>>) {
+requires(true && ... && (std::is_move_constructible_v<Args> && kIsReadable<Args>))
+std::variant<Args...> Read(Reader& reader, To<std::variant<Args...>>) {
     const auto index = reader.Read<std::size_t>();
     if (index >= sizeof...(Args)) {
         impl::ThrowInvalidVariantIndex(typeid(std::variant<Args...>), index);
@@ -167,26 +174,29 @@ Read(Reader& reader, To<std::variant<Args...>>) {
 /// Allows reading `const T`, which is usually encountered as a member of some
 /// container
 template <typename T>
-std::enable_if_t<kIsReadable<T>, T> Read(Reader& reader, To<const T>) {
+requires kIsReadable<T>
+T Read(Reader& reader, To<const T>) {
     return Read(reader, To<T>{});
 }
 
 /// @brief utils::StrongTypedef serialization support
 template <typename Tag, typename T, utils::StrongTypedefOps Ops>
-std::enable_if_t<kIsWritable<T>> Write(Writer& writer, const utils::StrongTypedef<Tag, T, Ops>& object) {
+requires kIsWritable<T>
+void Write(Writer& writer, const utils::StrongTypedef<Tag, T, Ops>& object) {
     writer.Write(object.GetUnderlying());
 }
 
 /// @brief utils::StrongTypedef deserialization support
 template <typename Tag, typename T, utils::StrongTypedefOps Ops>
-std::enable_if_t<kIsReadable<T>, utils::StrongTypedef<Tag, T, Ops>>
-Read(Reader& reader, To<utils::StrongTypedef<Tag, T, Ops>>) {
+requires kIsReadable<T>
+utils::StrongTypedef<Tag, T, Ops> Read(Reader& reader, To<utils::StrongTypedef<Tag, T, Ops>>) {
     return utils::StrongTypedef<Tag, T, Ops>{reader.Read<T>()};
 }
 
 /// @brief `std::unique_ptr` serialization support
 template <typename T>
-std::enable_if_t<kIsWritable<T>> Write(Writer& writer, const std::unique_ptr<T>& ptr) {
+requires kIsWritable<T>
+void Write(Writer& writer, const std::unique_ptr<T>& ptr) {
     writer.Write(static_cast<bool>(ptr));
     if (ptr) {
         writer.Write(*ptr);
@@ -195,7 +205,8 @@ std::enable_if_t<kIsWritable<T>> Write(Writer& writer, const std::unique_ptr<T>&
 
 /// @brief `std::unique_ptr` deserialization support
 template <typename T>
-std::enable_if_t<kIsReadable<T>, std::unique_ptr<T>> Read(Reader& reader, To<std::unique_ptr<T>>) {
+requires kIsReadable<T>
+std::unique_ptr<T> Read(Reader& reader, To<std::unique_ptr<T>>) {
     if (!reader.Read<bool>()) {
         return {};
     }
@@ -206,7 +217,8 @@ std::enable_if_t<kIsReadable<T>, std::unique_ptr<T>> Read(Reader& reader, To<std
 /// @warning If two or more `shared_ptr` within a single dumped entity point to
 /// the same object, they will point to its distinct copies after loading a dump
 template <typename T>
-std::enable_if_t<kIsWritable<T>> Write(Writer& writer, const std::shared_ptr<T>& ptr) {
+requires kIsWritable<T>
+void Write(Writer& writer, const std::shared_ptr<T>& ptr) {
     writer.Write(static_cast<bool>(ptr));
     if (ptr) {
         writer.Write(*ptr);
@@ -217,7 +229,8 @@ std::enable_if_t<kIsWritable<T>> Write(Writer& writer, const std::shared_ptr<T>&
 /// @warning If two or more `shared_ptr` within a single dumped entity point to
 /// the same object, they will point to its distinct copies after loading a dump
 template <typename T>
-std::enable_if_t<kIsReadable<T>, std::shared_ptr<T>> Read(Reader& reader, To<std::shared_ptr<T>>) {
+requires kIsReadable<T>
+std::shared_ptr<T> Read(Reader& reader, To<std::shared_ptr<T>>) {
     if (!reader.Read<bool>()) {
         return {};
     }
@@ -226,9 +239,8 @@ std::enable_if_t<kIsReadable<T>, std::shared_ptr<T>> Read(Reader& reader, To<std
 
 /// @brief `boost::bimap` serialization support
 template <typename L, typename R, typename... Args>
-std::enable_if_t<
-    kIsWritable<impl::BoostBimapLeftKey<L, R, Args...>> && kIsWritable<impl::BoostBimapRightKey<L, R, Args...>>>
-Write(Writer& writer, const boost::bimap<L, R, Args...>& map) {
+requires(kIsWritable<impl::BoostBimapLeftKey<L, R, Args...>> && kIsWritable<impl::BoostBimapRightKey<L, R, Args...>>)
+void Write(Writer& writer, const boost::bimap<L, R, Args...>& map) {
     writer.Write(map.size());
 
     for (const auto& [left, right] : map) {
@@ -239,10 +251,8 @@ Write(Writer& writer, const boost::bimap<L, R, Args...>& map) {
 
 /// @brief `boost::bimap` deserialization support
 template <typename L, typename R, typename... Args>
-std::enable_if_t<
-    kIsReadable<impl::BoostBimapLeftKey<L, R, Args...>> && kIsReadable<impl::BoostBimapRightKey<L, R, Args...>>,
-    boost::bimap<L, R, Args...>>
-Read(Reader& reader, To<boost::bimap<L, R, Args...>>) {
+requires(kIsReadable<impl::BoostBimapLeftKey<L, R, Args...>> && kIsReadable<impl::BoostBimapRightKey<L, R, Args...>>)
+boost::bimap<L, R, Args...> Read(Reader& reader, To<boost::bimap<L, R, Args...>>) {
     using BoostBimap = impl::BoostBimap<L, R, Args...>;
 
     using BoostBimapLeftKey = impl::BoostBimapLeftKey<L, R, Args...>;
@@ -267,7 +277,8 @@ Read(Reader& reader, To<boost::bimap<L, R, Args...>>) {
 
 /// @brief `boost::multi_index_container` serialization support
 template <typename T, typename Index, typename Alloc>
-std::enable_if_t<kIsWritable<T>> Write(Writer& writer, const boost::multi_index_container<T, Index, Alloc>& container) {
+requires kIsWritable<T>
+void Write(Writer& writer, const boost::multi_index_container<T, Index, Alloc>& container) {
     writer.Write(container.template get<0>().size());
     for (auto& item : container.template get<0>()) {
         writer.Write(item);
@@ -276,8 +287,8 @@ std::enable_if_t<kIsWritable<T>> Write(Writer& writer, const boost::multi_index_
 
 /// @brief `boost::multi_index_container` deserialization support
 template <typename T, typename Index, typename Alloc>
-std::enable_if_t<kIsReadable<T>, boost::multi_index_container<T, Index, Alloc>>
-Read(Reader& reader, To<boost::multi_index_container<T, Index, Alloc>>) {
+requires kIsReadable<T>
+boost::multi_index_container<T, Index, Alloc> Read(Reader& reader, To<boost::multi_index_container<T, Index, Alloc>>) {
     const auto size = reader.Read<std::size_t>();
     boost::multi_index_container<T, Index, Alloc> container;
 

core/include/userver/dynamic_config/storage_mock.hpp

@@ -19,7 +19,7 @@ namespace dynamic_config {
 namespace impl {
 
 template <typename T>
-using IsJson = std::enable_if_t<std::is_same_v<T, formats::json::Value>>;
+concept IsJson = std::is_same_v<T, formats::json::Value>;
 
 }  // namespace impl
 

core/include/userver/server/handlers/exceptions.hpp

@@ -269,7 +269,8 @@ class CustomHandlerException : public std::runtime_error {
     {}
 
     /// @deprecated Use the variadic constructor above instead.
-    template <typename MessageBuilder, typename = std::enable_if_t<impl::kIsMessageBuilder<MessageBuilder>>>
+    template <typename MessageBuilder>
+    requires impl::kIsMessageBuilder<MessageBuilder>
     CustomHandlerException(MessageBuilder&& builder, HandlerErrorCode handler_code)
         : CustomHandlerException(impl::CustomHandlerExceptionData{std::forward<MessageBuilder>(builder), handler_code})
     {}