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