strconv.hxx

/* String conversion definitions.
 *
 * DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/stringconv instead.
 *
 * Copyright (c) 2000-2022, 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_H_STRCONV
#define PQXX_H_STRCONV

#if !defined(PQXX_HEADER_PRE)
#  error "Include libpqxx headers as <pqxx/header>, not <pqxx/header.hxx>."
#endif

#include <algorithm>
#include <cstring>
#include <limits>
#include <sstream>
#include <stdexcept>
#include <typeinfo>

#if __has_include(<charconv>)
#  include <charconv>
#endif

#if defined(PQXX_HAVE_RANGES) && __has_include(<ranges>)
#  include <ranges>
#endif

#include "pqxx/except.hxx"
#include "pqxx/util.hxx"
#include "pqxx/zview.hxx"


namespace pqxx::internal
{
PQXX_LIBEXPORT std::string demangle_type_name(char const[]);
} // namespace pqxx::internal


namespace pqxx
{


template<typename TYPE>
std::string const type_name{internal::demangle_type_name(typeid(TYPE).name())};



template<typename TYPE, typename ENABLE = void> struct nullness
{
  static bool has_null;

  static bool always_null;

  static bool is_null(TYPE const &value);


  [[nodiscard]] static TYPE null();
};


template<typename TYPE> struct no_null
{

  static constexpr bool has_null = false;


  static constexpr bool always_null = false;


  [[nodiscard]] static constexpr bool is_null(TYPE const &) noexcept
  {
    return false;
  }
};



template<typename TYPE> struct string_traits
{

  [[nodiscard]] static inline zview
  to_buf(char *begin, char *end, TYPE const &value);


  static inline char *into_buf(char *begin, char *end, TYPE const &value);


  [[nodiscard]] static inline TYPE from_string(std::string_view text);

  // C++20: Can we make these all constexpr?

  [[nodiscard]] static inline std::size_t
  size_buffer(TYPE const &value) noexcept;
};


template<typename ENUM>
struct nullness<ENUM, std::enable_if_t<std::is_enum_v<ENUM>>> : no_null<ENUM>
{};
} // namespace pqxx


namespace pqxx::internal
{

template<typename ENUM> struct enum_traits
{
  using impl_type = std::underlying_type_t<ENUM>;
  using impl_traits = string_traits<impl_type>;

  [[nodiscard]] static constexpr zview
  to_buf(char *begin, char *end, ENUM const &value)
  {
    return impl_traits::to_buf(begin, end, to_underlying(value));
  }

  static constexpr char *into_buf(char *begin, char *end, ENUM const &value)
  {
    return impl_traits::into_buf(begin, end, to_underlying(value));
  }

  [[nodiscard]] static ENUM from_string(std::string_view text)
  {
    return static_cast<ENUM>(impl_traits::from_string(text));
  }

  [[nodiscard]] static std::size_t size_buffer(ENUM const &value) noexcept
  {
    return impl_traits::size_buffer(to_underlying(value));
  }

private:
  // C++23: Replace with std::to_underlying.
  static constexpr impl_type to_underlying(ENUM const &value) noexcept
  {
    return static_cast<impl_type>(value);
  }
};
} // namespace pqxx::internal



#define PQXX_DECLARE_ENUM_CONVERSION(ENUM)                                    \
  template<> struct string_traits<ENUM> : pqxx::internal::enum_traits<ENUM>   \
  {};                                                                         \
  template<> inline std::string const type_name<ENUM>                         \
  {                                                                           \
#    ENUM                                                                     \
  }


namespace pqxx
{

template<typename TYPE>
[[nodiscard]] inline TYPE from_string(std::string_view text)
{
  return string_traits<TYPE>::from_string(text);
}



template<>
[[nodiscard]] inline std::string_view from_string(std::string_view text)
{
  return text;
}



template<typename T> inline void from_string(std::string_view text, T &value)
{
  value = from_string<T>(text);
}



template<typename TYPE> inline std::string to_string(TYPE const &value);



template<typename... TYPE>
[[nodiscard]] inline std::vector<std::string_view>
to_buf(char *here, char const *end, TYPE... value)
{
  return {[&here, end](auto v) {
    auto begin = here;
    here = string_traits<decltype(v)>::into_buf(begin, end, v);
    // Exclude the trailing zero out of the string_view.
    auto len{static_cast<std::size_t>(here - begin) - 1};
    return std::string_view{begin, len};
  }(value)...};
}


template<typename TYPE>
inline void into_string(TYPE const &value, std::string &out);


template<typename TYPE>
[[nodiscard]] inline constexpr bool is_null(TYPE const &value) noexcept
{
  return nullness<strip_t<TYPE>>::is_null(value);
}



template<typename... TYPE>
[[nodiscard]] inline std::size_t size_buffer(TYPE const &...value) noexcept
{
  return (string_traits<strip_t<TYPE>>::size_buffer(value) + ...);
}



template<typename TYPE> inline constexpr bool is_sql_array{false};



template<typename TYPE> inline constexpr bool is_unquoted_safe{false};


template<typename T> inline constexpr char array_separator{','};



template<typename TYPE> inline constexpr format param_format(TYPE const &)
{
  return format::text;
}



template<typename TYPE>
inline zview generic_to_buf(char *begin, char *end, TYPE const &value)
{
  using traits = string_traits<TYPE>;
  // The trailing zero does not count towards the zview's size, so subtract 1
  // from the result we get from into_buf().
  if (is_null(value))
    return {};
  else
    return {begin, traits::into_buf(begin, end, value) - begin - 1};
}


#if defined(PQXX_HAVE_CONCEPTS)

template<class TYPE>
concept binary = std::ranges::contiguous_range<TYPE> and
  std::is_same_v<strip_t<value_type<TYPE>>, std::byte>;
#endif

} // namespace pqxx


#include "pqxx/internal/conversions.hxx"
#endif