composite.hxx

Go to the documentation of this file.

#ifndef PQXX_COMPOSITE_HXX
#define PQXX_COMPOSITE_HXX
 
#if !defined(PQXX_HEADER_PRE)
#  error "Include libpqxx headers as <pqxx/header>, not <pqxx/header.hxx>."
#endif
 
#include "pqxx/internal/array-composite.hxx"
#include "pqxx/util.hxx"
 
namespace pqxx
{
 
template<typename... T>
inline void parse_composite(ctx c, std::string_view text, T &...fields)
{
  static constexpr auto num_fields{sizeof...(T)};
  static_assert(num_fields > 0);
 
  auto const data{std::data(text)};
  auto const size{std::size(text)};
  if (size == 0)
    throw conversion_error{
      "Cannot parse composite value from empty string.", c.loc};
 
  if (data[0] != '(')
    throw conversion_error{
      std::format("Invalid composite value string: '{}'.", text), c.loc};
 
  // clang-tidy rule bug:
  // NOLINTBEGIN(misc-const-correctness)
  std::size_t here{1};
  std::size_t index{0};
  // NOLINTEND(misc-const-correctness)
  (pqxx::internal::specialize_parse_composite_field<T>(c)(
     index, text, here, fields, num_fields - 1, c.loc),
   ...);
  if (here != std::size(text))
    throw conversion_error{
      std::format(
        "Composite value did not end at the closing parenthesis: '{}'.", text),
      c.loc};
  if (text[here - 1] != ')')
    throw conversion_error{
      std::format("Composite value did not end in parenthesis: '{}'.", text),
      c.loc};
}
} // namespace pqxx
 
 
namespace pqxx::internal
{
constexpr char empty_composite_str[]{"()"};
} // namespace pqxx::internal
 
 
namespace pqxx
{
 
template<typename... T>
[[nodiscard]] inline std::size_t
composite_size_buffer(T const &...fields) noexcept
{
  constexpr auto num{sizeof...(fields)};
 
  // Size for a multi-field composite includes room for...
  //  + opening parenthesis
  //  + field budgets
  //  + separating comma per field
  //  - comma after final field
  //  + closing parenthesis
  //  + terminating zero
 
  if constexpr (num == 0)
    return std::size(pqxx::internal::empty_composite_str);
  else
    return 1 + (pqxx::internal::size_composite_field_buffer(fields) + ...) +
           num + 1;
}
 
 
 
template<typename... T>
inline zview composite_into_buf(ctx c, std::span<char> buf, T const &...fields)
{
  if (std::size(buf) < composite_size_buffer(fields...))
    throw conversion_error{
      "Buffer space may not be enough to represent composite value.", c.loc};
 
  constexpr auto num_fields{sizeof...(fields)};
  if constexpr (num_fields == 0)
  {
    constexpr std::string_view empty{"()"};
    return zview{
      std::data(buf),
      pqxx::internal::copy_chars<true>(empty, buf, 0, c.loc) - 1};
  }
 
  std::size_t pos{0};
  // C++26: Use buf.at().
  buf[pos++] = '(';
 
  (pqxx::internal::write_composite_field<T>(buf, pos, fields, c), ...);
 
  // If we've got multiple fields, "backspace" that last comma.
  if constexpr (num_fields > 1)
    --pos;
  // C++26: Use buf.at().
  buf[pos++] = ')';
  buf[pos] = '\0';
  return zview{std::data(buf), pos};
}
 
 
template<typename... T>
[[deprecated(
  "Pass conversion_context and std::span<char>, not two pointers.")]]
inline char *composite_into_buf(char *begin, char *end, T const &...fields)
{
  auto const text{composite_into_buf(
    {sl::current()}, std::span<char>{begin, end}, fields...)};
  return begin + std::size(text);
}
} // namespace pqxx
#endif