util.hxx

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 *   FILE
 *      pqxx/util.hxx
 *
 *   DESCRIPTION
 *      Various utility definitions for libpqxx
 *      DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/util instead.
 *
 * Copyright (c) 2001-2004, Jeroen T. Vermeulen <jtv@xs4all.nl>
 *
 * See COPYING for copyright license.  If you did not receive a file called
 * COPYING with this source code, please notify the distributor of this mistake,
 * or contact the author.
 *
 *-------------------------------------------------------------------------
 */
#include "pqxx/libcompiler.h"
#include "pqxx/config-public-libpq.h"

#include <cstdio>
#include <cctype>
#include <sstream>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <vector>


namespace pqxx {}

#ifdef PQXX_PQ_IN_NAMESPACE
// We want libpq in the pqxx::internal::pq namespace

namespace pqxx
{
namespace internal
{
namespace pq
{
#define PQXXPQ pqxx::internal::pq
extern "C"
{
#include "libpq-fe.h"
}
} // namespace pq
} // namespace internal
} // namespace pqxx

#else   // PQXX_PQ_IN_NAMESPACE
// We want libpq in the global namespace, with duplicates in pqxx::internal::pq

extern "C"
{
#include "libpq-fe.h"
}

namespace pqxx
{
namespace internal
{
namespace pq
{
#define PQXXPQ
typedef PQXXPQ::PGconn PGconn;
typedef PQXXPQ::PGresult PGresult;

} // namespace pq
} // namespace internal
} // namespace pqxx

#endif  // PQXX_PQ_IN_NAMESPACE


namespace pqxx
{
typedef PQXXPQ::Oid oid;

const oid oid_none = 0;


template<typename T> void error_unsupported_type_in_string_conversion(T);



template<typename T> PGSTD::string error_ambiguous_string_conversion(T);



// TODO: Implement date conversions


template<typename T> void from_string(const char Str[], T &Obj);

template<> void from_string(const char Str[], long &);                  //[t45]
template<> void from_string(const char Str[], unsigned long &);         //[t45]
template<> void from_string(const char Str[], int &);                   //[t45]
template<> void from_string(const char Str[], unsigned int &);          //[t45]
template<> void from_string(const char Str[], short &);                 //[t45]
template<> void from_string(const char Str[], unsigned short &);        //[t45]
template<> void from_string(const char Str[], float &);                 //[t46]
template<> void from_string(const char Str[], double &);                //[t46]
template<> void from_string(const char Str[], bool &);                  //[t76]
#if defined(PQXX_HAVE_LONG_DOUBLE)
template<> void from_string(const char Str[], long double &);           //[t46]
#endif


template<> inline void from_string(const char Str[],PGSTD::string &Obj) //[t46]
        { Obj = Str; }

template<> 
  inline void from_string(const char Str[], PGSTD::stringstream &Obj)   //[t0]
        { Obj.clear(); Obj << Str; }

template<typename T> 
  inline void from_string(const PGSTD::string &Str, T &Obj)             //[t45]
        { from_string(Str.c_str(), Obj); }

template<typename T>
  inline void from_string(const PGSTD::stringstream &Str, T &Obj)       //[t0]
        { from_string(Str.str(), Obj); }

template<> inline void 
from_string(const PGSTD::string &Str, PGSTD::string &Obj)               //[t46]
        { Obj = Str; }

template<> inline void
from_string(const PGSTD::string &, const char &Obj)
        { error_ambiguous_string_conversion(Obj); }
template<> inline void
from_string(const PGSTD::string &, const signed char &Obj)
        { error_ambiguous_string_conversion(Obj); }
template<> inline void
from_string(const PGSTD::string &, const unsigned char &Obj)
        { error_ambiguous_string_conversion(Obj); }



template<typename T> PGSTD::string to_string(const T &);

template<> PGSTD::string to_string(const short &);                      //[t76]
template<> PGSTD::string to_string(const unsigned short &);             //[t76]
template<> PGSTD::string to_string(const int &);                        //[t10]
template<> PGSTD::string to_string(const unsigned int &);               //[t13]
template<> PGSTD::string to_string(const long &);                       //[t18]
template<> PGSTD::string to_string(const unsigned long &);              //[t20]
template<> PGSTD::string to_string(const float &);                      //[t74]
template<> PGSTD::string to_string(const double &);                     //[t74]
template<> PGSTD::string to_string(const bool &);                       //[t76]
#if defined(PQXX_HAVE_LONG_DOUBLE)
template<> PGSTD::string to_string(const long double &);                //[t74]
#endif

inline PGSTD::string to_string(const char Obj[])                        //[t14]
        { return PGSTD::string(Obj); }

inline PGSTD::string to_string(const PGSTD::stringstream &Obj)          //[t0]
        { return Obj.str(); }

inline PGSTD::string to_string(const PGSTD::string &Obj) {return Obj;}  //[t21]

template<> PGSTD::string to_string(const char &);                       //[t21]


template<> inline PGSTD::string to_string(const signed char &Obj)
        { return error_ambiguous_string_conversion(Obj); }
template<> inline PGSTD::string to_string(const unsigned char &Obj)
        { return error_ambiguous_string_conversion(Obj); }



template<typename T=PGSTD::string, typename CONT=PGSTD::vector<T> >
class items : public CONT
{
public:
  items() : CONT() {}                                                   //[t80]
  explicit items(const T &t) : CONT() { push_back(t); }                 //[t0]
  items(const T &t1, const T &t2) : CONT()                              //[t80]
        { push_back(t1); push_back(t2); }
  items(const T &t1, const T &t2, const T &t3) : CONT()                 //[t0]
        { push_back(t1); push_back(t2); push_back(t3); }
  items(const T &t1, const T &t2, const T &t3, const T &t4) : CONT()    //[t0]
        { push_back(t1); push_back(t2); push_back(t3); push_back(t4); }
  items(const T&t1,const T&t2,const T&t3,const T&t4,const T&t5):CONT()  //[t0]
        {push_back(t1);push_back(t2);push_back(t3);push_back(t4);push_back(t5);}
  items(const CONT &c) : CONT(c) {}                                     //[t0]

  items &operator()(const T &t)                                         //[t80]
  {
    push_back(t);
    return *this;
  }
};


// TODO: Generalize--add transformation functor
template<typename ITER> inline
PGSTD::string separated_list(const PGSTD::string &sep,
    ITER begin,
    ITER end)                                                           //[t8]
{
  PGSTD::string result;
  if (begin != end)
  {
    result = to_string(*begin);
    for (++begin; begin != end; ++begin)
    {
      result += sep;
      result += to_string(*begin);
    }
  }
  return result;
}

template<typename CONTAINER> inline
PGSTD::string separated_list(const PGSTD::string &sep,
    const CONTAINER &c)                                                 //[t10]
{
  return separated_list(sep, c.begin(), c.end());
}



namespace internal
{
typedef unsigned long result_size_type;
typedef long result_difference_type;


template<typename T> inline const char *FmtString(T t)
{
  error_unsupported_type_in_string_conversion(t);
  return 0;
}

template<> inline const char *FmtString(short)         { return "%hd"; }
template<> inline const char *FmtString(unsigned short){ return "%hu"; }
template<> inline const char *FmtString(int)           { return  "%i"; }
template<> inline const char *FmtString(long)          { return "%li"; }
template<> inline const char *FmtString(unsigned)      { return  "%u"; }
template<> inline const char *FmtString(unsigned long) { return "%lu"; }
template<> inline const char *FmtString(float)         { return  "%f"; }
template<> inline const char *FmtString(double)        { return "%lf"; }
template<> inline const char *FmtString(char)          { return  "%c"; }
template<> inline const char *FmtString(unsigned char) { return  "%c"; }
#if defined(PQXX_HAVE_LONG_DOUBLE)
template<> inline const char *FmtString(long double)   { return "%Lf"; }
#endif

} // namespace internal


template<typename T> inline PGSTD::string ToString(const T &Obj)
{
  // TODO: Find a decent way to determine max string length at compile time!
  char Buf[500];
  sprintf(Buf, internal::FmtString(Obj), Obj);
  return PGSTD::string(Buf);
}


template<> inline PGSTD::string ToString(const PGSTD::string &Obj) {return Obj;}
template<> inline PGSTD::string ToString(const char *const &Obj) { return Obj; }
template<> inline PGSTD::string ToString(char *const &Obj) { return Obj; }

template<> inline PGSTD::string ToString(const unsigned char *const &Obj)
{
  return reinterpret_cast<const char *>(Obj);
}

template<> inline PGSTD::string ToString(const bool &Obj) 
{ 
  return ToString(unsigned(Obj));
}

template<> inline PGSTD::string ToString(const short &Obj)
{
  return ToString(int(Obj));
}

template<> inline PGSTD::string ToString(const unsigned short &Obj)
{
  return ToString(unsigned(Obj));
}



template<typename T> inline void FromString(const char Str[], T &Obj)
{
  if (!Str) throw PGSTD::runtime_error("Attempt to convert NULL string to " +
                                     PGSTD::string(typeid(T).name()));

  if (sscanf(Str, internal::FmtString(Obj), &Obj) != 1)
    throw PGSTD::runtime_error("Cannot convert value '" + 
                             PGSTD::string(Str) + 
                             "' to " + typeid(T).name());
}


namespace internal
{

void PQXX_LIBEXPORT FromString_string(const char Str[], PGSTD::string &Obj);


void PQXX_LIBEXPORT FromString_ucharptr(const char Str[], 
        const unsigned char *&Obj);

PGSTD::string PQXX_LIBEXPORT Quote_string(const PGSTD::string &Obj, 
        bool EmptyIsNull);

PGSTD::string PQXX_LIBEXPORT Quote_charptr(const char Obj[], bool EmptyIsNull);
} // namespace internal


template<> inline void FromString(const char Str[], PGSTD::string &Obj)
{
  internal::FromString_string(Str, Obj);
}

template<> inline void FromString(const char Str[], const char *&Obj)
{
  if (!Str) throw PGSTD::runtime_error("Attempt to read NULL string");
  Obj = Str;
}

template<> inline void FromString(const char Str[], const unsigned char *&Obj)
{
  internal::FromString_ucharptr(Str, Obj);
}

template<> inline void FromString(const char Str[], bool &Obj)
{
  from_string(Str, Obj);
}



PGSTD::string sqlesc(const char str[]);                                 //[t0]


PGSTD::string sqlesc(const char str[], size_t maxlen);                  //[t0]


PGSTD::string sqlesc(const PGSTD::string &);                            //[t0]



template<typename T> PGSTD::string Quote(const T &Obj, bool EmptyIsNull);



template<> 
inline PGSTD::string Quote(const PGSTD::string &Obj, bool EmptyIsNull)
{
  return internal::Quote_string(Obj, EmptyIsNull);
}


template<> inline PGSTD::string Quote(const char *const & Obj, bool EmptyIsNull)
{
  return internal::Quote_charptr(Obj, EmptyIsNull);
}



template<int LEN> inline PGSTD::string Quote(const char (&Obj)[LEN],
                                             bool EmptyIsNull)
{
  return internal::Quote_charptr(Obj, EmptyIsNull);
}


template<typename T> inline PGSTD::string Quote(const T &Obj, bool EmptyIsNull)
{
  return Quote(ToString(Obj), EmptyIsNull);
}



template<typename T> inline PGSTD::string Quote(T Obj)
{
  return Quote(Obj, false);
}


namespace internal
{
void freepqmem(void *);
void freenotif(PQXXPQ::PGnotify *);


template<typename T> class PQAlloc
{
  T *m_Obj;
  mutable const PQAlloc *m_l, *m_r;
public:
  typedef T content_type;

  PQAlloc() throw () : m_Obj(0), m_l(this), m_r(this) {}
  PQAlloc(const PQAlloc &rhs) throw () :
    m_Obj(0), m_l(this), m_r(this) { makeref(rhs); }
  ~PQAlloc() throw () { loseref(); }

  PQAlloc &operator=(const PQAlloc &rhs) throw () 
        { if (&rhs != this) { loseref(); makeref(rhs); } return *this; }


  explicit PQAlloc(T *obj) throw () : m_Obj(obj), m_l(this), m_r(this) {}

  void swap(PQAlloc &rhs) throw ()
  {
    PQAlloc tmp(*this);
    *this = rhs;
    rhs = tmp;
  }

  PQAlloc &operator=(T *obj) throw () { loseref(); makeref(obj); return *this; }

  operator bool() const throw () { return m_Obj != 0; }

  bool operator!() const throw () { return !m_Obj; }


  T *operator->() const throw (PGSTD::logic_error)
  {
    if (!m_Obj) throw PGSTD::logic_error("Null pointer dereferenced");
    return m_Obj;
  }


  T &operator*() const throw (PGSTD::logic_error) { return *operator->(); }


  T *c_ptr() const throw () { return m_Obj; }

  void clear() throw () { loseref(); }

private:
  void makeref(T *p) throw () { m_Obj = p; }

  void makeref(const PQAlloc &rhs) throw ()
  {
    m_l = &rhs;
    m_r = rhs.m_r;
    m_l->m_r = m_r->m_l = this;
    m_Obj = rhs.m_Obj;
  }

  void loseref() throw ()
  {
    if (m_l == this && m_Obj) freemem();
    m_Obj = 0;
    m_l->m_r = m_r;
    m_r->m_l = m_l;
    m_l = m_r = this;
  }

  void freemem() throw () { freepqmem(m_Obj); }
};


template<> inline void PQAlloc<PQXXPQ::PGresult>::freemem() throw ()
        { PQclear(m_Obj); }
template<> inline void PQAlloc<PQXXPQ::PGnotify>::freemem() throw ()
        { freenotif(m_Obj); }


class PQXX_LIBEXPORT namedclass
{
public:
  namedclass(const PGSTD::string &Name, const PGSTD::string &Classname) :
    m_Name(Name),
    m_Classname(Classname)
  {
  }

  const PGSTD::string &name() const throw () { return m_Name; }         //[t1]
  const PGSTD::string &classname() const throw () {return m_Classname;} //[t73]
  PGSTD::string description() const;

private:
  PGSTD::string m_Name, m_Classname;
};


void CheckUniqueRegistration(const namedclass *New, const namedclass *Old);
void CheckUniqueUnregistration(const namedclass *New, const namedclass *Old);



template<typename GUEST>
class unique
{
public:
  unique() : m_Guest(0) {}

  GUEST *get() const throw () { return m_Guest; }

  void Register(GUEST *G)
  {
    CheckUniqueRegistration(G, m_Guest);
    m_Guest = G;
  }

  void Unregister(GUEST *G)
  {
    CheckUniqueUnregistration(G, m_Guest);
    m_Guest = 0;
  }

private:
  GUEST *m_Guest;

  unique(const unique &);
  unique &operator=(const unique &);
};

void sleep_seconds(int);

} // namespace internal
} // namespace pqxx

---