conversions.hxx File Reference

#include <array>
#include <concepts>
#include <cstring>
#include <map>
#include <memory>
#include <numeric>
#include <optional>
#include <span>
#include <type_traits>
#include <variant>
#include "pqxx/encoding_group.hxx"
#include "pqxx/strconv.hxx"

Include dependency graph for conversions.hxx:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	pqxx::internal::disallowed_ambiguous_char_conversion< CHAR_TYPE >
	Deliberately nonfunctional conversion traits for char types. More...
struct	pqxx::internal::float_string_traits< T >
	String traits for builtin floating-point types. More...
struct	pqxx::internal::integer_string_traits< T >
	String traits for builtin integer types. More...
struct	pqxx::nullness< T >
	The built-in arithmetic types do not have inherent null values. More...
struct	pqxx::string_traits< short >
struct	pqxx::string_traits< unsigned short >
struct	pqxx::string_traits< int >
struct	pqxx::string_traits< unsigned >
struct	pqxx::string_traits< long >
struct	pqxx::string_traits< unsigned long >
struct	pqxx::string_traits< long long >
struct	pqxx::string_traits< unsigned long long >
struct	pqxx::string_traits< float >
struct	pqxx::string_traits< double >
struct	pqxx::string_traits< long double >
struct	pqxx::string_traits< bool >
struct	pqxx::nullness< std::optional< T > >
struct	pqxx::string_traits< std::optional< T > >
struct	pqxx::nullness< std::variant< T... > >
struct	pqxx::string_traits< std::variant< T... > >
struct	pqxx::string_traits< std::nullptr_t >
struct	pqxx::string_traits< std::nullopt_t >
struct	pqxx::string_traits< std::monostate >
struct	pqxx::nullness< char const * >
struct	pqxx::string_traits< char const * >
	String traits for C-style string ("pointer to char const"). More...
struct	pqxx::nullness< char * >
struct	pqxx::string_traits< char * >
	String traits for non-const C-style string ("pointer to char"). More...
struct	pqxx::nullness< char[N]>
struct	pqxx::string_traits< char[N]>
	String traits for C-style string constant ("pointer to array of char"). More...
struct	pqxx::nullness< std::string >
struct	pqxx::string_traits< std::string >
struct	pqxx::nullness< std::string_view >
	There's no real null value for std::string_view. More...
struct	pqxx::string_traits< std::string_view >
	String traits for string_view. More...
struct	pqxx::nullness< zview >
struct	pqxx::string_traits< zview >
	String traits for zview. More...
struct	pqxx::nullness< std::stringstream >
struct	pqxx::string_traits< std::stringstream >
struct	pqxx::nullness< std::nullptr_t >
struct	pqxx::nullness< std::nullopt_t >
struct	pqxx::nullness< std::monostate >
struct	pqxx::nullness< std::unique_ptr< T > >
struct	pqxx::string_traits< std::unique_ptr< T, Args... > >
struct	pqxx::nullness< std::shared_ptr< T > >
struct	pqxx::string_traits< std::shared_ptr< T > >
struct	pqxx::nullness< DATA >
struct	pqxx::string_traits< DATA >
struct	pqxx::internal::nonbinary_range_traits< T >
	Base class for string_traits specialisations for nonbinary ranges. More...
struct	pqxx::string_traits< T >
	String traits for SQL arrays. More...

Namespaces
	pqxx
	The home of all libpqxx classes, functions, templates, etc.
	pqxx::internal
	Private namespace for libpqxx's internal use; do not access.

Macros
#define	PQXX_SPECIALIZE_INT_TRAIT(typ)

Functions
constexpr PQXX_PURE char	pqxx::internal::number_to_digit (int i) noexcept
	Convert a number in [0, 9] to its ASCII digit. More...
constexpr PQXX_PURE int	pqxx::internal::digit_to_number (char c) noexcept
	Compute numeric value of given textual digit (assuming that it is a digit). More...
std::string	pqxx::internal::state_buffer_overrun (int have_bytes, int need_bytes)
	Summarize buffer overrun. More...
template<typename HAVE , typename NEED >
PQXX_INLINE_COV std::string	pqxx::internal::state_buffer_overrun (HAVE have_bytes, NEED need_bytes)
void	pqxx::internal::throw_null_conversion (std::string const &type, sl)
	Throw exception for attempt to convert SQL NULL to given type. More...
void	pqxx::internal::throw_null_conversion (std::string_view type, sl)
	Throw exception for attempt to convert SQL NULL to given type. More...
template<std::floating_point T>
PQXX_LIBEXPORT std::string	pqxx::internal::to_string_float (T, ctx={})
template<typename T >
char *	pqxx::internal::generic_into_buf (char *begin, char *end, T const &value, ctx c={})
	Generic implementation for into_buf(), on top of to_buf(). More...
template<typename T >
std::size_t	pqxx::internal::generic_into_buf (std::span< char > buf, T const &value, ctx c={})
	Generic implementation for into_buf(), on top of to_buf(). More...
template<typename T >
constexpr format	pqxx::param_format (std::optional< T > const &value)
template<typename... Args>
constexpr format	pqxx::param_format (std::variant< Args... > const &value)
template<typename T >
T	pqxx::from_string (std::stringstream const &text, ctx c={})
template<typename T , typename... Args>
format	pqxx::param_format (std::unique_ptr< T, Args... > const &value)
template<typename T >
format	pqxx::param_format (std::shared_ptr< T > const &value)
template<nonbinary_range TYPE>
std::size_t	pqxx::internal::array_into_buf (std::span< char > buf, TYPE const &value, std::size_t budget, ctx c={})
	Write an SQL array representation into buf. More...
template<nonbinary_range T>
constexpr format	pqxx::param_format (T const &)
	We don't know how to pass array params in binary format, so pass as text. More...
template<typename TYPE >
PQXX_INLINE_COV std::string	pqxx::to_string (TYPE const &value, ctx c)
	Convert a value to a readable string that PostgreSQL will understand. More...
template<>
std::string	pqxx::to_string (float const &value, ctx c)
template<>
std::string	pqxx::to_string (double const &value, ctx c)
template<>
std::string	pqxx::to_string (long double const &value, ctx c)
template<>
std::string	pqxx::to_string (std::stringstream const &value, ctx)
template<typename T >
void	pqxx::into_string (T const &value, std::string &out, ctx c={})

Variables
template<pqxx::internal::integer T>
constexpr bool	pqxx::is_unquoted_safe< T > {true}
template<>
constexpr bool	pqxx::is_unquoted_safe< bool > {true}
template<nonbinary_range T>
constexpr bool	pqxx::is_sql_array< T > {true}

Macro Definition Documentation

PQXX_SPECIALIZE_INT_TRAIT

#define PQXX_SPECIALIZE_INT_TRAIT

(

typ

)

Value:

  template<>                                                                  \
  struct string_traits<typ> final                                             \
          : pqxx::internal::integer_string_traits<typ>                        \
  {}