tablereader.hxx

Go to the documentation of this file.
00001 /*-------------------------------------------------------------------------
00002  *
00003  *   FILE
00004  *      pqxx/tablereader.hxx
00005  *
00006  *   DESCRIPTION
00007  *      definition of the pqxx::tablereader class.
00008  *   pqxx::tablereader enables optimized batch reads from a database table
00009  *   DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/tablereader instead.
00010  *
00011  * Copyright (c) 2001-2006, Jeroen T. Vermeulen <jtv@xs4all.nl>
00012  *
00013  * See COPYING for copyright license.  If you did not receive a file called
00014  * COPYING with this source code, please notify the distributor of this mistake,
00015  * or contact the author.
00016  *
00017  *-------------------------------------------------------------------------
00018  */
00019 #include "pqxx/compiler-public.hxx"
00020 #include "pqxx/compiler-internal-pre.hxx"
00021 
00022 #include "pqxx/result"
00023 #include "pqxx/tablestream"
00024 
00025 /* Methods tested in eg. self-test program test001 are marked with "//[t1]"
00026  */
00027 
00028 namespace pqxx
00029 {
00030 
00032 
00046 class PQXX_LIBEXPORT tablereader : public tablestream
00047 {
00048 public:
00049   tablereader(transaction_base &,
00050       const PGSTD::string &Name,
00051       const PGSTD::string &Null=PGSTD::string());                       //[t6]
00052 
00054 
00056   template<typename ITER>
00057   tablereader(transaction_base &,
00058       const PGSTD::string &Name,
00059       ITER begincolumns,
00060       ITER endcolumns);                                                 //[t80]
00061 
00062   template<typename ITER> tablereader(transaction_base &,
00063       const PGSTD::string &Name,
00064       ITER begincolumns,
00065       ITER endcolumns,
00066       const PGSTD::string &Null);                                       //[t80]
00067 
00068   ~tablereader() throw ();                                              //[t6]
00069 
00070   template<typename TUPLE> tablereader &operator>>(TUPLE &);            //[t8]
00071 
00072   operator bool() const throw () { return !m_Done; }                    //[t6]
00073   bool operator!() const throw () { return m_Done; }                    //[t6]
00074 
00076 
00080   bool get_raw_line(PGSTD::string &Line);                               //[t8]
00081 
00082   template<typename TUPLE>
00083   void tokenize(PGSTD::string, TUPLE &) const;                          //[t8]
00084 
00086 
00093   virtual void complete();                                              //[t8]
00094 
00095 private:
00096   void setup(transaction_base &T,
00097       const PGSTD::string &RName,
00098       const PGSTD::string &Columns=PGSTD::string());
00099   void PQXX_PRIVATE reader_close();
00100   PGSTD::string extract_field(const PGSTD::string &,
00101       PGSTD::string::size_type &) const;
00102 
00103   bool m_Done;
00104 };
00105 
00106 
00107 // TODO: Find meaningful definition of input iterator
00108 
00109 
00110 template<typename ITER> inline
00111 tablereader::tablereader(transaction_base &T,
00112     const PGSTD::string &Name,
00113     ITER begincolumns,
00114     ITER endcolumns) :
00115   namedclass(Name, "tablereader"),
00116   tablestream(T, PGSTD::string()),
00117   m_Done(true)
00118 {
00119   setup(T, Name, columnlist(begincolumns, endcolumns));
00120 }
00121 
00122 template<typename ITER> inline
00123 tablereader::tablereader(transaction_base &T,
00124     const PGSTD::string &Name,
00125     ITER begincolumns,
00126     ITER endcolumns,
00127     const PGSTD::string &Null) :
00128   namedclass(Name, "tablereader"),
00129   tablestream(T, Null),
00130   m_Done(true)
00131 {
00132   setup(T, Name, columnlist(begincolumns, endcolumns));
00133 }
00134 
00135 
00136 template<typename TUPLE>
00137 inline void tablereader::tokenize(PGSTD::string Line, TUPLE &T) const
00138 {
00139   PGSTD::back_insert_iterator<TUPLE> ins = PGSTD::back_inserter(T);
00140 
00141   // Filter and tokenize line, inserting tokens at end of T
00142   PGSTD::string::size_type here=0;
00143   while (here < Line.size()) *ins++ = extract_field(Line, here);
00144 }
00145 
00146 
00147 template<typename TUPLE>
00148 inline tablereader &pqxx::tablereader::operator>>(TUPLE &T)
00149 {
00150   PGSTD::string Line;
00151   if (get_raw_line(Line)) tokenize(Line, T);
00152   return *this;
00153 }
00154 
00155 
00156 } // namespace pqxx
00157 
00158 #include "pqxx/compiler-internal-post.hxx"

Generated on Thu Feb 1 17:12:08 2007 for libpqxx by  doxygen 1.5.1