00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef PQXX_H_TABLEWRITER
00020 #define PQXX_H_TABLEWRITER
00021
00022 #include <iterator>
00023
00024 #include "pqxx/compiler-public.hxx"
00025 #include "pqxx/compiler-internal-pre.hxx"
00026 #include "pqxx/tablestream"
00027
00028 namespace pqxx
00029 {
00030 class tablereader;
00032
00035 class PQXX_LIBEXPORT tablewriter : public tablestream
00036 {
00037 public:
00038 typedef unsigned size_type;
00039 tablewriter(transaction_base &,
00040 const std::string &WName,
00041 const std::string &Null=std::string());
00042 template<typename ITER> tablewriter(transaction_base &,
00043 const std::string &WName,
00044 ITER begincolumns,
00045 ITER endcolumns);
00046 template<typename ITER> tablewriter(transaction_base &T,
00047 const std::string &WName,
00048 ITER begincolumns,
00049 ITER endcolumns,
00050 const std::string &Null);
00051 ~tablewriter() PQXX_NOEXCEPT;
00052 template<typename IT> void insert(IT Begin, IT End);
00053 template<typename TUPLE> void insert(const TUPLE &);
00054 template<typename IT> void push_back(IT Begin, IT End);
00055 template<typename TUPLE> void push_back(const TUPLE &);
00056 void reserve(size_type) {}
00057 template<typename TUPLE> tablewriter &operator<<(const TUPLE &);
00058 tablewriter &operator<<(tablereader &);
00059 template<typename IT> std::string generate(IT Begin, IT End) const;
00060 template<typename TUPLE> std::string generate(const TUPLE &) const;
00061 virtual void complete() PQXX_OVERRIDE;
00062 void write_raw_line(const std::string &);
00063 private:
00064 void setup(transaction_base &,
00065 const std::string &WName,
00066 const std::string &Columns = std::string());
00067 PQXX_PRIVATE void writer_close();
00068 };
00069 }
00070 namespace std
00071 {
00072 template<>
00073 class back_insert_iterator<pqxx::tablewriter> :
00074 public iterator<output_iterator_tag, void,void,void,void>
00075 {
00076 public:
00077 explicit back_insert_iterator(pqxx::tablewriter &W) PQXX_NOEXCEPT :
00078 m_Writer(&W) {}
00079 back_insert_iterator &
00080 operator=(const back_insert_iterator &rhs) PQXX_NOEXCEPT
00081 {
00082 m_Writer = rhs.m_Writer;
00083 return *this;
00084 }
00085 template<typename TUPLE>
00086 back_insert_iterator &operator=(const TUPLE &T)
00087 {
00088 m_Writer->insert(T);
00089 return *this;
00090 }
00091 back_insert_iterator &operator++() { return *this; }
00092 back_insert_iterator &operator++(int) { return *this; }
00093 back_insert_iterator &operator*() { return *this; }
00094 private:
00095 pqxx::tablewriter *m_Writer;
00096 };
00097 }
00098 namespace pqxx
00099 {
00100 template<typename ITER> inline tablewriter::tablewriter(transaction_base &T,
00101 const std::string &WName,
00102 ITER begincolumns,
00103 ITER endcolumns) :
00104 namedclass("tablewriter", WName),
00105 tablestream(T, std::string())
00106 {
00107 setup(T, WName, columnlist(begincolumns, endcolumns));
00108 }
00109 template<typename ITER> inline tablewriter::tablewriter(transaction_base &T,
00110 const std::string &WName,
00111 ITER begincolumns,
00112 ITER endcolumns,
00113 const std::string &Null) :
00114 namedclass("tablewriter", WName),
00115 tablestream(T, Null)
00116 {
00117 setup(T, WName, columnlist(begincolumns, endcolumns));
00118 }
00119 namespace internal
00120 {
00121 PQXX_LIBEXPORT std::string Escape(
00122 const std::string &s,
00123 const std::string &null);
00124 inline std::string EscapeAny(
00125 const std::string &s,
00126 const std::string &null)
00127 { return Escape(s, null); }
00128 inline std::string EscapeAny(
00129 const char s[],
00130 const std::string &null)
00131 { return s ? Escape(std::string(s), null) : "\\N"; }
00132 template<typename T> inline std::string EscapeAny(
00133 const T &t,
00134 const std::string &null)
00135 { return Escape(to_string(t), null); }
00136 template<typename IT> class Escaper
00137 {
00138 const std::string &m_null;
00139 public:
00140 explicit Escaper(const std::string &null) : m_null(null) {}
00141 std::string operator()(IT i) const { return EscapeAny(*i, m_null); }
00142 };
00143 }
00144 template<typename IT>
00145 inline std::string tablewriter::generate(IT Begin, IT End) const
00146 {
00147 return separated_list("\t", Begin, End, internal::Escaper<IT>(NullStr()));
00148 }
00149 template<typename TUPLE>
00150 inline std::string tablewriter::generate(const TUPLE &T) const
00151 {
00152 return generate(T.begin(), T.end());
00153 }
00154 template<typename IT> inline void tablewriter::insert(IT Begin, IT End)
00155 {
00156 write_raw_line(generate(Begin, End));
00157 }
00158 template<typename TUPLE> inline void tablewriter::insert(const TUPLE &T)
00159 {
00160 insert(T.begin(), T.end());
00161 }
00162 template<typename IT>
00163 inline void tablewriter::push_back(IT Begin, IT End)
00164 {
00165 insert(Begin, End);
00166 }
00167 template<typename TUPLE>
00168 inline void tablewriter::push_back(const TUPLE &T)
00169 {
00170 insert(T.begin(), T.end());
00171 }
00172 template<typename TUPLE>
00173 inline tablewriter &tablewriter::operator<<(const TUPLE &T)
00174 {
00175 insert(T);
00176 return *this;
00177 }
00178 }
00179 #include "pqxx/compiler-internal-post.hxx"
00180 #endif