basic_connection.hxx

#ifndef PQXX_H_BASIC_CONNECTION
#define PQXX_H_BASIC_CONNECTION

#include "pqxx/compiler-public.hxx"
#include "pqxx/compiler-internal-pre.hxx"

#include <cstddef>
#include <memory>
#include <string>

#include "pqxx/connection_base.hxx"


namespace pqxx
{


template<typename CONNECTPOLICY> class basic_connection_base :
  public connection_base
{
public:
  basic_connection_base() :
    connection_base(m_policy),
    m_options(std::string{}),
    m_policy(m_options)
        { init(); }

  explicit basic_connection_base(const std::string &opt) :
    connection_base(m_policy),
    m_options(opt),
    m_policy(m_options)
        {init();}

  explicit basic_connection_base(const char opt[]) :
    basic_connection_base(opt ? std::string{opt} : std::string{}) {}

  explicit basic_connection_base(std::nullptr_t) : basic_connection_base() {}

  ~basic_connection_base() noexcept
        { close(); }

  const std::string &options() const noexcept                           //[t01]
        {return m_policy.options();}

private:
  std::string m_options;
  CONNECTPOLICY m_policy;
};



template<typename CONNECTPOLICY> struct basic_connection :
        basic_connection_base<CONNECTPOLICY>
{
  PQXX_DEPRECATED basic_connection() =default;
  PQXX_DEPRECATED explicit basic_connection(const std::string &opt) :
        basic_connection(opt) {}
  PQXX_DEPRECATED explicit basic_connection(const char opt[]) :
        basic_connection(opt) {}

  PQXX_DEPRECATED explicit basic_connection(std::nullptr_t) :
        basic_connection() {}

  using basic_connection_base<CONNECTPOLICY>::options;
};

} // namespace

#include "pqxx/compiler-internal-post.hxx"

#endif