transaction_focus.hxx

Go to the documentation of this file.

 
#ifndef PQXX_TRANSACTION_FOCUS_HXX
#define PQXX_TRANSACTION_FOCUS_HXX
 
#if !defined(PQXX_HEADER_PRE)
#  error "Include libpqxx headers as <pqxx/header>, not <pqxx/header.hxx>."
#endif
 
#include "pqxx/util.hxx"
 
namespace pqxx
{
 
class PQXX_LIBEXPORT transaction_focus
{
public:
#include "pqxx/internal/ignore-deprecated-pre.hxx"
 
  transaction_focus(
    transaction_base &t, std::string_view cname, std::string_view oname) :
          m_trans{&t}, m_classname{cname}, m_name{oname}
  {}
 
  transaction_focus(
    transaction_base &t, std::string_view cname, std::string &&oname) :
          m_trans{&t}, m_classname{cname}, m_name{std::move(oname)}
  {}
 
  transaction_focus(transaction_base &t, std::string_view cname) :
          m_trans{&t}, m_classname{cname}
  {}
 
#include "pqxx/internal/ignore-deprecated-post.hxx"
 
  transaction_focus() = delete;
  transaction_focus(transaction_focus const &) = delete;
  transaction_focus &operator=(transaction_focus const &) = delete;
  ~transaction_focus() = default;
 
  [[nodiscard]] constexpr std::string_view classname() const noexcept
  {
    return m_classname;
  }
 
  [[nodiscard]] std::string_view name() const & noexcept { return m_name; }
 
  [[nodiscard]] std::string description() const
  {
    return pqxx::internal::describe_object(m_classname, m_name);
  }
 
#include "pqxx/internal/ignore-deprecated-pre.hxx"
  transaction_focus(transaction_focus &&other) :
          m_trans{other.m_trans},
          m_classname{other.m_classname},
          m_registered{other.m_registered}
  {
    // This is a bit more complicated than you might expect.  The transaction
    // has a backpointer to the focus, and we need to transfer that to the new
    // focus.
    move_name_and_registration(other);
  }
 
  transaction_focus &operator=(transaction_focus &&other)
  {
    if (&other != this)
    {
      if (m_registered)
        unregister_me();
      m_trans = other.m_trans;
      m_classname = other.m_classname;
      move_name_and_registration(other);
    }
    return *this;
  }
#include "pqxx/internal/ignore-deprecated-post.hxx"
 
protected:
  void register_me();
  void unregister_me() noexcept;
  void reg_pending_error(std::string const &, sl) noexcept;
  [[nodiscard]] bool registered() const noexcept { return m_registered; }
 
#include "pqxx/internal/ignore-deprecated-pre.hxx"
  [[nodiscard]] transaction_base &trans() noexcept { return *m_trans; }
  [[nodiscard]] transaction_base const &trans() const noexcept
  {
    return *m_trans;
  }
#include "pqxx/internal/ignore-deprecated-post.hxx"
 
  // NOLINTBEGIN(
  //    cppcoreguidelines-non-private-member-variables-in-classes,
  //    misc-non-private-member-variables-in-classes
  // )
  [[deprecated(
    "This will become private.  Use trans() instead.")]] transaction_base
    *m_trans;
  // NOLINTEND(
  //    cppcoreguidelines-non-private-member-variables-in-classes,
  //    misc-non-private-member-variables-in-classes
  // )
 
private:
  void move_name_and_registration(transaction_focus &other)
  {
    bool const reg{other.m_registered};
    // Unregister the original while it still owns its name.
    if (reg)
      other.unregister_me();
    // Now!  Quick!  Steal that name.
    m_name = std::move(other.m_name);
    // Now that we own the name, register ourselves instead.
    if (reg)
      this->register_me();
  }
 
  std::string_view m_classname;
  std::string m_name;
  bool m_registered = false;
};
} // namespace pqxx
#endif