00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
#include "pqxx/libcompiler.h"
00020
00021
#include <string>
00022
00023
#include "pqxx/tablestream"
00024
00025
00026
00027
00028
namespace pqxx
00029 {
00030
class tablereader;
00031
00033
00042 class PQXX_LIBEXPORT tablewriter :
public tablestream
00043 {
00044
public:
00045 typedef unsigned size_type;
00046
00047 tablewriter(
transaction_base &,
00048
const PGSTD::string &WName,
00049
const PGSTD::string &Null=PGSTD::string());
00050
00052
00054
template<
typename ITER>
00055 tablewriter(
transaction_base &,
00056
const PGSTD::string &WName,
00057 ITER begincolumns,
00058 ITER endcolumns,
00059
const PGSTD::string &Null=PGSTD::string());
00060
00061 ~tablewriter() throw ();
00062
00063 template<typename IT>
void insert(IT Begin, IT End);
00064 template<typename TUPLE>
void insert(const TUPLE &);
00065 template<typename IT>
void push_back(IT Begin, IT End);
00066 template<typename TUPLE>
void push_back(const TUPLE &);
00067
00068 void reserve(
size_type) {}
00069
00070
template<
typename TUPLE> tablewriter &
operator<<(
const TUPLE &);
00071
00073 tablewriter &
operator<<(
tablereader &);
00074
00076
00078
template<
typename IT> PGSTD::string generate(IT Begin, IT End)
const;
00079
template<
typename TUPLE> PGSTD::string generate(
const TUPLE &) const;
00080
00082
00089 virtual
void complete();
00090
00091 #ifdef PQXX_DEPRECATED_HEADERS
00093 template<typename IT> PGSTD::string ezinekoT(IT Begin, IT End)
const
00094
{
return generate(Begin, End); }
00096
template<
typename TUPLE> PGSTD::string ezinekoT(
const TUPLE &T)
const
00097
{
return generate(T); }
00098
#endif
00099
00100
private:
00101
void setup(transaction_base &,
00102
const PGSTD::string &WName,
00103
const PGSTD::string &Columns = PGSTD::string());
00104
void WriteRawLine(
const PGSTD::string &);
00105
void writer_close();
00106 PGSTD::string EscapeAny(
const char *) const;
00107 PGSTD::string EscapeAny(const PGSTD::string &) const;
00108 template<typename T> PGSTD::string EscapeAny(const T &) const;
00109
00110 static PGSTD::string Escape(const PGSTD::string &);
00111 };
00112
00113 }
00114
00115
00116
00117 namespace PGSTD
00118 {
00120
00123
template<>
00124 class back_insert_iterator<pqxx::tablewriter> :
00125
public iterator<output_iterator_tag, void,void,void,void>
00126 {
00127
public:
00128 explicit back_insert_iterator(
pqxx::tablewriter &W) : m_Writer(&W) {}
00129
00130 back_insert_iterator &operator=(
const back_insert_iterator &rhs)
00131 {
00132 m_Writer = rhs.m_Writer;
00133
return *
this;
00134 }
00135
00136
template<
typename TUPLE>
00137 back_insert_iterator &operator=(
const TUPLE &T)
00138 {
00139 m_Writer->insert(T);
00140
return *
this;
00141 }
00142
00143 back_insert_iterator &operator++() {
return *
this; }
00144 back_insert_iterator &operator++(
int) {
return *
this; }
00145 back_insert_iterator &operator*() {
return *
this; }
00146
00147
private:
00148
pqxx::tablewriter *m_Writer;
00149 };
00150
00151 }
00152
00153
00154
namespace pqxx
00155 {
00156
00157
template<
typename ITER>
inline
00158 tablewriter::tablewriter(
transaction_base &T,
00159
const PGSTD::string &WName,
00160 ITER begincolumns,
00161 ITER endcolumns,
00162
const PGSTD::string &Null) :
00163
tablestream(T, WName, Null,
"tablewriter")
00164 {
00165 setup(T, WName,
columnlist(begincolumns, endcolumns));
00166 }
00167
00168
00169
inline PGSTD::string tablewriter::EscapeAny(
const PGSTD::string &t)
const
00170
{
00171
return (t ==
NullStr()) ?
"\\N" : Escape(t);
00172 }
00173
00174
inline PGSTD::string tablewriter::EscapeAny(
const char t[])
const
00175
{
00176
return t ? EscapeAny(PGSTD::string(t)) :
"\\N";
00177 }
00178
00179
template<
typename T>
inline PGSTD::string
00180 tablewriter::EscapeAny(
const T &t)
const
00181
{
00182
return EscapeAny(
to_string(t));
00183 }
00184
00185
00186
template<
typename IT>
00187 inline PGSTD::string tablewriter::generate(IT Begin, IT End)
const
00188
{
00189 PGSTD::string Line;
00190
for (; Begin != End; ++Begin)
00191 {
00192 Line += EscapeAny(*Begin);
00193 Line +=
"\t";
00194 }
00195
00196
00197
if (!Line.empty()) Line.erase(Line.size()-1);
00198
00199
return Line;
00200 }
00201
00202
00203
template<
typename TUPLE>
00204 inline PGSTD::string tablewriter::generate(
const TUPLE &T)
const
00205
{
00206
return generate(T.begin(), T.end());
00207 }
00208
00209
00210 template<
typename IT>
inline void tablewriter::insert(IT Begin, IT End)
00211 {
00212 WriteRawLine(
generate(Begin, End));
00213 }
00214
00215
00216 template<
typename TUPLE>
inline void tablewriter::insert(
const TUPLE &T)
00217 {
00218
insert(T.begin(), T.end());
00219 }
00220
00221
template<
typename IT>
00222 inline void tablewriter::push_back(IT Begin, IT End)
00223 {
00224
insert(Begin, End);
00225 }
00226
00227
template<
typename TUPLE>
00228 inline void tablewriter::push_back(
const TUPLE &T)
00229 {
00230
insert(T.begin(), T.end());
00231 }
00232
00233
template<
typename TUPLE>
00234 inline tablewriter &
tablewriter::operator<<(
const TUPLE &T)
00235 {
00236
insert(T);
00237
return *
this;
00238 }
00239
00240 }
00241
00242