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
template<
typename TUPLE>
00131 back_insert_iterator &operator=(
const TUPLE &T)
00132 {
00133 m_Writer.insert(T);
00134
return *
this;
00135 }
00136
00137 back_insert_iterator &operator++() {
return *
this; }
00138 back_insert_iterator &operator++(
int) {
return *
this; }
00139 back_insert_iterator &operator*() {
return *
this; }
00140
00141
private:
00142
pqxx::tablewriter &m_Writer;
00143 };
00144
00145 }
00146
00147
00148
namespace pqxx
00149 {
00150
00151
template<
typename ITER>
inline
00152 tablewriter::tablewriter(
transaction_base &T,
00153
const PGSTD::string &WName,
00154 ITER begincolumns,
00155 ITER endcolumns,
00156
const PGSTD::string &Null) :
00157
tablestream(T, WName, Null, "tablewriter")
00158 {
00159 setup(T, WName, columnlist(begincolumns, endcolumns));
00160 }
00161
00162
00163
inline PGSTD::string tablewriter::EscapeAny(
const PGSTD::string &t)
const
00164
{
00165
return (t ==
NullStr()) ?
"\\N" : Escape(t);
00166 }
00167
00168
inline PGSTD::string tablewriter::EscapeAny(
const char t[])
const
00169
{
00170
return t ? EscapeAny(PGSTD::string(t)) : "\\N";
00171 }
00172
00173
template<
typename T>
inline PGSTD::string
00174 tablewriter::EscapeAny(
const T &t)
const
00175
{
00176
return EscapeAny(
to_string(t));
00177 }
00178
00179
00180
template<
typename IT>
00181 inline PGSTD::string tablewriter::generate(IT Begin, IT End)
const
00182
{
00183 PGSTD::string Line;
00184
for (; Begin != End; ++Begin)
00185 {
00186 Line += EscapeAny(*Begin);
00187 Line +=
"\t";
00188 }
00189
00190
00191
if (!Line.empty()) Line.erase(Line.size()-1);
00192
00193
return Line;
00194 }
00195
00196
00197
template<
typename TUPLE>
00198 inline PGSTD::string tablewriter::generate(
const TUPLE &T)
const
00199
{
00200
return generate(T.begin(), T.end());
00201 }
00202
00203
00204 template<
typename IT>
inline void tablewriter::insert(IT Begin, IT End)
00205 {
00206 WriteRawLine(generate(Begin, End));
00207 }
00208
00209
00210 template<
typename TUPLE>
inline void tablewriter::insert(
const TUPLE &T)
00211 {
00212
insert(T.begin(), T.end());
00213 }
00214
00215
template<
typename IT>
00216 inline void tablewriter::push_back(IT Begin, IT End)
00217 {
00218
insert(Begin, End);
00219 }
00220
00221
template<
typename TUPLE>
00222 inline void tablewriter::push_back(
const TUPLE &T)
00223 {
00224
insert(T.begin(), T.end());
00225 }
00226
00227
template<
typename TUPLE>
00228 inline tablewriter &tablewriter::operator<<(
const TUPLE &T)
00229 {
00230
insert(T);
00231
return *
this;
00232 }
00233
00234 }
00235
00236