strconv.hxx

#ifndef PQXX_H_STRINGCONV
#define PQXX_H_STRINGCONV

#include "pqxx/compiler-public.hxx"

#include <limits>
#include <sstream>
#include <stdexcept>


namespace pqxx
{



template<typename T, typename = void> struct string_traits;

namespace internal
{
[[noreturn]] PQXX_LIBEXPORT void throw_null_conversion(
        const std::string &type);


template<typename TYPE> struct type_name;
#define PQXX_DECLARE_TYPE_NAME(TYPE) \
  template<> struct type_name<TYPE> \
  { static constexpr const char *value = #TYPE; }

PQXX_DECLARE_TYPE_NAME(bool);
PQXX_DECLARE_TYPE_NAME(short);
PQXX_DECLARE_TYPE_NAME(unsigned short);
PQXX_DECLARE_TYPE_NAME(int);
PQXX_DECLARE_TYPE_NAME(unsigned int);
PQXX_DECLARE_TYPE_NAME(long);
PQXX_DECLARE_TYPE_NAME(unsigned long);
PQXX_DECLARE_TYPE_NAME(long long);
PQXX_DECLARE_TYPE_NAME(unsigned long long);
PQXX_DECLARE_TYPE_NAME(float);
PQXX_DECLARE_TYPE_NAME(double);
PQXX_DECLARE_TYPE_NAME(long double);
PQXX_DECLARE_TYPE_NAME(char *);
PQXX_DECLARE_TYPE_NAME(const char *);
PQXX_DECLARE_TYPE_NAME(std::string);
PQXX_DECLARE_TYPE_NAME(const std::string);
PQXX_DECLARE_TYPE_NAME(std::stringstream);
#undef PQXX_DECLARE_TYPE_NAME

template<size_t N> struct type_name<char[N]>
{ static constexpr const char *value = "char[]"; };



template<typename TYPE> struct PQXX_LIBEXPORT builtin_traits
{
  static constexpr const char *name() noexcept
        { return internal::type_name<TYPE>::value; }
  static constexpr bool has_null() noexcept { return false; }
  static bool is_null(TYPE) { return false; }
  [[noreturn]] static TYPE null() { throw_null_conversion(name()); }
  static void from_string(const char Str[], TYPE &Obj);
  static std::string to_string(TYPE Obj);
};
} // namespace pqxx::internal


#define PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(TYPE) \
  template<> struct PQXX_LIBEXPORT string_traits<TYPE> : \
    internal::builtin_traits<TYPE> {};

PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(bool)

PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(short)
PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(unsigned short)
PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(int)
PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(unsigned int)
PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(long)
PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(unsigned long)
PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(long long)
PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(unsigned long long)

PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(float)
PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(double)
PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION(long double)

#undef PQXX_DECLARE_STRING_TRAITS_SPECIALIZATION



template<typename ENUM>
struct enum_traits
{
  using underlying_type = typename std::underlying_type<ENUM>::type;
  using underlying_traits = string_traits<underlying_type>;

  static constexpr bool has_null() noexcept { return false; }
  [[noreturn]] static ENUM null()
        { internal::throw_null_conversion("enum type"); }

  static void from_string(const char Str[], ENUM &Obj)
  {
    underlying_type tmp;
    underlying_traits::from_string(Str, tmp);
    Obj = ENUM(tmp);
  }

  static std::string to_string(ENUM Obj)
        { return underlying_traits::to_string(underlying_type(Obj)); }
};



#define PQXX_DECLARE_ENUM_CONVERSION(ENUM) \
template<> \
struct string_traits<ENUM> : pqxx::enum_traits<ENUM> \
{ \
  static constexpr const char *name() noexcept { return #ENUM; } \
  [[noreturn]] static ENUM null() \
        { internal::throw_null_conversion(name()); } \
}


template<> struct PQXX_LIBEXPORT string_traits<const char *>
{
  static constexpr const char *name() noexcept { return "const char *"; }
  static constexpr bool has_null() noexcept { return true; }
  static bool is_null(const char *t) { return t == nullptr; }
  static const char *null() { return nullptr; }
  static void from_string(const char Str[], const char *&Obj) { Obj = Str; }
  static std::string to_string(const char *Obj) { return Obj; }
};

template<> struct PQXX_LIBEXPORT string_traits<char *>
{
  static constexpr const char *name() noexcept { return "char *"; }
  static constexpr bool has_null() noexcept { return true; }
  static bool is_null(const char *t) { return t == nullptr; }
  static const char *null() { return nullptr; }

  // Don't allow this conversion since it breaks const-safety.
  // static void from_string(const char Str[], char *&Obj);

  static std::string to_string(char *Obj) { return Obj; }
};

template<size_t N> struct PQXX_LIBEXPORT string_traits<char[N]>
{
  static constexpr const char *name() noexcept { return "char[]"; }
  static constexpr bool has_null() noexcept { return true; }
  static bool is_null(const char t[]) { return t == nullptr; }
  static const char *null() { return nullptr; }
  static std::string to_string(const char Obj[]) { return Obj; }
};

template<> struct PQXX_LIBEXPORT string_traits<std::string>
{
  static constexpr const char *name() noexcept { return "string"; }
  static constexpr bool has_null() noexcept { return false; }
  static bool is_null(const std::string &) { return false; }
  [[noreturn]] static std::string null()
        { internal::throw_null_conversion(name()); }
  static void from_string(const char Str[], std::string &Obj) { Obj=Str; }
  static std::string to_string(const std::string &Obj) { return Obj; }
};

template<> struct PQXX_LIBEXPORT string_traits<const std::string>
{
  static constexpr const char *name() noexcept { return "const string"; }
  static constexpr bool has_null() noexcept { return false; }
  static bool is_null(const std::string &) { return false; }
  [[noreturn]] static const std::string null()
        { internal::throw_null_conversion(name()); }
  static const std::string to_string(const std::string &Obj) { return Obj; }
};

template<> struct PQXX_LIBEXPORT string_traits<std::stringstream>
{
  static constexpr const char *name() noexcept { return "stringstream"; }
  static constexpr bool has_null() noexcept { return false; }
  static bool is_null(const std::stringstream &) { return false; }
  [[noreturn]] static std::stringstream null()
        { internal::throw_null_conversion(name()); }
  static void from_string(const char Str[], std::stringstream &Obj)
        { Obj.clear(); Obj << Str; }
  static std::string to_string(const std::stringstream &Obj)
        { return Obj.str(); }
};


// TODO: Implement date conversions.


template<typename T>
  inline void from_string(const char Str[], T &Obj)
{
  if (Str == nullptr) throw std::runtime_error{"Attempt to read null string."};
  string_traits<T>::from_string(Str, Obj);
}



template<typename T> inline void from_string(const char Str[], T &Obj, size_t)
{
  return from_string(Str, Obj);
}

template<>
  inline void from_string<std::string>(                                 //[t00]
        const char Str[],
        std::string &Obj,
        size_t len)
{
  if (Str == nullptr) throw std::runtime_error{"Attempt to read null string."};
  Obj.assign(Str, len);
}

template<typename T>
  inline void from_string(const std::string &Str, T &Obj)               //[t45]
        { from_string(Str.c_str(), Obj); }

template<typename T>
  inline void from_string(const std::stringstream &Str, T &Obj)         //[t00]
        { from_string(Str.str(), Obj); }

template<> inline void
from_string(const std::string &Str, std::string &Obj)                   //[t46]
        { Obj = Str; }


namespace internal
{
constexpr int digit_to_number(char c) noexcept { return c-'0'; }
constexpr char number_to_digit(int i) noexcept
        { return static_cast<char>(i+'0'); }
} // namespace pqxx::internal



template<typename T> inline std::string to_string(const T &Obj)
        { return string_traits<T>::to_string(Obj); }


} // namespace pqxx

#endif