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 <type_traits>
#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 auto
separated_list(const std::string &sep, const CONTAINER &c)              //[t10]
        /*
        Always std::string; necessary because SFINAE doesn't work with the
        contents of function bodies, so the check for iterability has to be in
        the signature.
        */
        -> typename std::enable_if<
                (
                        not std::is_void<decltype(std::begin(c))>::value
                        and not std::is_void<decltype(std::end(c))>::value
                ),
                std::string
        >::type
{
  return separated_list(sep, std::begin(c), std::end(c));
}


template<
        typename TUPLE,
        std::size_t INDEX=0,
        typename ACCESS,
        typename std::enable_if<
                (INDEX == std::tuple_size<TUPLE>::value-1),
                int
        >::type=0
>
inline std::string
separated_list(
        const std::string & /* sep */,
        const TUPLE &t,
        const ACCESS& access
)
{
  return to_string(access(&std::get<INDEX>(t)));
}

template<
        typename TUPLE,
        std::size_t INDEX=0,
        typename ACCESS,
        typename std::enable_if<
                (INDEX < std::tuple_size<TUPLE>::value-1),
                int
        >::type=0
>
inline std::string
separated_list(const std::string &sep, const TUPLE &t, const ACCESS& access)
{
  return
        to_string(access(&std::get<INDEX>(t))) +
        sep +
        separated_list<TUPLE, INDEX+1>(sep, t, access);
}

template<
        typename TUPLE,
        std::size_t INDEX=0,
        typename std::enable_if<
                (INDEX <= std::tuple_size<TUPLE>::value),
                int
        >::type=0
>
inline std::string
separated_list(const std::string &sep, const TUPLE &t)
{
  return separated_list(sep, t, [](const TUPLE &tup){return *tup;});
}



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);

} // namespace internal
} // namespace pqxx

#endif