libpqxx
tablewriter.hxx
1
13#ifndef PQXX_H_TABLEWRITER
14#define PQXX_H_TABLEWRITER
15
16#include <iterator>
17
18#include "pqxx/compiler-public.hxx"
19#include "pqxx/compiler-internal-pre.hxx"
20
21#include "pqxx/tablestream.hxx"
22
23
24namespace pqxx
25{
27
31class PQXX_LIBEXPORT tablewriter : public tablestream
32{
33public:
34 PQXX_DEPRECATED tablewriter(
36 const std::string &WName,
37 const std::string &Null=std::string{});
38 template<typename ITER>
39 PQXX_DEPRECATED tablewriter(
41 const std::string &WName,
42 ITER begincolumns,
43 ITER endcolumns);
44 template<typename ITER>
45 PQXX_DEPRECATED tablewriter(
47 const std::string &WName,
48 ITER begincolumns,
49 ITER endcolumns,
50 const std::string &Null);
51 ~tablewriter() noexcept;
52 template<typename IT> void insert(IT Begin, IT End);
53 template<typename TUPLE> void insert(const TUPLE &);
54 template<typename IT> void push_back(IT Begin, IT End);
55 template<typename TUPLE> void push_back(const TUPLE &);
56 template<typename SIZE> void reserve(SIZE) {}
57 template<typename TUPLE> tablewriter &operator<<(const TUPLE &);
59 template<typename IT> std::string generate(IT Begin, IT End) const;
60 template<typename TUPLE> std::string generate(const TUPLE &) const;
61 virtual void complete() override;
62 void write_raw_line(const std::string &);
63private:
64 void set_up(
66 const std::string &WName,
67 const std::string &Columns = std::string{});
68 PQXX_PRIVATE void writer_close();
69};
70} // namespace pqxx
71
72
73namespace std
74{
75template<>
76 class back_insert_iterator<pqxx::tablewriter>
77{
78public:
79 using iterator_category = output_iterator_tag;
80
82 m_writer{&W} {}
83
84 back_insert_iterator &
85 operator=(const back_insert_iterator &rhs) noexcept
86 {
87 m_writer = rhs.m_writer;
88 return *this;
89 }
90
91 template<typename TUPLE>
92 back_insert_iterator &operator=(const TUPLE &T)
93 {
94 m_writer->insert(T);
95 return *this;
96 }
97
98 back_insert_iterator &operator++() { return *this; }
99 back_insert_iterator &operator++(int) { return *this; }
100 back_insert_iterator &operator*() { return *this; }
101
102private:
103 pqxx::tablewriter *m_writer;
104};
105} // namespace std
106
107
108namespace pqxx
109{
110template<typename ITER> inline tablewriter::tablewriter(
112 const std::string &WName,
113 ITER begincolumns,
114 ITER endcolumns) :
115 namedclass{"tablewriter", WName},
116 tablestream{T, std::string{}}
117{
118 set_up(T, WName, columnlist(begincolumns, endcolumns));
119}
120
121
122template<typename ITER> inline tablewriter::tablewriter(
124 const std::string &WName,
125 ITER begincolumns,
126 ITER endcolumns,
127 const std::string &Null) :
128 namedclass{"tablewriter", WName},
129 tablestream{T, Null}
130{
131 set_up(T, WName, columnlist(begincolumns, endcolumns));
132}
133
134
135namespace internal
136{
137PQXX_LIBEXPORT std::string escape(
138 const std::string &s,
139 const std::string &null);
140
141inline std::string escape_any(
142 const std::string &s,
143 const std::string &null)
144{ return escape(s, null); }
145
146inline std::string escape_any(
147 const char s[],
148 const std::string &null)
149{ return s ? escape(std::string{s}, null) : "\\N"; }
150
151template<typename T> inline std::string escape_any(
152 const T &t,
153 const std::string &null)
154{ return escape(to_string(t), null); }
155
156
157template<typename IT> class Escaper
158{
159 const std::string &m_null;
160public:
161 explicit Escaper(const std::string &null) : m_null{null} {}
162 std::string operator()(IT i) const { return escape_any(*i, m_null); }
163};
164}
165
166
167template<typename IT>
168inline std::string tablewriter::generate(IT Begin, IT End) const
169{
170 return separated_list("\t", Begin, End, internal::Escaper<IT>{NullStr()});
171}
172template<typename TUPLE>
173inline std::string tablewriter::generate(const TUPLE &T) const
174{
175 return generate(std::begin(T), std::end(T));
176}
177
178template<typename IT> inline void tablewriter::insert(IT Begin, IT End)
179{
180 write_raw_line(generate(Begin, End));
181}
182
183template<typename TUPLE> inline void tablewriter::insert(const TUPLE &T)
184{
185 insert(std::begin(T), std::end(T));
186}
187
188template<typename IT>
189inline void tablewriter::push_back(IT Begin, IT End)
190{
191 insert(Begin, End);
192}
193
194template<typename TUPLE>
195inline void tablewriter::push_back(const TUPLE &T)
196{
197 insert(std::begin(T), std::end(T));
198}
199
200template<typename TUPLE>
202{
203 insert(T);
204 return *this;
205}
206
207} // namespace pqxx
208#include "pqxx/compiler-internal-post.hxx"
209#endif
STL namespace.
The home of all libpqxx classes, functions, templates, etc.
Definition: array.hxx:26
std::basic_ostream< CHAR > & operator<<(std::basic_ostream< CHAR > &S, const field &F)
Write a result field to any type of stream.
Definition: field.hxx:355
std::string to_string(const field &Obj)
Convert a field to a string.
Definition: result.cxx:451
std::string separated_list(const std::string &sep, ITER begin, ITER end, ACCESS access)
Represent sequence of values as a string, joined by a given separator.
Definition: util.hxx:95
std::string escape(const std::string &s, const std::string &null)
Definition: tablewriter.cxx:131
std::string escape_any(const std::string &s, const std::string &null)
Definition: tablewriter.hxx:141
Definition: tablereader.hxx:30
Base class for obsolete tablereader/tablewriter classes.
Definition: tablestream.hxx:28
const std::string & NullStr() const
Definition: tablestream.hxx:36
static std::string columnlist(ITER colbegin, ITER colend)
Definition: tablestream.hxx:52
Definition: tablewriter.hxx:32
tablewriter(transaction_base &, const std::string &WName, const std::string &Null=std::string{})
Definition: tablewriter.cxx:22
void reserve(SIZE)
Definition: tablewriter.hxx:56
void insert(IT Begin, IT End)
Definition: tablewriter.hxx:178
std::string generate(IT Begin, IT End) const
Definition: tablewriter.hxx:168
void push_back(IT Begin, IT End)
Definition: tablewriter.hxx:189
tablewriter & operator<<(const TUPLE &)
Definition: tablewriter.hxx:201
void write_raw_line(const std::string &)
Definition: tablewriter.cxx:65
back_insert_iterator & operator*()
Definition: tablewriter.hxx:100
back_insert_iterator(pqxx::tablewriter &W) noexcept
Definition: tablewriter.hxx:81
back_insert_iterator & operator=(const back_insert_iterator &rhs) noexcept
Definition: tablewriter.hxx:85
back_insert_iterator & operator=(const TUPLE &T)
Definition: tablewriter.hxx:92
back_insert_iterator & operator++()
Definition: tablewriter.hxx:98
back_insert_iterator & operator++(int)
Definition: tablewriter.hxx:99
output_iterator_tag iterator_category
Definition: tablewriter.hxx:79
Definition: tablewriter.hxx:158
std::string operator()(IT i) const
Definition: tablewriter.hxx:162
Escaper(const std::string &null)
Definition: tablewriter.hxx:161
Interface definition (and common code) for "transaction" classes.
Definition: transaction_base.hxx:138