types.hxx

Go to the documentation of this file.

/* Basic type aliases and forward declarations.
 *
 * 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_TYPES_HXX
#define PQXX_TYPES_HXX
 
#if !defined(PQXX_HEADER_PRE)
#  error "Include libpqxx headers as <pqxx/header>, not <pqxx/header.hxx>."
#endif
 
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <ranges>
#include <source_location>
#include <string>
#include <string_view>
#include <type_traits>
#include <typeinfo>
 
#if defined(PQXX_HAVE_STACKTRACE)
#  include <stacktrace>
#endif
 
#if defined(PQXX_HAVE_TYPE_DISPLAY)
#  include <meta>
#endif
 
 
namespace pqxx
{
using sl = std::source_location;
 
#if defined(PQXX_HAVE_STACKTRACE)
using st = std::stacktrace;
#else
struct stacktrace_placeholder final
{
  constexpr stacktrace_placeholder() noexcept = default;
  constexpr stacktrace_placeholder(stacktrace_placeholder const &) noexcept =
    default;
 
  constexpr stacktrace_placeholder(stacktrace_placeholder &&) noexcept {}
  ~stacktrace_placeholder() noexcept = default;
 
  stacktrace_placeholder &
  operator=(stacktrace_placeholder const &) noexcept = default;
  stacktrace_placeholder &
  operator=(stacktrace_placeholder &&) noexcept = default;
 
  [[nodiscard]] PQXX_PURE static constexpr stacktrace_placeholder
  current() noexcept
  {
    return {};
  }
};
using st = stacktrace_placeholder;
#endif
 
 
using oid = unsigned int;
 
 
using result_size_type = int;
 
using result_difference_type = int;
 
using row_size_type = int;
 
using row_difference_type = int;
 
using field_size_type = std::size_t;
 
using large_object_size_type = int64_t;
 
 
// Forward declarations, to help break compilation dependencies.
// These won't necessarily include all classes in libpqxx.
class connection;
class const_result_iterator;
class const_reverse_result_iterator;
class const_reverse_row_iterator;
class const_row_iterator;
class dbtransaction;
// 9.0: Remove this.
class errorhandler;
class field;
class largeobjectaccess;
class notification_receiver;
struct range_error;
class result;
class row;
class stream_from;
class transaction_base;
 
 
enum class format : int
{
  text = 0,
  binary = 1,
};
 
 
 
template<typename TYPE> using strip_t = std::remove_cvref_t<TYPE>;
 
 
 
template<std::ranges::range CONTAINER>
using value_type = std::remove_cvref_t<std::ranges::range_value_t<CONTAINER>>;
 
 
template<typename CHAR>
concept char_sized = (sizeof(CHAR) == 1);
 
 
template<typename STRING>
concept char_string = std::ranges::contiguous_range<STRING> and
                      std::same_as<std::remove_cv_t<value_type<STRING>>, char>;
 
 
template<typename RANGE>
concept char_strings = std::ranges::range<RANGE> and
                       char_string<std::remove_cv_t<value_type<RANGE>>>;
 
 
template<typename DATA>
concept potential_binary =
  std::ranges::contiguous_range<DATA> and char_sized<value_type<DATA>> and
  not std::is_reference_v<value_type<DATA>>;
 
 
 
template<typename T>
concept binary = std::ranges::contiguous_range<T> and
                 std::same_as<std::remove_cv_t<value_type<T>>, std::byte>;
 
 
template<typename T>
concept nonbinary_range =
  std::ranges::range<T> and
  not std::same_as<
    std::remove_cvref_t<std::ranges::range_reference_t<T>>, std::byte> and
  not std::same_as<
    std::remove_cvref_t<std::ranges::range_reference_t<T>>, char>;
 
 
using bytes_view = std::span<std::byte const>;
 
 
using writable_bytes_view = std::span<std::byte>;
 
 
 
template<typename T>
concept not_borrowed =
  not std::is_reference_v<T> and not std::is_pointer_v<T> and
  not std::ranges::borrowed_range<T>;
 
 
template<typename E>
concept enum_type = std::is_enum_v<E>;
 
 
 
struct from_table_t final
{};
 
 
struct from_query_t final
{};
} // namespace pqxx
 
 
namespace pqxx::internal
{
#if !defined(PQXX_HAVE_TYPE_DISPLAY)
 
PQXX_LIBEXPORT PQXX_ZARGS std::string
demangle_type_name(char const[]) noexcept;
#endif
} // namespace pqxx::internal
 
 
namespace pqxx
{
#include "pqxx/internal/ignore-deprecated-pre.hxx"
#if defined(PQXX_HAVE_TYPE_DISPLAY)
template<typename TYPE>
[[deprecated("Use name_type() instead.")]]
std::string const type_name{display_string_of(^^TYPE)};
 
#else
 
 
template<typename TYPE>
[[deprecated("Use name_type() instead.")]]
std::string const type_name{
  pqxx::internal::demangle_type_name(typeid(TYPE).name())};
 
#endif
#include "pqxx/internal/ignore-deprecated-post.hxx"
 
template<typename TYPE> inline constexpr std::string_view name_type() noexcept
{
#if defined(PQXX_HAVE_TYPE_DISPLAY)
 
  return display_string_of(^^TYPE);
 
#else
 
#  include "pqxx/internal/ignore-deprecated-pre.hxx"
  return type_name<TYPE>;
#  include "pqxx/internal/ignore-deprecated-post.hxx"
 
#endif
}
 
 
// Specialisations of name_type<>() follow.  Some are tested, but because they
// are so trivial, the coverage tools never notice that they get tested.
// There's just no point running coverage for these.
// LCOV_EXCL_START
 
template<>
PQXX_PURE constexpr inline std::string_view name_type<std::string>() noexcept
{
  return "std::string";
}
template<>
PQXX_PURE constexpr inline std::string_view
name_type<std::string_view>() noexcept
{
  return "std::string_view";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<char const *>() noexcept
{
  return "char const *";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<bool>() noexcept
{
  return "bool";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<short>() noexcept
{
  return "short";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<int>() noexcept
{
  return "int";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<long>() noexcept
{
  return "long";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<long long>() noexcept
{
  return "long long";
}
template<>
PQXX_PURE constexpr inline std::string_view
name_type<unsigned short>() noexcept
{
  return "unsigned short";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<unsigned>() noexcept
{
  return "unsigned";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<unsigned long>() noexcept
{
  return "unsigned long";
}
template<>
PQXX_PURE constexpr inline std::string_view
name_type<unsigned long long>() noexcept
{
  return "unsigned long long";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<float>() noexcept
{
  return "float";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<double>() noexcept
{
  return "double";
}
template<>
PQXX_PURE constexpr inline std::string_view name_type<long double>() noexcept
{
  return "long double";
}
template<>
PQXX_PURE constexpr inline std::string_view
name_type<std::nullptr_t>() noexcept
{
  return "std::nullptr_t";
}
 
// LCOV_EXCL_STOP
} // namespace pqxx
 
 
namespace pqxx::internal
{
template<typename T>
concept char_type = std::same_as<std::remove_cv_t<T>, char> or
                    std::same_as<std::remove_cv_t<T>, signed char> or
                    std::same_as<std::remove_cv_t<T>, unsigned char>;
 
 
 
template<typename T>
concept integer = std::integral<T> and not char_type<T>;
} // namespace pqxx::internal
 
 
 
namespace pqxx::internal::pq
{
using PGconn = void;
using PGresult = void;
using PGnotify = void;
using PQnoticeProcessor = void (*)(void *, char const *);
using PQconninfoOption = void;
} // namespace pqxx::internal::pq
#endif