EIC code displayed by LXR master/​include/​boost/​mysql/​connection_pool.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

Warning, file /include/boost/mysql/connection_pool.hpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 //
 // Copyright (c) 2019-2025 Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
 #ifndef BOOST_MYSQL_CONNECTION_POOL_HPP
 #define BOOST_MYSQL_CONNECTION_POOL_HPP
 
 #include <boost/mysql/any_connection.hpp>
 #include <boost/mysql/diagnostics.hpp>
 #include <boost/mysql/error_code.hpp>
 #include <boost/mysql/pool_params.hpp>
 #include <boost/mysql/with_diagnostics.hpp>
 
 #include <boost/mysql/detail/access.hpp>
 #include <boost/mysql/detail/config.hpp>
 #include <boost/mysql/detail/connection_pool_fwd.hpp>
 #include <boost/mysql/detail/initiation_base.hpp>
 
 #include <boost/asio/any_completion_handler.hpp>
 #include <boost/asio/any_io_executor.hpp>
 #include <boost/asio/async_result.hpp>
 
 #include <chrono>
 #include <memory>
 #include <utility>
 
 namespace boost {
 namespace mysql {
 
 /**
  * \brief A proxy to a connection owned by a pool that returns it to the pool when destroyed.
  * \details
  * A `pooled_connection` behaves like to a `std::unique_ptr`: it has exclusive ownership of an
  * \ref any_connection created by the pool. When destroyed, it returns the connection to the pool.
  * A `pooled_connection` may own nothing. We say such a connection is invalid (`this->valid() == false`).
  *
  * This class is movable but not copyable.
  *
  * \par Object lifetimes
  * While `*this` is alive, the \ref connection_pool internal data will be kept alive
  * automatically. It's safe to destroy the `connection_pool` object before `*this`.
  *
  * \par Thread safety
  * This object and the \ref any_connection object it may point to are **not thread safe**,
  * even if the connection pool used to obtain them was constructed with
  * \ref pool_params::thread_safe set to true.
  *
  * Functions that return the underlying connection to the pool
  * cause a mutation on the pool state object. Calling such functions
  * on objects obtained from the same pool
  * is thread-safe only if the pool was constructed with \ref pool_params::thread_safe set to true.
  *
  * In other words, individual connections can't be shared between threads. Pools can
  * be shared only if they're constructed with \ref pool_params::thread_safe set to true.
  *
  * - Distinct objects: safe if the \ref connection_pool that was used to obtain the objects
  *   was created with \ref pool_params::thread_safe set to true. Otherwise, unsafe.
  * - Shared objects: always unsafe.
  */
 class pooled_connection
 {
 #ifndef BOOST_MYSQL_DOXYGEN
     friend struct detail::access;
     friend class detail::basic_pool_impl<any_connection, std::chrono::steady_clock, pooled_connection>;
 #endif
 
     struct impl_t
     {
         detail::connection_node* node;
         std::shared_ptr<detail::pool_impl> pool;
     } impl_{};
 
     pooled_connection(detail::connection_node& node, std::shared_ptr<detail::pool_impl> pool_impl) noexcept
         : impl_{&node, std::move(pool_impl)}
     {
         BOOST_ASSERT(impl_.pool);
     }
 
 public:
     /**
      * \brief Constructs an invalid pooled connection.
      * \details
      * The resulting object is invalid (`this->valid() == false`).
      *
      * \par Exception safety
      * No-throw guarantee.
      */
     pooled_connection() noexcept = default;
 
     /**
      * \brief Move constructor.
      * \details
      * Transfers connection ownership from `other` to `*this`.
      *
      * After this function returns, if `other.valid() == true`, `this->valid() == true`.
      * In any case, `other` will become invalid (`other.valid() == false`).
      *
      * \par Exception safety
      * No-throw guarantee.
      */
     pooled_connection(pooled_connection&& other) noexcept : impl_(std::move(other.impl_)) {}
 
     /**
      * \brief Move assignment.
      * \details
      * If `this->valid()`, returns the connection owned by `*this` to the pool and marks
      * it as pending reset (as if the destructor was called).
      * It then transfers connection ownership from `other` to `*this`.
      *
      * After this function returns, if `other.valid() == true`, `this->valid() == true`.
      * In any case, `other` will become invalid (`other.valid() == false`).
      *
      * \par Thread-safety
      * May cause a mutation on the connection pool that `this` points to.
      * Thread-safe for a shared pool only if it was constructed with
      * \ref pool_params::thread_safe set to true.
      *
      * \par Exception safety
      * No-throw guarantee.
      */
     pooled_connection& operator=(pooled_connection&& other) noexcept
     {
         if (valid())
         {
             detail::return_connection(*impl_.pool, *impl_.node, true);
         }
         impl_ = std::move(other.impl_);
         return *this;
     }
 
 #ifndef BOOST_MYSQL_DOXYGEN
     pooled_connection(const pooled_connection&) = delete;
     pooled_connection& operator=(const pooled_connection&) = delete;
 #endif
 
     /**
      * \brief Destructor.
      * \details
      * If `this->valid() == true`, returns the owned connection to the pool
      * and marks it as pending reset. If your connection doesn't need to be reset
      * (e.g. because you didn't mutate session state), use \ref return_without_reset.
      *
      * \par Thread-safety
      * May cause a mutation on the connection pool that `this` points to.
      * Thread-safe for a shared pool only if it was constructed with
      * \ref pool_params::thread_safe set to true.
      */
     ~pooled_connection()
     {
         if (valid())
             detail::return_connection(*impl_.pool, *impl_.node, true);
     }
 
     /**
      * \brief Returns whether the object owns a connection or not.
      * \par Exception safety
      * No-throw guarantee.
      */
     bool valid() const noexcept { return impl_.pool.get() != nullptr; }
 
     /**
      * \brief Retrieves the connection owned by this object.
      * \par Preconditions
      * The object should own a connection (`this->valid() == true`).
      *
      * \par Object lifetimes
      * The returned reference is valid as long as `*this` or an object
      * move-constructed or move-assigned from `*this` is alive.
      *
      * \par Exception safety
      * No-throw guarantee.
      */
     any_connection& get() noexcept { return detail::get_connection(*impl_.node); }
 
     /// \copydoc get
     const any_connection& get() const noexcept { return detail::get_connection(*impl_.node); }
 
     /// \copydoc get
     any_connection* operator->() noexcept { return &get(); }
 
     /// \copydoc get
     const any_connection* operator->() const noexcept { return &get(); }
 
     /**
      * \brief Returns the owned connection to the pool and marks it as not requiring reset.
      * \details
      * Returns a connection to the pool and marks it as idle. This will
      * skip the \ref any_connection::async_reset_connection call to wipe session state.
      * \n
      * This can provide a performance gain, but must be used with care. Failing to wipe
      * session state can lead to resource leaks (prepared statements not being released),
      * incorrect results and vulnerabilities (different logical operations interacting due
      * to leftover state).
      * \n
      * Please read the documentation on \ref any_connection::async_reset_connection before
      * calling this function. If in doubt, don't use it, and leave the destructor return
      * the connection to the pool for you.
      * \n
      * When this function returns, `*this` will own nothing (`this->valid() == false`).
      *
      * \par Preconditions
      * `this->valid() == true`
      *
      * \par Exception safety
      * No-throw guarantee.
      *
      * \par Thread-safety
      * Causes a mutation on the connection pool that `this` points to.
      * Thread-safe for a shared pool only if it was constructed with
      * \ref pool_params::thread_safe set to true.
      */
     void return_without_reset() noexcept
     {
         BOOST_ASSERT(valid());
         detail::return_connection(*impl_.pool, *impl_.node, false);
         impl_ = impl_t{};
     }
 };
 
 /**
  * \brief A pool of connections of variable size.
  * \details
  * A connection pool creates and manages \ref any_connection objects.
  * Using a pool allows to reuse sessions, avoiding part of the overhead associated
  * to session establishment. It also features built-in error handling and reconnection.
  * See the discussion and examples for more details on when to use this class.
  *
  * Connections are retrieved by \ref async_get_connection, which yields a
  * \ref pooled_connection object. They are returned to the pool when the
  * `pooled_connection` is destroyed, or by calling \ref pooled_connection::return_without_reset.
  *
  * A pool needs to be run before it can return any connection. Use \ref async_run for this.
  * Pools can only be run once.
  *
  * Connections are created, connected and managed internally by the pool, following
  * a well-defined state model. Please refer to the discussion for details.
  *
  * Due to oddities in Boost.Asio's universal async model, this class only
  * exposes async functions. You can use `asio::use_future` to transform them
  * into sync functions (please read the discussion for details).
  *
  * This is a move-only type.
  *
  * \par Default completion tokens
  * The default completion token for all async operations in this class is
  * `with_diagnostics(asio::deferred)`, which allows you to use `co_await`
  * and have the expected exceptions thrown on error.
  *
  * \par Thread-safety
  * Pools are composed of an internal state object, plus a handle to such state.
  * Each component has different thread-safety rules.
  *
  * Regarding **internal state**, connection pools are **not thread-safe by default**,
  * but can be made safe by constructing them with
  * \ref pool_params::thread_safe set to `true`.
  * Internal state is also mutated by some functions outside `connection_pool`, like
  * returning connections.
  *
  * The following actions imply a pool state mutation, and are protected by a strand
  * when thread-safety is enabled:
  *
  * - Calling \ref connection_pool::async_run.
  * - Calling \ref connection_pool::async_get_connection.
  * - Cancelling \ref async_get_connection by emitting a cancellation signal.
  * - Returning a connection by destroying a \ref pooled_connection or
  *   calling \ref pooled_connection::return_without_reset.
  * - Cancelling the pool by calling \ref connection_pool::cancel,
  *   emitting a cancellation signal for \ref async_run, or destroying the
  *   `connection_pool` object.
  *
  * The **handle to the pool state** is **never thread-safe**, even for
  * pools with thread-safety enabled. Functions like assignments
  * modify the handle, and cause race conditions if called
  * concurrently with other functions. Other objects,
  * like \ref pooled_connection, have their own state handle,
  * and thus interact only with the pool state.
  *
  * If configured to be thread-safe, the protection applies only to the pool's state.
  * In particular, be careful when using `asio::cancel_after` and similar tokens.
  * Please read
  * <a href="../connection_pool.html#mysql.connection_pool.thread_safe">this page</a> for more info.
  *
  * In summary:
  *
  * - Distinct objects: safe. \n
  * - Shared objects: unsafe. Setting \ref pool_params::thread_safe
  *   to `true` makes some functions safe.
  *
  * \par Object lifetimes
  * Connection pool objects create an internal state object that is referenced
  * by other objects and operations (like \ref pooled_connection). This object
  * will be kept alive using shared ownership semantics even after the `connection_pool`
  * object is destroyed. This results in intuitive lifetime rules.
  */
 class connection_pool
 {
     std::shared_ptr<detail::pool_impl> impl_;
 
 #ifndef BOOST_MYSQL_DOXYGEN
     friend struct detail::access;
 #endif
 
     struct initiate_run : detail::initiation_base
     {
         using detail::initiation_base::initiation_base;
 
         // Having diagnostics* here makes async_run compatible with with_diagnostics
         template <class Handler>
         void operator()(Handler&& h, diagnostics*, std::shared_ptr<detail::pool_impl> self)
         {
             async_run_erased(std::move(self), std::forward<Handler>(h));
         }
     };
 
     BOOST_MYSQL_DECL
     static void async_run_erased(
         std::shared_ptr<detail::pool_impl> pool,
         asio::any_completion_handler<void(error_code)> handler
     );
 
     struct initiate_get_connection : detail::initiation_base
     {
         using detail::initiation_base::initiation_base;
 
         template <class Handler>
         void operator()(Handler&& h, diagnostics* diag, std::shared_ptr<detail::pool_impl> self)
         {
             async_get_connection_erased(std::move(self), diag, std::forward<Handler>(h));
         }
     };
 
     BOOST_MYSQL_DECL
     static void async_get_connection_erased(
         std::shared_ptr<detail::pool_impl> pool,
         diagnostics* diag,
         asio::any_completion_handler<void(error_code, pooled_connection)> handler
     );
 
     template <class CompletionToken>
     auto async_get_connection_impl(diagnostics* diag, CompletionToken&& token)
         -> decltype(asio::async_initiate<CompletionToken, void(error_code, pooled_connection)>(
             std::declval<initiate_get_connection>(),
             token,
             diag,
             impl_
         ))
     {
         BOOST_ASSERT(valid());
         return asio::async_initiate<CompletionToken, void(error_code, pooled_connection)>(
             initiate_get_connection{get_executor()},
             token,
             diag,
             impl_
         );
     }
 
     BOOST_MYSQL_DECL
     connection_pool(asio::any_io_executor ex, pool_params&& params, int);
 
 public:
     /**
      * \brief Constructs a connection pool.
      * \details
      *
      * The pool is created in a "not-running" state. Call \ref async_run to transition to the
      * "running" state.
      *
      * The constructed pool is always valid (`this->valid() == true`).
      *
      * \par Executor
      * The passed executor becomes the pool executor, available through \ref get_executor.
      * `ex` is used as follows:
      *
      *   - If `params.thread_safe == true`, `ex` is used to build a strand. The strand is used
      *     to build internal I/O objects, like timers.
      *   - If `params.thread_safe == false`, `ex` is used directly to build internal I/O objects.
      *   - If `params.connection_executor` is empty, `ex` is used to build individual connections,
      *     regardless of the chosen thread-safety mode. Otherwise, `params.connection_executor`
      *     is used.
      *
      * \par Exception safety
      * Strong guarantee. Exceptions may be thrown by memory allocations.
      * \throws std::invalid_argument If `params` contains values that violate the rules described in \ref
      *         pool_params.
      */
     connection_pool(asio::any_io_executor ex, pool_params params)
         : connection_pool(std::move(ex), std::move(params), 0)
     {
     }
 
     /**
      * \brief Constructs a connection pool.
      * \details
      * Equivalent to `connection_pool(ctx.get_executor(), params)`.
      *
      * This function participates in overload resolution only if `ExecutionContext`
      * satisfies the `ExecutionContext` requirements imposed by Boost.Asio.
      *
      * \par Exception safety
      * Strong guarantee. Exceptions may be thrown by memory allocations.
      * \throws std::invalid_argument If `params` contains values that violate the rules described in \ref
      *         pool_params.
      */
     template <
         class ExecutionContext
 #ifndef BOOST_MYSQL_DOXYGEN
         ,
         class = typename std::enable_if<std::is_convertible<
             decltype(std::declval<ExecutionContext&>().get_executor()),
             asio::any_io_executor>::value>::type
 #endif
         >
     connection_pool(ExecutionContext& ctx, pool_params params)
         : connection_pool(ctx.get_executor(), std::move(params), 0)
     {
     }
 
 #ifndef BOOST_MYSQL_DOXYGEN
     connection_pool(const connection_pool&) = delete;
     connection_pool& operator=(const connection_pool&) = delete;
 #endif
 
     /**
      * \brief Move-constructor.
      * \details
      * Constructs a connection pool by taking ownership of `other`.
      *
      * After this function returns, if `other.valid() == true`, `this->valid() == true`.
      * In any case, `other` will become invalid (`other.valid() == false`).
      *
      * Moving a connection pool with outstanding async operations
      * is safe.
      *
      * \par Exception safety
      * No-throw guarantee.
      *
      * \par Thread-safety
      * Mutates `other`'s internal state handle. Does not access the pool state.
      * This function **can never be called concurrently with other functions
      * that read the internal state handle**, even for pools created
      * with \ref pool_params::thread_safe set to true.
      *
      * The internal pool state is not accessed, so this function can be called
      * concurrently with functions that only access the pool's internal state,
      * like returning connections.
      */
     connection_pool(connection_pool&& other) = default;
 
     /**
      * \brief Move assignment.
      * \details
      * Assigns `other` to `*this`, transferring ownership.
      *
      * After this function returns, if `other.valid() == true`, `this->valid() == true`.
      * In any case, `other` will become invalid (`other.valid() == false`).
      *
      * Moving a connection pool with outstanding async operations
      * is safe.
      *
      * \par Exception safety
      * No-throw guarantee.
      *
      * \par Thread-safety
      * Mutates `*this` and `other`'s internal state handle. Does not access the pool state.
      * This function **can never be called concurrently with other functions
      * that read the internal state handle**, even for pools created
      * with \ref pool_params::thread_safe set to true.
      *
      * The internal pool state is not accessed, so this function can be called
      * concurrently with functions that only access the pool's internal state,
      * like returning connections.
      */
     connection_pool& operator=(connection_pool&& other) = default;
 
     /**
      * \brief Destructor.
      * \details
      * Cancels all outstanding async operations on `*this`, as per \ref cancel.
      *
      * \par Thread-safety
      * Mutates the internal state handle. Mutates the pool state.
      * This function **can never be called concurrently with other functions
      * that read the internal state handle**, even for pools created
      * with \ref pool_params::thread_safe set to true.
      *
      * The internal pool state is modified as per \ref cancel.
      * If thread-safety is enabled, it's safe to call the destructor concurrently
      * with functions that only access the pool's internal state,
      * like returning connections.
      */
     ~connection_pool()
     {
         if (valid())
             cancel();
     }
 
     /**
      * \brief Returns whether the object is in a moved-from state.
      * \details
      * This function returns always `true` except for pools that have been
      * moved-from. Moved-from objects don't represent valid pools. They can only
      * be assigned to or destroyed.
      *
      * \par Exception safety
      * No-throw guarantee.
      *
      * \par Thread-safety
      * Reads the internal state handle. Does not access the pool state.
      * Can be called concurrently with any other function that reads the state handle,
      * like \ref async_run or \ref async_get_connection.
      * It can't be called concurrently with functions modifying the handle, like assignments,
      * even if \ref pool_params::thread_safe is set to true.
      */
     bool valid() const noexcept { return impl_.get() != nullptr; }
 
     /// The executor type associated to this object.
     using executor_type = asio::any_io_executor;
 
     /**
      * \brief Retrieves the executor associated to this object.
      * \details
      * Returns the executor used to construct the pool as first argument.
      * This is the case even when using \ref pool_params::thread_safe -
      * the internal strand created in this case is never exposed.
      *
      * \par Exception safety
      * No-throw guarantee.
      *
      * \par Thread-safety
      * Reads the internal state handle. Reads the pool state.
      * If the pool was built with thread-safety enabled, it can be called
      * concurrently with other functions that don't modify the state handle.
      */
     BOOST_MYSQL_DECL
     executor_type get_executor() noexcept;
 
     /**
      * \brief Runs the pool task in charge of managing connections.
      * \details
      * This function creates and connects new connections, and resets and pings
      * already created ones. You need to call this function for \ref async_get_connection
      * to succeed.
      *
      * The async operation will run indefinitely, until the pool is cancelled
      * (by calling \ref cancel or using per-operation cancellation on the `async_run` operation).
      * The operation completes once all internal connection operations
      * (including connects, pings and resets) complete.
      *
      * It is safe to call this function after calling \ref cancel.
      *
      * \par Preconditions
      * This function can be called at most once for a single pool.
      * Formally, `async_run` hasn't been called before on `*this` or any object
      * used to move-construct or move-assign `*this`.
      *
      * Additionally, `this->valid() == true`.
      *
      * \par Object lifetimes
      * While the operation is outstanding, the pool's internal data will be kept alive.
      * It is safe to destroy `*this` while the operation is outstanding.
      *
      * \par Handler signature
      * The handler signature for this operation is `void(boost::mysql::error_code)`
      *
      * \par Executor
      *
      * The final handler is executed using `token`'s associated executor,
      * or `this->get_executor()` if the token doesn't have an associated
      * executor. The final handler is called as if it was submitted using `asio::post`,
      * and is never be called inline from within this function.
      *
      * If the pool was constructed with thread-safety enabled, intermediate
      * completion handlers are executed using an internal strand that wraps `this->get_executor()`.
      * Otherwise, intermediate handlers are executed using `this->get_executor()`.
      * In any case, the token's associated executor is only used for the final handler.
      *
      * \par Per-operation cancellation
      * This operation supports per-operation cancellation. Cancelling `async_run`
      * is equivalent to calling \ref connection_pool::cancel.
      * The following `asio::cancellation_type_t` values are supported:
      *
      *   - `asio::cancellation_type_t::terminal`
      *   - `asio::cancellation_type_t::partial`
      *
      * Note that `asio::cancellation_type_t::total` is not supported because invoking
      * `async_run` always has observable side effects.
      *
      * \par Errors
      * This function always complete successfully. The handler signature ensures
      * maximum compatibility with Boost.Asio infrastructure.
      *
      * \par Thread-safety
      * Reads the internal state handle. Mutates the pool state.
      * If the pool was built with thread-safety enabled, it can be called
      * concurrently with other functions that don't modify the state handle.
      */
     template <
         BOOST_ASIO_COMPLETION_TOKEN_FOR(void(::boost::mysql::error_code))
             CompletionToken = with_diagnostics_t<asio::deferred_t>>
     auto async_run(CompletionToken&& token = {})
         BOOST_MYSQL_RETURN_TYPE(decltype(asio::async_initiate<CompletionToken, void(error_code)>(
             std::declval<initiate_run>(),
             token,
             static_cast<diagnostics*>(nullptr),
             impl_
         )))
     {
         BOOST_ASSERT(valid());
         return asio::async_initiate<CompletionToken, void(error_code)>(
             initiate_run{get_executor()},
             token,
             static_cast<diagnostics*>(nullptr),
             impl_
         );
     }
 
     /**
      * \brief Retrieves a connection from the pool.
      * \details
      * Retrieves an idle connection from the pool to be used.
      *
      * If this function completes successfully (empty error code), the return \ref pooled_connection
      * will have `valid() == true` and will be usable. If it completes with a non-empty error code,
      * it will have `valid() == false`.
      *
      * If a connection is idle when the operation is started, it will complete immediately
      * with that connection. Otherwise, it will wait for a connection to become idle
      * (possibly creating one in the process, if pool configuration allows it), until
      * the operation is cancelled (by emitting a cancellation signal) or the pool
      * is cancelled (by calling \ref connection_pool::cancel).
      * If the pool is not running, the operation fails immediately.
      *
      * If the operation is cancelled, and the overload with \ref diagnostics was used,
      * the output diagnostics will contain the most recent error generated by
      * the connections attempting to connect (via \ref any_connection::async_connect), if any.
      * In cases where \ref async_get_connection doesn't complete because connections are unable
      * to connect, this feature can help figuring out where the problem is.
      *
      * \par Preconditions
      * `this->valid() == true` \n
      *
      * \par Object lifetimes
      * While the operation is outstanding, the pool's internal data will be kept alive.
      * It is safe to destroy `*this` while the operation is outstanding.
      *
      * \par Handler signature
      * The handler signature for this operation is
      * `void(boost::mysql::error_code, boost::mysql::pooled_connection)`
      *
      * \par Executor
      *
      * If the final handler has an associated immediate executor, and the operation
      * completes immediately, the final handler is dispatched to it.
      * Otherwise, the final handler is called as if it was submitted using `asio::post`,
      * and is never be called inline from within this function.
      * Immediate completions can only happen when thread-safety is not enabled.
      *
      * The final handler is executed using `token`'s associated executor,
      * or `this->get_executor()` if the token doesn't have an associated
      * executor.
      *
      * If the pool was constructed with thread-safety enabled, intermediate
      * completion handlers are executed using an internal strand that wraps `this->get_executor()`.
      * Otherwise, intermediate handlers are executed using
      * `token`'s associated executor if it has one, or `this->get_executor()` if it hasn't.
      *
      * **Caution**: be careful when using thread-safety and `asio::cancel_after`, as it
      * can result in inadvertent race conditions. Please refer to
      * <a href="../../../connection_pool.html#mysql.connection_pool.thread_safe">this
      * page</a> for more info.
      *
      * \par Per-operation cancellation
      * This operation supports per-operation cancellation.
      * Cancelling `async_get_connection` has no observable side effects.
      * The following `asio::cancellation_type_t` values are supported:
      *
      *   - `asio::cancellation_type_t::terminal`
      *   - `asio::cancellation_type_t::partial`
      *   - `asio::cancellation_type_t::total`
      *
      * \par Errors
      *   - \ref client_errc::no_connection_available, if the `async_get_connection`
      *     operation is cancelled before a connection becomes available.
      *   - \ref client_errc::pool_not_running, if the `async_get_connection`
      *     operation is cancelled before async_run is called.
      *   - \ref client_errc::pool_cancelled, if the pool is cancelled before
      *     the operation completes, or `async_get_connection` is called
      *     on a pool that has been cancelled.
      *
      * \par Thread-safety
      * Reads the internal state handle. Mutates the pool state.
      * If the pool was built with thread-safety enabled, it can be called
      * concurrently with other functions that don't modify the state handle.
      */
     template <
         BOOST_ASIO_COMPLETION_TOKEN_FOR(void(::boost::mysql::error_code, ::boost::mysql::pooled_connection))
             CompletionToken = with_diagnostics_t<asio::deferred_t>>
     auto async_get_connection(CompletionToken&& token = {}) BOOST_MYSQL_RETURN_TYPE(
         decltype(async_get_connection_impl(nullptr, std::forward<CompletionToken>(token)))
     )
     {
         return async_get_connection_impl(nullptr, std::forward<CompletionToken>(token));
     }
 
     /// \copydoc async_get_connection
     template <
         BOOST_ASIO_COMPLETION_TOKEN_FOR(void(::boost::mysql::error_code, ::boost::mysql::pooled_connection))
             CompletionToken = with_diagnostics_t<asio::deferred_t>>
     auto async_get_connection(diagnostics& diag, CompletionToken&& token = {}) BOOST_MYSQL_RETURN_TYPE(
         decltype(async_get_connection_impl(nullptr, std::forward<CompletionToken>(token)))
     )
     {
         return async_get_connection_impl(&diag, std::forward<CompletionToken>(token));
     }
 
     /**
      * \brief Stops any current outstanding operation and marks the pool as cancelled.
      * \details
      * This function has the following effects:
      *
      * \li Stops the currently outstanding \ref async_run operation, if any, which will complete
      *     with a success error code.
      * \li Cancels any outstanding \ref async_get_connection operations.
      * \li Marks the pool as cancelled. Successive `async_get_connection` calls will
      *     fail immediately.
      *
      * This function will return immediately, without waiting for the cancelled operations to complete.
      *
      * You may call this function any number of times. Successive calls will have no effect.
      *
      * \par Preconditions
      * `this->valid() == true`
      *
      * \par Exception safety
      * Basic guarantee. Memory allocations and acquiring mutexes may throw.
      *
      * \par Thread-safety
      * Reads the internal state handle. Mutates the pool state.
      * If the pool was built with thread-safety enabled, it can be called
      * concurrently with other functions that don't modify the state handle.
      */
     BOOST_MYSQL_DECL
     void cancel();
 };
 
 }  // namespace mysql
 }  // namespace boost
 
 #ifdef BOOST_MYSQL_HEADER_ONLY
 #include <boost/mysql/impl/connection_pool.ipp>
 #endif
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team