Espacios de nombres
Variantes
Acciones

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

De cppreference.com
< cpp‎ | header
 
 
Archivos de encabezado de la biblioteca estándar
 

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

Contenido

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]

[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;
}

[editar] 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;
  };
}

[editar] 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;
  };
}

[editar] 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>;
}