string_literal.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/string_literal.hpp
/// @brief @copybrief utils::StringLiteral
/// @ingroup userver_universal
 
#include <concepts>
#include <string_view>
 
#include <fmt/core.h>
 
#include <userver/formats/serialize/to.hpp>
#include <userver/utils/zstring_view.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
/// @ingroup userver_containers
///
/// @brief Non-empty string view to a compile time known null terminated char array that lives for the lifetime of
/// program, as per [lex.string]; a drop-in replacement for `static const std::string kVar = "value"` and
/// `constexpr std::string_view kVar = "value"`.
class StringLiteral : public zstring_view {
public:
    StringLiteral() = delete;
 
#if defined(__clang__) && __clang_major__ < 18
    // clang-16 and below lose (optimize out) the pointer to `literal` with consteval. Clang-18 is know to work
    constexpr
#else
    consteval
#endif
        StringLiteral(const char* literal) noexcept
        : zstring_view{literal} {
        // data()[size()] == '\0' is guaranteed by std::string_view that calls std::strlen(literal)
    }
 
    void swap(zstring_view&) = delete;  // loses guarantee on lifetime because zstring_view may refer to non-literal
    void swap(StringLiteral& other) noexcept { zstring_view::swap(other); }
 
    /// Constructs a StringLiteral from a pointer and size.
    /// @warning `str[len]` should be '\0' and `str` should point to compile time literal.
    static constexpr StringLiteral UnsafeMake(const char* str, std::size_t len) noexcept {
        return StringLiteral(str, len);
    }
 
    friend constexpr auto operator<=>(StringLiteral lhs, StringLiteral rhs) noexcept = default;
 
    friend constexpr auto operator<=>(StringLiteral lhs, const std::convertible_to<std::string_view> auto& rhs)
        noexcept {
        return std::string_view{lhs} <=> std::string_view{rhs};
    }
 
    friend constexpr bool operator==(StringLiteral lhs, const std::convertible_to<std::string_view> auto& rhs)
        noexcept {
        return std::string_view{lhs} == std::string_view{rhs};
    }
 
private:
    constexpr explicit StringLiteral(const char* str, std::size_t len) noexcept
        : zstring_view{zstring_view::UnsafeMake(str, len)} {}
};
 
template <class Value>
Value Serialize(StringLiteral literal, formats::serialize::To<Value>) {
    return typename Value::Builder(std::string_view{literal}).ExtractValue();
}
 
template <typename StringBuilder>
void WriteToStream(StringLiteral literal, StringBuilder& sw) {
    WriteToStream(std::string_view{literal}, sw);
}
 
}  // namespace utils
 
USERVER_NAMESPACE_END
 
template <>
struct fmt::formatter<USERVER_NAMESPACE::utils::StringLiteral, char> : fmt::formatter<std::string_view> {
    template <typename FormatContext>
    constexpr auto format(USERVER_NAMESPACE::utils::StringLiteral value, FormatContext& ctx) const {
        return fmt::formatter<std::string_view>::format(std::string_view{value}, ctx);
    }
};