22 #include "pqxx/compiler-public.hxx" 
   23 #include "pqxx/compiler-internal-pre.hxx" 
   31 #include "pqxx/internal/result_data.hxx" 
   33 #include "pqxx/except" 
   49 class result_connection;
 
   50 class result_creation;
 
   51 class result_sql_cursor;
 
   56 class const_result_iterator;
 
   57 class const_reverse_result_iterator;
 
   83         const internal::result_data, internal::freemem_result_data>
 
   86         const internal::result_data, internal::freemem_result_data> 
super;
 
  104         super(rhs), m_data(rhs.m_data) {}
 
  107         { super::operator=(rhs); m_data=rhs.m_data; 
return *
this; }
 
  113   bool operator==(
const result &) 
const throw ();                       
 
  114   bool operator!=(const 
result &rhs) const throw ()                     
 
  115         { 
return !operator==(rhs); }
 
  118   const_reverse_iterator rbegin() 
const;                                
 
  119   const_reverse_iterator rend() 
const;                                  
 
  121   const_iterator begin() 
const throw ();                                
 
  122   inline const_iterator end() const throw ();                           
 
  127   size_type PQXX_PURE size() 
const throw ();                            
 
  128   bool PQXX_PURE empty() const throw ();                                
 
  131   void swap(
result &) throw ();                                         
 
  134         { 
return tuple(
this, i); }
 
  137   void clear() throw () { super::reset(); m_data = 0; }                 
 
  147   tuple::size_type column_number(const 
char ColName[]) const;           
 
  159   oid column_type(
int ColNum) 
const                                      
  163   oid column_type(
const PGSTD::string &ColName) 
const                    
  167   oid column_type(
const char ColName[]) 
const                            
  174   oid column_table(
int ColNum) 
const                                     
  178   oid column_table(
const PGSTD::string &ColName) 
const                   
  194   const PGSTD::string & PQXX_PURE query() 
const throw ();               
 
  200   oid PQXX_PURE inserted_oid() const;                                   
 
  206   size_type PQXX_PURE affected_rows() const;                            
 
  215         tuple::size_type) const throw ();
 
  217   friend class pqxx::internal::gate::result_creation;
 
  218   result(internal::pq::PGresult *rhs,
 
  220         const PGSTD::
string &Query,
 
  222   void PQXX_PRIVATE CheckStatus() const;
 
  224   friend class pqxx::internal::gate::result_connection;
 
  225   bool operator!() const throw () { 
return !m_data; }
 
  226   operator bool() 
const throw () { 
return m_data != 0; }
 
  228   void PQXX_PRIVATE PQXX_NORETURN ThrowSQLError(
 
  229         const PGSTD::string &Err,
 
  230         const PGSTD::string &Query) 
const;
 
  231   int PQXX_PRIVATE PQXX_PURE errorposition() 
const throw ();
 
  232   PGSTD::
string PQXX_PRIVATE StatusError() const;
 
  234   friend class pqxx::internal::gate::result_sql_cursor;
 
  235   const 
char * PQXX_PURE CmdStatus() const throw ();
 
  238   pqxx::internal::pq::PGresult *m_data;
 
  240   static const PGSTD::
string PQXX_PRIVATE s_empty_string;
 
  251         PGSTD::random_access_iterator_tag,
 
  290   const_result_iterator operator++(
int);                                
 
  291   const_result_iterator &
operator++() { ++m_Index; 
return *
this; }      
 
  292   const_result_iterator operator--(
int);                                
 
  293   const_result_iterator &
operator--() { --m_Index; 
return *
this; }      
 
  295   const_result_iterator &operator+=(difference_type i)                  
 
  296       { m_Index = size_type(difference_type(m_Index) + i); 
return *
this; }
 
  297   const_result_iterator &operator-=(difference_type i)                  
 
  298       { m_Index = size_type(difference_type (m_Index) - i); 
return *
this; }
 
  305   bool operator==(
const const_result_iterator &i) 
const                  
  306       {
return m_Index==i.m_Index;}
 
  307   bool operator!=(
const const_result_iterator &i) 
const                  
  308       {
return m_Index!=i.m_Index;}
 
  309   bool operator<(
const const_result_iterator &i) 
const                   
  310       {
return m_Index<i.m_Index;}
 
  311   bool operator<=(
const const_result_iterator &i) 
const                  
  312       {
return m_Index<=i.m_Index;}
 
  313   bool operator>(
const const_result_iterator &i) 
const                   
  314       {
return m_Index>i.m_Index;}
 
  315   bool operator>=(
const const_result_iterator &i) 
const                  
  316       {
return m_Index>=i.m_Index;}
 
  323   inline const_result_iterator 
operator+(difference_type) 
const;        
 
  326         const_result_iterator);
 
  327   inline const_result_iterator operator-(difference_type) 
const;        
 
  328   inline difference_type operator-(const_result_iterator) 
const;        
 
  340   private const_result_iterator
 
  343   typedef const_result_iterator 
super;
 
  345   using iterator_type::iterator_category;
 
  349   using iterator_type::value_type;
 
  353   typedef const tuple &reference;
 
  354   typedef tuple value_type;
 
  359     const_result_iterator(rhs) {}
 
  361         const const_result_iterator &rhs) :
 
  362     const_result_iterator(rhs) { super::operator--(); }
 
  364   const_result_iterator PQXX_PURE base() 
const throw ();                
 
  370   using const_result_iterator::operator->;                              
 
  371   using const_result_iterator::operator*;                               
 
  380       { iterator_type::operator=(r); 
return *
this; }
 
  382       { iterator_type::operator--(); 
return *
this; }
 
  385       { iterator_type::operator++(); 
return *
this; }
 
  388       { iterator_type::operator-=(i); 
return *
this; }
 
  390       { iterator_type::operator+=(i); 
return *
this; }
 
  401   difference_type operator-(                                            
 
  403       { 
return rhs.const_result_iterator::operator-(*this); }
 
  412       { 
return iterator_type::operator==(rhs); }
 
  415       { 
return !operator==(rhs); }
 
  418       { 
return iterator_type::operator>(rhs); }
 
  420       { 
return iterator_type::operator>=(rhs); }
 
  422       { 
return iterator_type::operator<(rhs); }
 
  424       { 
return iterator_type::operator<=(rhs); }
 
  451 template<
typename CHAR>
 
  453         PGSTD::basic_ostream<CHAR> &S, 
const pqxx::field &F)            
 
  455   S.write(F.
c_str(), PGSTD::streamsize(F.
size()));
 
  468         { 
return PGSTD::string(Obj.
c_str(), Obj.
size()); }
 
  471 inline const_result_iterator
 
  474   return const_result_iterator(
 
  478 inline const_result_iterator
 
  482 inline const_result_iterator
 
  485   return const_result_iterator(
 
  495         { 
return const_result_iterator(
this, size()); }
 
  506 #include "pqxx/compiler-internal-post.hxx"