zstring_view.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/zstring_view.hpp
/// @brief @copybrief utils::zstring_view
/// @ingroup userver_universal
 
#include <concepts>
#include <string>
#include <string_view>
 
#include <fmt/format.h>
 
#include <userver/formats/serialize/to.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
// Forward declaration
[[noreturn]] void AbortWithStacktrace(std::string_view message) noexcept;
 
/// @ingroup userver_containers
///
/// @brief Non-empty string view type that guarantees null-termination and has a `c_str()` member function.
class zstring_view : public std::string_view {  // NOLINT(readability-identifier-naming)
public:
    zstring_view() = delete;
    zstring_view(const zstring_view& str) = default;
 
    constexpr zstring_view(const char* str) noexcept : std::string_view{str} {
        // data()[size()] == '\0' is guaranteed by std::string_view that calls std::strlen(str)
    }
 
    zstring_view(const std::string& str) noexcept : std::string_view{str} {}
 
    zstring_view& operator=(std::string_view) = delete;
    zstring_view& operator=(const zstring_view&) = default;
 
    void remove_suffix(std::size_t) = delete;  // zstring_view becomes not null-terminated after that function call
    void swap(std::string_view&) = delete;     // zstring_view may become not null-terminated after that function call
    void swap(zstring_view& other) noexcept { std::string_view::swap(other); }
 
    constexpr const char* c_str() const noexcept { return std::string_view::data(); }
 
    /// Constructs a zstring_view from a pointer and size.
    /// @warning `str[len]` should be '\0'.
    static constexpr zstring_view UnsafeMake(const char* str, std::size_t len) noexcept {
        return zstring_view{str, len};
    }
 
    friend constexpr auto operator<=>(zstring_view lhs, zstring_view rhs) noexcept = default;
 
    friend constexpr auto operator<=>(zstring_view lhs, const std::convertible_to<std::string_view> auto& rhs)
        noexcept {
        return std::string_view{lhs} <=> std::string_view{rhs};
    }
 
    friend constexpr bool operator==(zstring_view lhs, const std::convertible_to<std::string_view> auto& rhs) noexcept {
        return std::string_view{lhs} == std::string_view{rhs};
    }
 
private:
    constexpr zstring_view(const char* str, std::size_t len) noexcept : std::string_view{str, len} {
#ifndef NDEBUG
        if (!str || str[len] != 0) {
            USERVER_NAMESPACE::utils::AbortWithStacktrace("`str` should be not null and should be null terminated");
        }
#endif
    }
};
 
template <class Value>
Value Serialize(zstring_view view, formats::serialize::To<Value>) {
    return typename Value::Builder(std::string_view{view}).ExtractValue();
}
 
template <typename StringBuilder>
void WriteToStream(zstring_view view, StringBuilder& sw) {
    WriteToStream(std::string_view{view}, sw);
}
 
}  // namespace utils
 
USERVER_NAMESPACE_END
 
template <>
struct fmt::formatter<USERVER_NAMESPACE::utils::zstring_view, char> : fmt::formatter<std::string_view> {};
 
namespace fmt {
 
// Allow fmt::runtime() to work with utils::zstring_view
template <class... NotUsed>
inline auto runtime(USERVER_NAMESPACE::utils::zstring_view s, NotUsed...)  // NOLINT(readability-identifier-naming)
    -> decltype(fmt::runtime(std::string_view{s})) {
    static_assert(sizeof...(NotUsed) == 0);
    return fmt::runtime(std::string_view{s});
}
 
}  // namespace fmt