util.hxx

#ifndef PQXX_H_UTIL
#define PQXX_H_UTIL

#include "pqxx/compiler-public.hxx"

#include <cstdio>
#include <cctype>
#include <iterator>
#include <memory>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <vector>

#include "pqxx/strconv.hxx"


namespace pqxx {}

#include <pqxx/internal/libpq-forward.hxx>


namespace pqxx
{
template<typename T> inline void ignore_unused(T) {}


struct PQXX_LIBEXPORT thread_safety_model
{
  bool have_safe_strerror = true;


  bool safe_libpq;

  bool safe_query_cancel = true;

  bool safe_result_copy = true;


  bool safe_kerberos;

  std::string description;
};


PQXX_LIBEXPORT thread_safety_model describe_thread_safety() noexcept;


constexpr oid oid_none = 0;




template<typename ITER, typename ACCESS> inline
std::string separated_list(                                             //[t00]
        const std::string &sep,
        ITER begin,
        ITER end,
        ACCESS access)
{
  std::string result;
  if (begin != end)
  {
    result = to_string(access(begin));
    for (++begin; begin != end; ++begin)
    {
      result += sep;
      result += to_string(access(begin));
    }
  }
  return result;
}


template<typename ITER> inline std::string
separated_list(const std::string &sep, ITER begin, ITER end)            //[t00]
        { return separated_list(sep, begin, end, [](ITER i){ return *i; }); }


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



namespace internal
{
PQXX_LIBEXPORT void freepqmem(const void *) noexcept;
template<typename P> inline void freepqmem_templated(P *p) noexcept
{
  freepqmem(p);
}

PQXX_LIBEXPORT void freemallocmem(const void *) noexcept;
template<typename P> inline void freemallocmem_templated(P *p) noexcept
{
  freemallocmem(p);
}



class PQXX_LIBEXPORT namedclass
{
public:
  explicit namedclass(const std::string &Classname) :
    m_classname(Classname),
    m_name()
  {
  }

  namedclass(const std::string &Classname, const std::string &Name) :
    m_classname(Classname),
    m_name(Name)
  {
  }

  const std::string &name() const noexcept { return m_name; }           //[t01]

  const std::string &classname() const noexcept                         //[t73]
        { return m_classname; }

  std::string description() const;

private:
  std::string m_classname, m_name;
};


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



template<typename GUEST>
class unique
{
public:
  unique() =default;
  unique(const unique &) =delete;
  unique &operator=(const unique &) =delete;

  GUEST *get() const noexcept { return m_guest; }

  void register_guest(GUEST *G)
  {
    CheckUniqueRegistration(G, m_guest);
    m_guest = G;
  }

  void unregister_guest(GUEST *G)
  {
    CheckUniqueUnregistration(G, m_guest);
    m_guest = nullptr;
  }

private:
  GUEST *m_guest = nullptr;
};



PQXX_LIBEXPORT void sleep_seconds(int);

using cstring = const char *;


constexpr char
        sql_begin_work[] = "BEGIN",
        sql_commit_work[] = "COMMIT",
        sql_rollback_work[] = "ROLLBACK";

} // namespace internal
} // namespace pqxx

#endif