clase ara::log::Logger

La función miembro LogDebug de la clase ara::log::Logger sirve para crear mensajes de registro con la gravedad Debug y devuelve para ello un objeto LogStream configurado en consecuencia [SWS_LOG_00068]. La declaración se realiza mediante el archivo de cabecera #include "ara/log/logger.h" [SWS_LOG_00068].

Para el uso y la semántica se definen las siguientes características de especificación:

• Llamada y valor de retorno: El método no acepta parámetros de entrada y devuelve directamente un objeto LogStream con nivel de gravedad Debug [SWS_LOG_00068]. En este caso, el funcionamiento se corresponde con el del método Logger::LogFatal() [SWS_LOG_00068].
• Tratamiento de errores: La firma está declarada como noexcept y especificada como segura frente a excepciones (exception safe) [SWS_LOG_00068]. En caso de error, no se emiten mensajes ni códigos de error [SWS_LOG_00068].
• Concurrencia: La función miembro está clasificada como constante (const), así como explícitamente segura para hilos (thread-safe) [SWS_LOG_00068], de modo que se permiten accesos de lectura paralelos a través de la misma instancia del registrador.

El método LogError de la clase ara::log::Logger sirve para iniciar una entrada de registro con el nivel de gravedad Error [SWS_LOG_00065]. La función se declara a través del archivo de encabezado ara/log/logger.h y no recibe parámetros [SWS_LOG_00065].

Uso y valor de retorno

La llamada síncrona devuelve un objeto de tipo LogStream con el nivel de gravedad Error [SWS_LOG_00065]. En este sentido, el comportamiento corresponde funcionalmente al de Logger::LogFatal() [SWS_LOG_00065]. Dado que LogError está declarado como const, la llamada no modifica el estado del objeto registrador y también se puede ejecutar sobre instancias constantes [SWS_LOG_00065].

Concurrencia y seguridad frente a excepciones

Para el contexto de llamada rigen garantías establecidas [SWS_LOG_00065]:

• Seguridad para subprocesos: La función está especificada como thread-safe [SWS_LOG_00065]. Interpretación: Por tanto, es de prever que las llamadas se puedan realizar de forma concurrente desde varios subprocesos sobre la misma instancia sin sincronización externa. Pregunta Q-e55d2b523c5cbcb3 (abierta)
• Seguridad ante excepciones: El método está declarado como noexcept, así como exception safe [SWS_LOG_00065]; no lanza excepciones en tiempo de ejecución.

Manejo de errores

No se contemplan códigos de error específicos ni notificaciones a DET o DEM para LogError [SWS_LOG_00065]. Los estados de error al realizar la llamada quedan excluidos gracias a la seguridad ante excepciones garantizada y a la interfaz sin parámetros [SWS_LOG_00065].

Uso y ciclo de vida

El método LogFatal de la clase ara::log::Logger (proporcionado a través de la cabecera ara/log/logger.h) crea un objeto LogStream con el nivel de gravedad Fatal ([SWS_LOG_00064]). La función no recibe argumentos y devuelve el flujo directamente. El objeto LogStream devuelto recibe mensajes de registro y parámetros secuencialmente a través del operador de flujo << ([SWS_LOG_00064]). En el escenario de aplicación habitual, el ciclo de vida del flujo creado se limita a una sola sentencia y finaliza con el punto y coma de cierre tras el último parámetro pasado ([SWS_LOG_00064]). Para prolongar el ciclo de vida del objeto de flujo más allá de esto, se puede asignar a una variable con nombre ([SWS_LOG_00064]).

Tratamiento de errores y concurrencia

La función está declarada como noexcept y especificada como segura frente a excepciones (exception safe) ([SWS_LOG_00064]). En tiempo de ejecución no lanza excepciones y no utiliza códigos de error específicos. En cuanto a la concurrencia, el método está especificado como const y totalmente seguro para subprocesos (thread-safe), por lo que se permiten llamadas paralelas a través de la misma instancia de registrador ([SWS_LOG_00064]).

Interacción

El método coincide en interfaz y comportamiento con los métodos de registro relacionados para diferentes niveles de gravedad dentro de ara::log::Logger: LogError ([SWS_LOG_00065]), LogWarn ([SWS_LOG_00066]), LogInfo ([SWS_LOG_00067]), LogDebug ([SWS_LOG_00068]) así como LogVerbose ([SWS_LOG_00069]).

La función miembro LogInfo de la clase ara::log::Logger ([SWS_LOG_00067]) se declara mediante la cabecera ara/log/logger.h. Sirve para crear un mensaje de registro con el nivel de gravedad Info, no requiere parámetros de entrada y devuelve de forma síncrona un objeto de tipo LogStream ([SWS_LOG_00067]). Según la especificación, el comportamiento se corresponde con el de Logger::LogFatal() ([SWS_LOG_00067]), donde la interpretación es que la funcionalidad opera de manera análoga y solo la clasificación del nivel de gravedad está fijada en Info.

En cuanto a la concurrencia y al contexto de llamada, el método está declarado como const y especificado explícitamente como seguro para hilos (thread-safe) ([SWS_LOG_00067]). De este modo, LogInfo puede invocarse en cualquier momento en paralelo desde varios hilos sobre la misma instancia del registrador, sin que sean necesarios bloqueos o mecanismos de sincronización bajo la responsabilidad de la aplicación.

En el tratamiento de errores, la función incluye el identificador noexcept y está clasificada como segura frente a excepciones (exception safe) ([SWS_LOG_00067]). No se devuelven códigos de error específicos ni se disparan mensajes de error DEM o DET ([SWS_LOG_00067]); no se ha definido ningún caso de error para esta llamada.

En la estructura de requisitos, la interfaz está asignada directamente a los upstream requirements [RS_LT_00003] y [RS_LT_00049] ([SWS_LOG_00067]), los cuales definen las directrices de nivel superior para el subsistema de logging y tracing.

El método LogVerbose() de la clase ara::log::Logger del archivo de cabecera #include "ara/log/logger.h" sirve para crear salidas de registro con el nivel de gravedad más detallado, Verbose [SWS_LOG_00069]. En la llamada no se pasan parámetros. La función devuelve de forma síncrona un objeto LogStream que está inicializado explícitamente con la severidad Verbose y se utiliza para transmitir contenidos de mensajes [SWS_LOG_00069].

La especificación indica que el comportamiento es idéntico al de Logger::LogFatal() [SWS_LOG_00069]; como interpretación, esto probablemente significa que el almacenamiento en búfer y la provisión del flujo siguen la mecánica general de registro y solo difieren en el nivel de gravedad asignado. Pregunta Q-522523e7a845dc3a (abierta) Para el tratamiento de errores, el método está especificado como noexcept y exception safe [SWS_LOG_00069]. Por consiguiente, no se producen excepciones y no existen códigos de error específicos en el contexto de llamada [SWS_LOG_00069].

En lo relativo a la concurrencia y a los contratos de interfaz, rigen las siguientes propiedades:

• Seguridad de hilos: El método está clasificado como thread-safe, de modo que las llamadas simultáneas a través de la misma instancia del registrador o de instancias diferentes pueden ejecutarse de forma segura [SWS_LOG_00069].
• Constancia: La declaración como const garantiza que la llamada no modifique el estado interno del objeto registrador [SWS_LOG_00069].

usar

La función miembro LogWarn de la clase ara::log::Logger se proporciona a través del encabezado ara/log/logger.h [SWS_LOG_00066]. La llamada se realiza sin parámetros sobre una instancia de registrador mediante la signatura LogStream LogWarn () const noexcept; [SWS_LOG_00066]. Como valor de retorno, la función devuelve de forma síncrona un objeto de tipo LogStream con la clasificación de gravedad Warn (Warn severity) [SWS_LOG_00066]. El comportamiento funcional corresponde a la descripción de Logger::LogFatal() [SWS_LOG_00066]. Interpretación: El objeto LogStream devuelto probablemente sirva para componer mensajes de registro de nivel de advertencia para su posterior emisión. Pregunta Q-02b18df759926020 (abierta)

Concurrencia y seguridad frente a errores

Con respecto al contexto de llamada y a la concurrencia, el método está especificado como thread-safe [SWS_LOG_00066]. Por tanto, puede invocarse de forma segura desde varios hilos concurrentes sobre la misma instancia. La función garantiza total seguridad frente a excepciones (exception safe) y está declarada con noexcept [SWS_LOG_00066]. Para esta operación no se han definido códigos de error, valores de error o señales de confirmación específicos para errores en tiempo de ejecución [SWS_LOG_00066]; interpretación: cabe descartar un fallo de retorno en el funcionamiento normal. Pregunta Q-44b264cd97ff8159 (abierta)

usar

El método de plantilla LogWith de la clase ara::log::Logger sirve para el registro estructurado de mensajes mediante un identificador, así como atributos y argumentos asociados [SWS_LOG_00133]. Se incluye a través del encabezado #include "ara/log/logger.h" y se ejecuta de forma síncrona sin valor de retorno [SWS_LOG_00133].

La función acepta los siguientes parámetros [SWS_LOG_00133]:

• attrs: una std::tuple con atributos del mensaje (tipos Attrs...),
• msgId: una instancia definida por la implementación de tipo MsgId para la identificación del objeto de mensaje,
• params: argumentos variádicos (tipos Params...) que se añaden a la entrada de registro.

Concurrencia y restricciones

La función está especificada como thread-safe y puede ejecutarse de forma concurrente [SWS_LOG_00133]. Está declarada con noexcept y clasificada como segura frente a excepciones (exception safe), por lo que no se lanzan excepciones de C++ [SWS_LOG_00133]. No se definen códigos de error ni mensajes de error específicos.

Para la instanciación de la plantilla se aplica: la función no participa en la resolución de sobrecarga si al menos uno de los tipos en Attrs... no representa un atributo de mensaje admisible [SWS_LOG_00133]. Interpretación: Dado que el requisito para el tipo Attr está marcado como TBD en la especificación, la comprobación de tipos concreta dependerá previsiblemente de la implementación de plataforma correspondiente. Pregunta Q-30f5de483410d716 (abierta)