zview.hxx

Go to the documentation of this file.

/* Zero-terminated string view.
 *
 * DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/zview instead.
 *
 * Copyright (c) 2000-2026, Jeroen T. Vermeulen.
 *
 * See COPYING for copyright license.  If you did not receive a file called
 * COPYING with this source code, please notify the distributor of this
 * mistake, or contact the author.
 */
#ifndef PQXX_ZVIEW_HXX
#define PQXX_ZVIEW_HXX
 
#include <cassert>
#include <string>
#include <string_view>
#include <type_traits>
 
#include "pqxx/types.hxx"
 
 
namespace pqxx
{
class zview;
 
 
 
template<typename T>
concept ZString =
  (std::is_convertible_v<std::remove_cvref_t<T>, char const *> or
   std::is_convertible_v<std::remove_cvref_t<T>, zview> or
   std::is_convertible_v<T, std::string const &>) and
  not std::is_convertible_v<T, std::nullptr_t>;
 
 
 
class PQXX_LIBEXPORT zview final : public std::string_view
{
public:
  constexpr zview() noexcept : zview{""} {}
 
 
  PQXX_ZARGS constexpr zview(char const text[], std::ptrdiff_t len) noexcept(
    noexcept(std::string_view{text, static_cast<std::size_t>(len)})) :
          std::string_view{text, static_cast<std::size_t>(len)}
  {
    invariant();
  }
 
  constexpr zview(char text[], std::ptrdiff_t len) noexcept(
    noexcept(std::string_view{text, static_cast<std::size_t>(len)})) :
          std::string_view{text, static_cast<std::size_t>(len)}
  {
    invariant();
  }
 
 
  explicit constexpr zview(std::string_view other) noexcept :
          std::string_view{other}
  {
    invariant();
  }
 
  // clang-tidy rule bug:
  // NOLINTBEGIN(
  //    cppcoreguidelines-pro-bounds-array-to-pointer-decay,
  //    hicpp-no-array-decay
  // )
 
 
  template<typename... Args>
  explicit constexpr zview(Args &&...args) :
          std::string_view(std::forward<Args>(args)...)
  {
    invariant();
  }
 
  // NOLINTEND(
  //    cppcoreguidelines-pro-bounds-array-to-pointer-decay,
  //    hicpp-no-array-decay
  // )
 
  // NOLINTBEGIN(google-explicit-constructor,hicpp-explicit-conversions)
 
  constexpr zview(std::string const &str) noexcept :
          std::string_view{str.c_str(), str.size()}
  {
    invariant();
  }
 
 
  PQXX_ZARGS constexpr zview(char const str[]) noexcept(
    noexcept(std::string_view{str})) :
          std::string_view{str}
  {
    invariant();
  }
 
  zview(std::nullptr_t) = delete;
 
 
  template<size_t size>
  PQXX_ZARGS constexpr zview(char const (&literal)[size]) :
          zview(literal, size - 1)
  {}
 
  // NOLINTEND(google-explicit-constructor,hicpp-explicit-conversions)
 
  [[nodiscard]] constexpr char const *c_str() const & noexcept
  {
    return data();
  }
 
  // NOLINTBEGIN(google-explicit-constructor,hicpp-explicit-conversions)
  constexpr operator char const *() const noexcept { return data(); }
  // NOLINTEND(google-explicit-constructor,hicpp-explicit-conversions)
 
  constexpr bool operator==(zview const &rhs) const noexcept
  {
    return std::string_view{*this} == std::string_view{rhs};
  }
  constexpr bool operator!=(zview const &rhs) const noexcept
  {
    return std::string_view{*this} != std::string_view{rhs};
  }
 
private:
  [[maybe_unused]] constexpr void invariant() const noexcept
  {
    assert(std::data(*this) != nullptr);
    assert(std::data(*this)[std::size(*this)] == '\0');
  }
};
 
 
template<> inline constexpr std::string_view name_type<zview>() noexcept
{
  return "pqxx::zview";
}
 
 
 
PQXX_ZARGS constexpr zview
operator""_zv(char const str[], std::size_t len) noexcept
{
  return zview{str, len};
}
 
 
constexpr inline bool operator==(char const lhs[], pqxx::zview rhs) noexcept
{
  return std::string_view{lhs} == std::string_view{rhs};
}
 
 
constexpr inline bool operator!=(char const lhs[], pqxx::zview rhs) noexcept
{
  return std::string_view{lhs} != std::string_view{rhs};
}
} // namespace pqxx
 
 
template<> inline constexpr bool std::ranges::enable_view<pqxx::zview>{true};
 
 
template<>
inline constexpr bool std::ranges::enable_borrowed_range<pqxx::zview>{true};
#endif