21 #include "pqxx/compiler-public.hxx" 
   30 #ifdef PQXX_TR1_HEADERS 
   36 #include "pqxx/strconv" 
  272 #include <pqxx/internal/libpq-forward.hxx> 
  358 template<typename T=PGSTD::
string, typename CONT=PGSTD::vector<T> >
 
  365   explicit items(
const T &t) : CONT() { this->push_back(t); }           
 
  366   items(
const T &t1, 
const T &t2) : CONT()                              
 
  367         { this->push_back(t1); this->push_back(t2); }
 
  368   items(
const T &t1, 
const T &t2, 
const T &t3) : CONT()                 
 
  369         { this->push_back(t1); this->push_back(t2); this->push_back(t3); }
 
  370   items(
const T &t1, 
const T &t2, 
const T &t3, 
const T &t4) : CONT()    
 
  377   items(
const T&t1,
const T&t2,
const T&t3,
const T&t4,
const T&t5):CONT()  
 
  403   typename ITER::value_type 
operator()(ITER i)
 const { 
return *i; }
 
  416 template<
typename ITER, 
typename ACCESS> 
inline 
  426     for (++begin; begin != end; ++begin)
 
  441 template<
typename ITER> 
inline PGSTD::string
 
  447 template<
typename OBJ> 
inline PGSTD::string
 
  453 template<
typename CONTAINER> 
inline PGSTD::string
 
  477 void PQXX_LIBEXPORT 
freepqmem(
const void *) 
throw ();
 
  490 #ifdef PQXX_HAVE_SHARED_PTR 
  493 template<
typename T, 
void (*DELETER)(T *) = freepqmem_templated<T> >
 
  498   PQAlloc() throw () : m_ptr() {}
 
  500   explicit PQAlloc(T *t) : m_ptr(t, DELETER) {}
 
  502   T *
get() 
const throw () { 
return m_ptr.get(); }
 
  509   T *
operator->() 
const throw () { 
return m_ptr.get(); }
 
  510   T &
operator*() 
const throw () { 
return *m_ptr; }
 
  511   void reset() throw () { m_ptr.reset(); }
 
  512   void swap(
PQAlloc &other) 
throw () { m_ptr.swap(other.m_ptr); }
 
  515   PQXXTR1::shared_ptr<T> m_ptr;
 
  518 #else // !PQXX_HAVE_SHARED_PTR 
  524   refcount *
volatile m_l, *
volatile m_r;
 
  534   bool loseref() 
throw ();
 
  558 template<
typename T, 
void (*DELETER)(T *) = freepqmem_templated<T> >
 
  575   explicit PQAlloc(T *obj) 
throw () : m_Obj(obj), m_rc() {}
 
  587   operator bool() 
const throw () { 
return m_Obj != 0; }
 
  597     if (!m_Obj) 
throw PGSTD::logic_error(
"Null pointer dereferenced");
 
  609   T *
get() 
const throw () { 
return m_Obj; }
 
  611   void reset() throw () { loseref(); }
 
  614   void makeref(T *p) 
throw () { m_Obj = p; }
 
  616   void makeref(
const PQAlloc &rhs) 
throw ()
 
  623   void loseref() throw ()
 
  625     if (m_rc.
loseref() && m_Obj) DELETER(m_Obj);
 
  629   void redoref(
const PQAlloc &rhs) 
throw ()
 
  630         { 
if (rhs.m_Obj != m_Obj) { loseref(); makeref(rhs); } }
 
  631   void redoref(T *obj) 
throw ()
 
  632         { 
if (obj != m_Obj) { loseref(); makeref(obj); } }
 
  635 #endif // PQXX_HAVE_SHARED_PTR 
  650   T *
get() 
const throw () { 
return m_ptr; }
 
  652   template<
typename INDEX> T &
operator[](INDEX i) 
const throw ()
 
  675   namedclass(
const PGSTD::string &Classname, 
const PGSTD::string &Name=
"") :
 
  676     m_Classname(Classname),
 
  681   const PGSTD::string &
name() 
const throw () { 
return m_Name; }         
 
  682   const PGSTD::string &
classname() 
const throw () {
return m_Classname;} 
 
  683   PGSTD::string description() 
const;
 
  686   PGSTD::string m_Classname, m_Name;
 
  698 template<
typename GUEST>
 
  704   GUEST *
get() 
const throw () { 
return m_Guest; }
 
  755 template<
typename T> 
inline PGSTD::ptrdiff_t 
distance(T first, T last)
 
  757 #ifdef PQXX_HAVE_DISTANCE 
  762   for (d=0; first != last; ++d) ++first;