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> 55 template<
typename LEFT,
typename RIGHT>
56 inline constexpr
bool cmp_less(LEFT lhs, RIGHT rhs) noexcept
58 #if defined(PQXX_HAVE_CMP) 59 return std::cmp_less(lhs, rhs);
64 constexpr
bool left_signed{std::is_signed_v<LEFT>};
65 if constexpr (left_signed == std::is_signed_v<RIGHT>)
67 else if constexpr (std::is_signed_v<LEFT>)
68 return (lhs <= 0) ? true : (std::make_unsigned_t<LEFT>(lhs) < rhs);
70 return (rhs <= 0) ? false : (lhs < std::make_unsigned_t<RIGHT>(rhs));
77 template<
typename LEFT,
typename RIGHT>
78 inline constexpr
bool cmp_greater(LEFT lhs, RIGHT rhs) noexcept
80 #if defined(PQXX_HAVE_CMP) 81 return std::cmp_greater(lhs, rhs);
90 template<
typename LEFT,
typename RIGHT>
93 #if defined(PQXX_HAVE_CMP) 94 return std::cmp_less_equal(lhs, rhs);
103 template<
typename LEFT,
typename RIGHT>
106 #if defined(PQXX_HAVE_CMP) 107 return std::cmp_greater_equal(lhs, rhs);
118 [[nodiscard]]
inline std::string
cat2(std::string_view x, std::string_view y)
121 auto const xs{std::size(x)}, ys{std::size(y)};
123 x.copy(std::data(buf), xs);
124 y.copy(std::data(buf) + xs, ys);
135 template<
typename... T>
inline constexpr
void ignore_unused(T &&...) noexcept
143 template<
typename TO,
typename FROM>
144 inline TO
check_cast(FROM value, std::string_view description)
146 static_assert(std::is_arithmetic_v<FROM>);
147 static_assert(std::is_arithmetic_v<TO>);
148 static_assert(std::is_integral_v<FROM> == std::is_integral_v<TO>);
152 if constexpr (std::is_same_v<FROM, bool>)
153 return static_cast<TO
>(value);
159 using from_limits = std::numeric_limits<decltype(value)>;
160 using to_limits = std::numeric_limits<TO>;
161 if constexpr (std::is_signed_v<FROM>)
163 if constexpr (std::is_signed_v<TO>)
165 if (value < to_limits::lowest())
175 "Casting negative value to unsigned type: "sv, description)};
184 if constexpr (std::is_integral_v<FROM>)
186 using unsigned_from = std::make_unsigned_t<FROM>;
187 using unsigned_to = std::make_unsigned_t<TO>;
188 constexpr
auto from_max{
static_cast<unsigned_from
>((from_limits::max)())};
189 constexpr
auto to_max{
static_cast<unsigned_to
>((to_limits::max)())};
190 if constexpr (from_max > to_max)
196 else if constexpr ((from_limits::max)() > (to_limits::max)())
198 if (value > (to_limits::max)())
202 return static_cast<TO
>(value);
250 bool safe_libpq =
false;
259 bool safe_kerberos =
false;
270 #if defined(PQXX_HAVE_CONCEPTS) 271 # define PQXX_POTENTIAL_BINARY_ARG pqxx::potential_binary 273 # define PQXX_POTENTIAL_BINARY_ARG typename 295 template<PQXX_POTENTIAL_BINARY_ARG TYPE>
300 reinterpret_cast<std::byte
const *
>(
307 #if defined(PQXX_HAVE_CONCEPTS) 308 template<
typename CHAR>
309 concept char_sized = (
sizeof(CHAR) == 1);
310 # define PQXX_CHAR_SIZED_ARG char_sized 312 # define PQXX_CHAR_SIZED_ARG typename 323 template<PQXX_CHAR_SIZED_ARG CHAR,
typename SIZE>
324 std::basic_string_view<std::byte>
binary_cast(CHAR
const *data, SIZE size)
326 static_assert(
sizeof(CHAR) == 1);
328 reinterpret_cast<std::byte
const *
>(data),
329 check_cast<std::size_t>(size,
"binary data size")};
358 template<
typename CHAR>
inline constexpr
bool is_digit(CHAR c) noexcept
360 return (c >=
'0') and (c <=
'9');
367 [[nodiscard]] std::string
384 void const *old_guest, std::string_view old_class, std::string_view old_name,
385 void const *new_guest, std::string_view new_class,
386 std::string_view new_name);
394 void const *old_guest, std::string_view old_class, std::string_view old_name,
395 void const *new_guest, std::string_view new_class,
396 std::string_view new_name);
403 inline constexpr std::size_t
size_esc_bin(std::size_t binary_bytes) noexcept
405 return 2 + (2 * binary_bytes) + 1;
414 return (escaped_bytes - 2) / 2;
426 esc_bin(std::basic_string_view<std::byte> binary_data,
char buffer[]) noexcept;
430 std::string PQXX_LIBEXPORT
431 esc_bin(std::basic_string_view<std::byte> binary_data);
436 unesc_bin(std::string_view escaped_data, std::byte buffer[]);
440 std::basic_string<std::byte>
441 PQXX_LIBEXPORT
unesc_bin(std::string_view escaped_data);
445 template<
typename T>
auto ssize(T
const &c)
447 #if defined(__cpp_lib_ssize) && __cplusplus >= __cpp_lib_ssize 448 return std::ssize(c);
450 using signed_t = std::make_signed_t<decltype(std::size(c))>;
451 return static_cast<signed_t
>(std::size(c));
452 #endif // __cpp_lib_ssize 461 template<
typename RETURN,
typename... ARGS>
462 std::tuple<ARGS...>
args_f(RETURN (&func)(ARGS...));
470 template<
typename RETURN,
typename... ARGS>
471 std::tuple<ARGS...>
args_f(std::function<RETURN(ARGS...)>
const &);
479 template<
typename CLASS,
typename RETURN,
typename... ARGS>
480 std::tuple<ARGS...>
member_args_f(RETURN (CLASS::*)(ARGS...));
488 template<
typename CLASS,
typename RETURN,
typename... ARGS>
489 std::tuple<ARGS...>
member_args_f(RETURN (CLASS::*)(ARGS...)
const);
499 template<
typename CALLABLE>
500 auto args_f(CALLABLE
const &f)
505 template<
typename CALLABLE>
513 template<
typename... TYPES>
514 std::tuple<strip_t<TYPES>...>
strip_types(std::tuple<TYPES...>
const &);
518 template<
typename... TYPES>
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:247
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:403
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:445
constexpr bool is_digit(CHAR c) noexcept
A safer and more generic replacement for std::isdigit.
Definition: util.hxx:358
constexpr bool cmp_greater(LEFT lhs, RIGHT rhs) noexcept
C++20 std::cmp_greater, or workaround if not available.
Definition: util.hxx:78
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::tuple< ARGS... > member_args_f(RETURN(CLASS::*)(ARGS...))
Helper for determining a member function's parameter types.
std::string description
A human-readable description of any thread-safety issues.
Definition: util.hxx:262
void check_version() noexcept
Definition: util.hxx:227
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:91
constexpr oid oid_none
The "null" oid.
Definition: util.hxx:334
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
std::tuple< strip_t< TYPES >... > strip_types(std::tuple< TYPES... > const &)
Helper: Apply strip_t to each of a tuple type's component types.
decltype(args_f(std::declval< CALLABLE >())) args_t
A callable's parameter types, as a tuple.
Definition: util.hxx:506
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:135
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
decltype(strip_types(std::declval< TYPES... >())) strip_types_t
Take a tuple type and apply strip_t to its component types.
Definition: util.hxx:519
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:144
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:412
constexpr bool cmp_greater_equal(LEFT lhs, RIGHT rhs) noexcept
C++20 std::cmp_greater_equal, or workaround if not available.
Definition: util.hxx:104
std::string cat2(std::string_view x, std::string_view y)
Efficiently concatenate two strings.
Definition: util.hxx:118
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:56
strip_t< decltype(*std::begin(std::declval< CONTAINER >()))> value_type
The type of a container's elements.
Definition: types.hxx:107
void unesc_bin(std::string_view escaped_data, std::byte buffer[])
Reconstitute binary data from its escaped version.
Definition: util.cxx:158
std::tuple< ARGS... > args_f(RETURN(&func)(ARGS...))
Helper for determining a function's parameter types.
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:296