◐ Shell
clean mode source ↗

Archivo de encabezado de la biblioteca estándar <stop_token>

De cppreference.com

Este archivo de encabezado es parte de la biblioteca de soporte de hilos.

Clases

Una interfaz para consultar si se ha hecho una solicitud de cancelación de un std::jthread.
(clase) [editar]
Clase que representa una solicitud para detener uno o más std::jthreads.
(clase) [editar]
Una interfaz para registrar devoluciones de llamada al cancelar un std::jthread.
(plantilla de clase) [editar]
Tipo marcador de posición para ser usado en el constructor de stop_source
(clase) [editar]

Constantes

Una instancia de std::nostopstate_t para ser usada en el constructor stop_source
(constante) [editar]

Sinopsis

namespace std {
  // clase stop_token
  class stop_token;

  // clase stop_source
  class stop_source;

  // indicador de estado de detención no compartido
  struct nostopstate_t {
    explicit nostopstate_t() = default;
  };
  inline constexpr nostopstate_t nostopstate{};

  // clase stop_callback
  template<class Callback>
  class stop_callback;
}

Clase std::stop_token

namespace std {
  class stop_token {
  public:
    // constructores, copia y asignación
    stop_token() noexcept;

    stop_token(const stop_token&) noexcept;
    stop_token(stop_token&&) noexcept;
    stop_token& operator=(const stop_token&) noexcept;
    stop_token& operator=(stop_token&&) noexcept;
    ~stop_token();
    void swap(stop_token&) noexcept;

    // manejo de detención
    [[nodiscard]] bool stop_requested() const noexcept;
    [[nodiscard]] bool stop_possible() const noexcept;

    [[nodiscard]]
    friend bool operator==(const stop_token& lhs, const stop_token& rhs) noexcept;
    friend void swap(stop_token& lhs, stop_token& rhs) noexcept;
  };
}

Clase std::stop_source

namespace std {
  // indicador de estado de detención no compartido
  struct nostopstate_t {
    explicit nostopstate_t() = default;
  };
  inline constexpr nostopstate_t nostopstate{};

  class stop_source {
  public:
    // constructores, copia y asignación
    stop_source();
    explicit stop_source(nostopstate_t) noexcept;

    stop_source(const stop_source&) noexcept;
    stop_source(stop_source&&) noexcept;
    stop_source& operator=(const stop_source&) noexcept;
    stop_source& operator=(stop_source&&) noexcept;
    ~stop_source();
    void swap(stop_source&) noexcept;

    // manejo de detención
    [[nodiscard]] stop_token get_token() const noexcept;
    [[nodiscard]] bool stop_possible() const noexcept;
    [[nodiscard]] bool stop_requested() const noexcept;
    bool request_stop() noexcept;

    [[nodiscard]] friend bool
    operator==(const stop_source& lhs, const stop_source& rhs) noexcept;
    friend void swap(stop_source& lhs, stop_source& rhs) noexcept;
  };
}

Plantilla de clase std::stop_callback

namespace std {
  template<class Callback>
  class stop_callback {
  public:
    using callback_type = Callback;

    // constructors and destructor
    template<class C>
    explicit stop_callback(const stop_token& st, C&& cb)
        noexcept(is_nothrow_constructible_v<Callback, C>);
    template<class C>
    explicit stop_callback(stop_token&& st, C&& cb)
        noexcept(is_nothrow_constructible_v<Callback, C>);
    ~stop_callback();

    stop_callback(const stop_callback&) = delete;
    stop_callback(stop_callback&&) = delete;
    stop_callback& operator=(const stop_callback&) = delete;
    stop_callback& operator=(stop_callback&&) = delete;

  private:
    Callback callback;      // solo exposición
  };

  template<class Callback>
  stop_callback(stop_token, Callback) -> stop_callback<Callback>;
}