tablewriter.hxx

#ifndef PQXX_H_TABLEWRITER
#define PQXX_H_TABLEWRITER

#include <iterator>

#include "pqxx/compiler-public.hxx"
#include "pqxx/compiler-internal-pre.hxx"

#include "pqxx/tablestream.hxx"


namespace pqxx
{

class PQXX_LIBEXPORT tablewriter : public tablestream
{
public:
  PQXX_DEPRECATED tablewriter(
        transaction_base &,
        const std::string &WName,
        const std::string &Null=std::string{});
  template<typename ITER>
        PQXX_DEPRECATED tablewriter(
        transaction_base &,
        const std::string &WName,
        ITER begincolumns,
        ITER endcolumns);
  template<typename ITER>
        PQXX_DEPRECATED tablewriter(
        transaction_base &T,
        const std::string &WName,
        ITER begincolumns,
        ITER endcolumns,
        const std::string &Null);
  ~tablewriter() noexcept;
  template<typename IT> void insert(IT Begin, IT End);
  template<typename TUPLE> void insert(const TUPLE &);
  template<typename IT> void push_back(IT Begin, IT End);
  template<typename TUPLE> void push_back(const TUPLE &);
  template<typename SIZE> void reserve(SIZE) {}
  template<typename TUPLE> tablewriter &operator<<(const TUPLE &);
  tablewriter &operator<<(tablereader &);
  template<typename IT> std::string generate(IT Begin, IT End) const;
  template<typename TUPLE> std::string generate(const TUPLE &) const;
  virtual void complete() override;
  void write_raw_line(const std::string &);
private:
  void set_up(
        transaction_base &,
        const std::string &WName,
        const std::string &Columns = std::string{});
  PQXX_PRIVATE void writer_close();
};
} // namespace pqxx


namespace std
{
template<>
  class back_insert_iterator<pqxx::tablewriter>
{
public:
  using iterator_category = output_iterator_tag;

  explicit back_insert_iterator(pqxx::tablewriter &W) noexcept :
    m_writer{&W} {}

  back_insert_iterator &
    operator=(const back_insert_iterator &rhs) noexcept
  {
    m_writer = rhs.m_writer;
    return *this;
  }

  template<typename TUPLE>
  back_insert_iterator &operator=(const TUPLE &T)
  {
    m_writer->insert(T);
    return *this;
  }

  back_insert_iterator &operator++() { return *this; }
  back_insert_iterator &operator++(int) { return *this; }
  back_insert_iterator &operator*() { return *this; }

private:
  pqxx::tablewriter *m_writer;
};
} // namespace std


namespace pqxx
{
template<typename ITER> inline tablewriter::tablewriter(
        transaction_base &T,
        const std::string &WName,
        ITER begincolumns,
        ITER endcolumns) :
  namedclass{"tablewriter", WName},
  tablestream{T, std::string{}}
{
  set_up(T, WName, columnlist(begincolumns, endcolumns));
}


template<typename ITER> inline tablewriter::tablewriter(
        transaction_base &T,
        const std::string &WName,
        ITER begincolumns,
        ITER endcolumns,
        const std::string &Null) :
  namedclass{"tablewriter", WName},
  tablestream{T, Null}
{
  set_up(T, WName, columnlist(begincolumns, endcolumns));
}


namespace internal
{
PQXX_LIBEXPORT std::string escape(
        const std::string &s,
        const std::string &null);

inline std::string escape_any(
        const std::string &s,
        const std::string &null)
{ return escape(s, null); }

inline std::string escape_any(
        const char s[],
        const std::string &null)
{ return s ? escape(std::string{s}, null) : "\\N"; }

template<typename T> inline std::string escape_any(
        const T &t,
        const std::string &null)
{ return escape(to_string(t), null); }


template<typename IT> class Escaper
{
  const std::string &m_null;
public:
  explicit Escaper(const std::string &null) : m_null{null} {}
  std::string operator()(IT i) const { return escape_any(*i, m_null); }
};
}


template<typename IT>
inline std::string tablewriter::generate(IT Begin, IT End) const
{
  return separated_list("\t", Begin, End, internal::Escaper<IT>{NullStr()});
}
template<typename TUPLE>
inline std::string tablewriter::generate(const TUPLE &T) const
{
  return generate(std::begin(T), std::end(T));
}

template<typename IT> inline void tablewriter::insert(IT Begin, IT End)
{
  write_raw_line(generate(Begin, End));
}

template<typename TUPLE> inline void tablewriter::insert(const TUPLE &T)
{
  insert(std::begin(T), std::end(T));
}

template<typename IT>
inline void tablewriter::push_back(IT Begin, IT End)
{
  insert(Begin, End);
}

template<typename TUPLE>
inline void tablewriter::push_back(const TUPLE &T)
{
  insert(std::begin(T), std::end(T));
}

template<typename TUPLE>
inline tablewriter &tablewriter::operator<<(const TUPLE &T)
{
  insert(T);
  return *this;
}

} // namespace pqxx
#include "pqxx/compiler-internal-post.hxx"
#endif