14 #if !defined(PQXX_HEADER_PRE) 15 # error "Include libpqxx headers as <pqxx/header>, not <pqxx/header.hxx>." 26 #include <string_view> 27 #include <type_traits> 32 #if __has_include(<version>) 36 #include "pqxx/except.hxx" 37 #include "pqxx/internal/encodings.hxx" 38 #include "pqxx/types.hxx" 39 #include "pqxx/version.hxx" 46 #include <pqxx/internal/libpq-forward.hxx> 56 template<
typename LEFT,
typename RIGHT>
57 inline constexpr
bool cmp_less(LEFT lhs, RIGHT rhs) noexcept
59 #if defined(PQXX_HAVE_CMP) 60 return std::cmp_less(lhs, rhs);
65 constexpr
bool left_signed{std::is_signed_v<LEFT>};
66 if constexpr (left_signed == std::is_signed_v<RIGHT>)
68 else if constexpr (std::is_signed_v<LEFT>)
69 return (lhs <= 0) ? true : (std::make_unsigned_t<LEFT>(lhs) < rhs);
71 return (rhs <= 0) ? false : (lhs < std::make_unsigned_t<RIGHT>(rhs));
78 template<
typename LEFT,
typename RIGHT>
79 inline constexpr
bool cmp_greater(LEFT lhs, RIGHT rhs) noexcept
81 #if defined(PQXX_HAVE_CMP) 82 return std::cmp_greater(lhs, rhs);
91 template<
typename LEFT,
typename RIGHT>
94 #if defined(PQXX_HAVE_CMP) 95 return std::cmp_less_equal(lhs, rhs);
104 template<
typename LEFT,
typename RIGHT>
107 #if defined(PQXX_HAVE_CMP) 108 return std::cmp_greater_equal(lhs, rhs);
119 [[nodiscard]]
inline std::string
cat2(std::string_view x, std::string_view y)
122 auto const xs{std::size(x)}, ys{std::size(y)};
124 x.copy(std::data(buf), xs);
125 y.copy(std::data(buf) + xs, ys);
136 template<
typename... T>
inline constexpr
void ignore_unused(T &&...) noexcept
144 template<
typename TO,
typename FROM>
145 inline TO
check_cast(FROM value, std::string_view description)
147 static_assert(std::is_arithmetic_v<FROM>);
148 static_assert(std::is_arithmetic_v<TO>);
149 static_assert(std::is_integral_v<FROM> == std::is_integral_v<TO>);
153 if constexpr (std::is_same_v<FROM, bool>)
154 return static_cast<TO
>(value);
160 using from_limits = std::numeric_limits<decltype(value)>;
161 using to_limits = std::numeric_limits<TO>;
162 if constexpr (std::is_signed_v<FROM>)
164 if constexpr (std::is_signed_v<TO>)
166 if (value < to_limits::lowest())
176 "Casting negative value to unsigned type: "sv, description)};
185 if constexpr (std::is_integral_v<FROM>)
187 using unsigned_from = std::make_unsigned_t<FROM>;
188 using unsigned_to = std::make_unsigned_t<TO>;
189 constexpr
auto from_max{
static_cast<unsigned_from
>((from_limits::max)())};
190 constexpr
auto to_max{
static_cast<unsigned_to
>((to_limits::max)())};
191 if constexpr (from_max > to_max)
197 else if constexpr ((from_limits::max)() > (to_limits::max)())
199 if (value > (to_limits::max)())
203 return static_cast<TO
>(value);
251 bool safe_libpq =
false;
260 bool safe_kerberos =
false;
271 #if defined(PQXX_HAVE_CONCEPTS) 272 # define PQXX_POTENTIAL_BINARY_ARG pqxx::potential_binary 274 # define PQXX_POTENTIAL_BINARY_ARG typename 296 template<PQXX_POTENTIAL_BINARY_ARG TYPE>
301 reinterpret_cast<std::byte
const *
>(
308 #if defined(PQXX_HAVE_CONCEPTS) 309 template<
typename CHAR>
310 concept char_sized = (
sizeof(CHAR) == 1);
311 # define PQXX_CHAR_SIZED_ARG char_sized 313 # define PQXX_CHAR_SIZED_ARG typename 324 template<PQXX_CHAR_SIZED_ARG CHAR,
typename SIZE>
325 std::basic_string_view<std::byte>
binary_cast(CHAR
const *data, SIZE size)
327 static_assert(
sizeof(CHAR) == 1);
329 reinterpret_cast<std::byte
const *
>(data),
330 check_cast<std::size_t>(size,
"binary data size")};
359 template<
typename CHAR>
inline constexpr
bool is_digit(CHAR c) noexcept
361 return (c >=
'0') and (c <=
'9');
368 [[nodiscard]] std::string
385 void const *old_guest, std::string_view old_class, std::string_view old_name,
386 void const *new_guest, std::string_view new_class,
387 std::string_view new_name);
395 void const *old_guest, std::string_view old_class, std::string_view old_name,
396 void const *new_guest, std::string_view new_class,
397 std::string_view new_name);
404 inline constexpr std::size_t
size_esc_bin(std::size_t binary_bytes) noexcept
406 return 2 + (2 * binary_bytes) + 1;
415 return (escaped_bytes - 2) / 2;
427 esc_bin(std::basic_string_view<std::byte> binary_data,
char buffer[]) noexcept;
431 std::string PQXX_LIBEXPORT
432 esc_bin(std::basic_string_view<std::byte> binary_data);
437 unesc_bin(std::string_view escaped_data, std::byte buffer[]);
441 std::basic_string<std::byte>
442 PQXX_LIBEXPORT
unesc_bin(std::string_view escaped_data);
446 template<
typename T>
auto ssize(T
const &c)
448 #if defined(__cpp_lib_ssize) && __cplusplus >= __cpp_lib_ssize 449 return std::ssize(c);
451 using signed_t = std::make_signed_t<decltype(std::size(c))>;
452 return static_cast<signed_t
>(std::size(c));
453 #endif // __cpp_lib_ssize Something is out of range, similar to std::out_of_range.
Definition: except.hxx:201
std::string describe_object(std::string_view class_name, std::string_view name)
Describe an object for humans, based on class name and optional name.
Definition: util.cxx:51
Descriptor of library's thread-safety model.
Definition: util.hxx:248
constexpr std::size_t size_esc_bin(std::size_t binary_bytes) noexcept
Compute buffer size needed to escape binary data for use as a BYTEA.
Definition: util.hxx:404
The home of all libpqxx classes, functions, templates, etc.
Definition: array.hxx:26
auto ssize(T const &c)
Transitional: std::ssize(), or custom implementation if not available.
Definition: util.hxx:446
constexpr bool is_digit(CHAR c) noexcept
A safer and more generic replacement for std::isdigit.
Definition: util.hxx:359
constexpr bool cmp_greater(LEFT lhs, RIGHT rhs) noexcept
C++20 std::cmp_greater, or workaround if not available.
Definition: util.hxx:79
void check_unique_register(void const *old_guest, std::string_view old_class, std::string_view old_name, void const *new_guest, std::string_view new_class, std::string_view new_name)
Check validity of registering a new "guest" in a "host.".
Definition: util.cxx:61
std::string description
A human-readable description of any thread-safety issues.
Definition: util.hxx:263
void check_version() noexcept
Definition: util.hxx:228
void esc_bin(std::basic_string_view< std::byte > binary_data, char buffer[]) noexcept
Hex-escape binary data into a buffer.
Definition: util.cxx:126
constexpr bool cmp_less_equal(LEFT lhs, RIGHT rhs) noexcept
C++20 std::cmp_less_equal, or workaround if not available.
Definition: util.hxx:92
constexpr oid oid_none
The "null" oid.
Definition: util.hxx:335
void check_unique_unregister(void const *old_guest, std::string_view old_class, std::string_view old_name, void const *new_guest, std::string_view new_class, std::string_view new_name)
Like check_unique_register, but for un-registering a guest.
Definition: util.cxx:78
decltype(*std::begin(std::declval< CONTAINER >())) value_type
The type of a container's elements.
Definition: types.hxx:107
int PQXX_VERSION_CHECK() noexcept
Library version check stub.
Definition: version.cxx:23
constexpr void ignore_unused(T &&...) noexcept
Suppress compiler warning about an unused item.
Definition: util.hxx:136
std::remove_cv_t< std::remove_reference_t< TYPE > > strip_t
Remove any constness, volatile, and reference-ness from a type.
Definition: types.hxx:91
Internal items for libpqxx' own use. Do not use these yourself.
Definition: composite.hxx:82
thread_safety_model describe_thread_safety()
Describe thread safety available in this build.
Definition: util.cxx:33
TO check_cast(FROM value, std::string_view description)
Cast a numeric value to another type, or throw if it underflows/overflows.
Definition: util.hxx:145
constexpr std::size_t size_unesc_bin(std::size_t escaped_bytes) noexcept
Compute binary size from the size of its escaped version.
Definition: util.hxx:413
constexpr bool cmp_greater_equal(LEFT lhs, RIGHT rhs) noexcept
C++20 std::cmp_greater_equal, or workaround if not available.
Definition: util.hxx:105
std::string cat2(std::string_view x, std::string_view y)
Efficiently concatenate two strings.
Definition: util.hxx:119
constexpr bool cmp_less(LEFT lhs, RIGHT rhs) noexcept
Same as std::cmp_less, or a workaround where that's not available.
Definition: util.hxx:57
void unesc_bin(std::string_view escaped_data, std::byte buffer[])
Reconstitute binary data from its escaped version.
Definition: util.cxx:158
std::basic_string_view< std::byte > binary_cast(TYPE const &data)
Cast binary data to a type that libpqxx will recognise as binary.
Definition: util.hxx:297