std::execution::read_env

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de ejecución

Conceptos de ejecución scheduler receiver receiver_of operation_state    sender sender_in sender_to Componentes de ejecución Contextos de ejecución run_loop Dominios de ejecución default_domain Garantía de progreso hacia adelante forward_progress_guarantee Entornos empty_env    get_env    env_of_t Consultas std::stop_token_of_t std::get_stop_token std::get_allocator std::forwarding_query get_scheduler get_domain get_forward_progress_guarantee get_delegation_scheduler get_completion_scheduler Signaturas de terminación completion_signatures completion_signatures_of_t transform_completion_signatures transform_completion_signatures_of    value_types_of_t error_types_of_t    tag_of_t sends_stopped    Cierres de adaptador de emisor sender_adaptor_closure Servicios de corrutinas as_awaitable with_awaitable_senders

Operaciones centrales Estado de operación connect connect_result_t start Terminación set_value set_error set_stopped Transformación transform_env transform_sender apply_sender Algoritmos de emisores Fábricas de emisores just just_error just_stopped read_env schedule schedule_result_t Adaptadores de emisores starts_on continues_on    on then upon_error upon_stopped let_value let_error let_stopped schedule_from when_all when_all_with_variant into_variant stopped_as_optional stopped_as_error bulk split Consumidores de emisores this_thread::sync_wait this_thread::sync_wait_with_variant

 

Definido en el archivo de encabezado <execution>
inlineconstexpr/*no especificado*/ read_env{};		(desde C++26) (objeto punto de personalización)
Signatura de la llamada
execution::senderauto read_env(auto&& query );		(desde C++26)

Una fábrica de emisores que devuelve un emisor que llega al entorno de un receptor y extrae el valor actual asociado con un determinado objeto de consulta.

Para cualquier objeto de consulta q, la expresión read_env(q) es de expresión equivalente a /*crear-emisor*/(read_env, q).

Objetos punto de personalización

El nombre execution::read_env denota un objeto punto de personalización, que es un objeto funciónconst de un tipo clase literalsemiregular. Para fines de exposición, la versión no calificada constvolatile de su tipo se denota como __read_env_fn.

Todas los ejemplares de __read_env_fn son iguales. Los efectos de invocar diferentes ejemplares del tipo __read_env_fn sobre los mismos argumentos son equivalentes, independientemente de si la expresión que denota el ejemplar es un l-valor o un r-valor, y está calificada const o no (sin embargo, no se requiere que un ejemplar calificado volatile sea invocable). Por lo tanto, execution::read_env se puede copiar libremente y sus copias se pueden usar indistintamente.

Dado un conjunto de tipos Args..., si std::declval<Args>()... cumple con los requisitos para los argumentos a execution::read_env arriba, __read_env_fn modela

• std::invocable<__read_env_fn, Args...>,
• std::invocable<const __read_env_fn, Args...>,
• std::invocable<__read_env_fn&, Args...>, and
• std::invocable<const __read_env_fn&, Args...>.
  

De lo contrario, ningún operador de llamada a función de __read_env_fn participa en la resolución de sobrecargas.

Ejemplo

Un ejemplo de uso de esta fábrica es planificar trabajo dependiente del planificador del receptor, que se puede obtener con read_env(get_scheduler):

std::execution::senderauto task = std::execution::read_env(std::execution::get_scheduler)| std::execution::let_value([](auto sched){return std::execution::starts_on(sched, /*algo de trabajo anidado aquí*/);});   std::this_thread::sync_wait( std::move(task));// esperar a que termine