clase ara::core::Map

usar

La función de acceso síncrono a elementos at de la clase ara::core::Map ([SWS_CORE_01456]) sirve para la recuperación controlada de un valor correspondiente a una clave existente. Se proporciona a través del encabezado ara/core/map.h. Como parámetro de entrada acepta una referencia de clave const key_type &x y devuelve una referencia modificable mapped_type & al valor asociado ([SWS_CORE_01456]). La semántica corresponde en principio al uso habitual de std::map; para instancias constantes está disponible la sobrecarga separada [SWS_CORE_01457].

Tratamiento de errores y condiciones límite

En caso de error, la función difiere deliberadamente del comportamiento estándar ISO: si el elemento x indicado no está presente en el contenedor, se genera una IsoStdOutOfRangeViolation en lugar de una excepción C++ clásica del tipo std::out_of_range ([SWS_CORE_01456]). La firma está declarada explícitamente como noexcept y clasificada como segura frente a excepciones (exception safe) ([SWS_CORE_01456]).

Interacción

El concepto de indicar desbordamientos de rango mediante IsoStdOutOfRangeViolation se implementa de manera uniforme en todo el módulo:

• Dentro de ara::core::Map, la sobrecarga de lectura con const posee el mismo comportamiento ante errores ([SWS_CORE_01457]).
• Existen funciones at correspondientes con IsoStdOutOfRangeViolation para ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]), ara::core::Vector ([SWS_CORE_01354], [SWS_CORE_01355]), ara::core::StringView ([SWS_CORE_02133]), así como ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).
• En el sistema global, la violación generada probablemente esté relacionada con mecanismos de aborto y terminación como AddAbortHandler ([SWS_CORE_00054]). Pregunta Q-9427d214713f7508 (abierta)

usar

La función miembro at conforme a [SWS_CORE_01457] permite el acceso de lectura síncrono a un elemento dentro de una instancia de ara::core::Map a través del encabezado #include "ara/core/map.h". Como parámetro, se pasa la clave buscada x como const key_type &. En caso de búsqueda exitosa, el método devuelve una referencia constante al valor correspondiente (const mapped_type &).

Tratamiento de errores y comportamiento ante excepciones

El comportamiento corresponde en principio al comportamiento estándar de std::map::at, pero presenta una discrepancia específica: si la clave x no se encuentra en el contenedor, se lanza un IsoStdOutOfRangeViolation en lugar de std::out_of_range conforme a [SWS_CORE_01457]. Dado que la función está especificada con noexcept, esta infracción no conduce a una excepción regular de C++; presumiblemente, esto conlleva la terminación controlada del proceso mediante los mecanismos de tratamiento de errores que pueden registrarse en el contexto de [SWS_CORE_00054]. Pregunta Q-d7dd2c332f88ed14 (abierta)

Concurrencia e interacción

Como método constante, la llamada califica para el acceso de lectura concurrente, siempre que no se produzcan accesos modificadores simultáneos a la misma instancia de map. Además de esta interfaz constante, existe una sobrecarga no constante con [SWS_CORE_01456] que devuelve una referencia modificable. La misma estrategia para la señalización de violaciones de rango mediante IsoStdOutOfRangeViolation se implementa de manera consistente también en otros contenedores de Core adaptativos, por ejemplo en ara::core::Array ([SWS_CORE_01274]) y ara::core::Vector ([SWS_CORE_01354]).

La función miembro clear de la clase ara::core::Map sirve para vaciar completamente el contenido del contenedor según la especificación en [SWS_CORE_01485]. La función requiere la inclusión del archivo de encabezado #include "ara/core/map.h". La semántica de llamada y el comportamiento se orientan al uso correspondiente del estándar ISO C++ para maps asociativos estándar ([map]).

En cuanto a la interfaz y el tratamiento de errores, la función presenta las siguientes características:

• Parámetros y valor de retorno: la operación posee la firma void clear () noexcept;, no recibe parámetros y no devuelve ningún valor [SWS_CORE_01485].
• Seguridad frente a excepciones: la función está declarada explícitamente como noexcept y especificada como exception safe [SWS_CORE_01485]. Por lo tanto, no lanza excepciones de C++ en caso de error.
• Ejecución síncrona: la llamada se ejecuta de forma síncrona sobre la instancia; tras el retorno, el contenedor debería estar vacío (tamaño 0). Pregunta Q-1d0cf2a1a33d818e (abierta)

En el módulo core, el vaciado de contenedores estándar sigue un paradigma uniforme. Se encuentran funciones clear análogas con firma y seguridad frente a excepciones idénticas, por ejemplo, para contenedores secuenciales en ara::core::Vector según [SWS_CORE_01375] (ara/core/vector.h), así como para cadenas de caracteres en ara::core::BasicString según [SWS_CORE_03057] (ara/core/string.h). Los desarrolladores pueden confiar, en todos los contenedores, en la semántica estándar habitual de C++ y en la ausencia garantizada de excepciones.

El método plantilla contains de la clase ara::core::Map sirve para verificar de forma síncrona si existe una clave buscada en un contenedor asociativo [SWS_CORE_01497]. Se proporciona a través de la cabecera #include "ara/core/map.h" y se invoca como función miembro constante (const) sobre una instancia de ara::core::Map [SWS_CORE_01497]. Como parámetro de llamada, acepta una referencia constante const K &x a la clave que se desea buscar y entrega un valor de retorno del tipo bool [SWS_CORE_01497].

En cuanto a su semántica, la especificación remite al uso correspondiente en [map] [SWS_CORE_01497]. Esto presumiblemente debe interpretarse como la adopción del comportamiento de std::map::contains, según el cual el método devuelve true si y solo si una clave equivalente está contenida en el map, y en caso contrario false. Pregunta Q-664d5a3d099db549 (abierta)

En lo que respecta a la robustez y al tratamiento de errores, la función está catalogada explícitamente como not exception safe [SWS_CORE_01497]. No existen para esta operación códigos de error específicos de AUTOSAR ni mensajes a DET o DEM. Quienes la invoquen deben tener en cuenta que durante la ejecución pueden lanzarse excepciones y propagarse hacia el exterior, provocadas presumiblemente por comparaciones de claves o conversiones del tipo K. Pregunta (abierta)

Dado que contains, como operación de lectura const, no altera el estado del map, los accesos simultáneos de lectura sobre la misma instancia no suelen ser críticos, mientras que las modificaciones paralelas de escritura en el contenedor presumiblemente requerirán sincronización externa. Pregunta Q-f3ca0e3d094f8f0a (abierta)

Uso y semántica

La función miembro contains pertenece al ámbito de la clase ara::core::Map y se proporciona a través del archivo de cabecera ara/core/map.h [SWS_CORE_01510]. La función posee la firma bool contains (const key_type &x) const; y se ejecuta de forma sincrónica. Sirve para comprobar si existe un elemento con la clave x en el contenedor. La especificación remite al comportamiento correspondiente en [map], con lo que probablemente se hace referencia a la semántica del contenedor estándar de C++ std::map::contains, que devuelve true si la clave está presente y false en caso contrario. Pregunta Q-fea394bd408bf925 (abierta)

Tratamiento de errores y seguridad frente a excepciones

El comportamiento de contains está catalogado expresamente en la especificación como not exception safe [SWS_CORE_01510]. En el alcance de la especificación no se definen códigos de error específicos, dominios de error ni notificaciones DET o DEM. Por lo tanto, los llamadores deben tener en cuenta que no se conceden garantías de seguridad frente a excepciones durante la búsqueda y que deben gestionarse las excepciones que se produzcan.

Concurrencia y restricciones

La especificación en [SWS_CORE_01510] no realiza ninguna afirmación explícita sobre la seguridad para subprocesos (thread-safety). Dado que se trata de una función miembro constante (const), el estado del contenedor no se modifica. Interpretación: Los accesos de lectura paralelos probablemente sean admisibles, mientras que las modificaciones simultáneas de escritura sobre la misma instancia requieren una sincronización externa. Pregunta Q-7d8ce1efc81ec781 (abierta)

Interacción en el módulo core

En comparación con otras funciones de comprobación de estado del módulo core —como por ejemplo HasValue [SWS_CORE_00751] o CheckError [SWS_CORE_00765] en ara::core::Result, que están definidas como exception safe y noexcept—, contains en ara::core::Map no ofrece ninguna garantía de noexcept y está declarada como no segura frente a excepciones [SWS_CORE_01510].

La función miembro síncrona count de la clase ara::core::Map determina, a partir de la clave x de tipo const key_type& proporcionada, cuántas veces aparece dicha clave en el contenedor y devuelve el resultado como size_type [SWS_CORE_01494]. La declaración se realiza a través de la cabecera #include "ara/core/map.h" [SWS_CORE_01494]. Interpretación: de acuerdo con la referencia al comportamiento estándar en [map], es probable que el valor de retorno en el caso de claves únicas sea 0 o 1. Pregunta Q-a713cfc1019b40d0 (abierta)

En cuanto al tratamiento de errores, la función está clasificada expresamente en la especificación como «not exception safe» [SWS_CORE_01494]. No se definen códigos de error específicos ni mensajes de DET/DEM; si la operación de comparación de claves lanza una excepción, presumiblemente se propagará de forma directa a quien invoca la función. Pregunta (abierta)

Respecto a la concurrencia y las restricciones, se trata de una operación constante (const) [SWS_CORE_01494]. Interpretación: los accesos de lectura concurrentes a la misma instancia de ara::core::Map deberían ser posibles sin condiciones de carrera de datos, mientras que las operaciones modificadoras simultáneas deben asegurarse mediante sincronización externa. Pregunta (abierta)

En interacción con requisitos afines, dentro de ara::core::Map existe una sobrecarga de plantilla con [SWS_CORE_01495] template <class K> size_type count (const K &x) const. Esta permite realizar consultas de búsqueda heterogéneas con tipos de comparación compatibles K sin tener que crear obligatoriamente de forma previa un objeto temporal de tipo key_type, si bien está sujeta a la misma clasificación respecto a la seguridad frente a excepciones [SWS_CORE_01495].

La función miembro de plantilla count de la clase ara::core::Map comprueba de forma síncrona la presencia de elementos a partir de una clave y determina su cantidad [SWS_CORE_01495]. La función está declarada en la cabecera ara/core/map.h y devuelve la cantidad de elementos encontrados como size_type [SWS_CORE_01495]. Según la referencia especificada al uso en [map], la llamada devuelve el valor 1 en el caso de claves únicas si existe un elemento coincidente, y 0 en caso contrario [SWS_CORE_01495].

En interacción directa con la sobrecarga count(const key_type&) [SWS_CORE_01494], esta variante permite pasar cualquier tipo de clave compatible const K& [SWS_CORE_01495]. Interpretación: es de esperar que la parametrización de plantilla esté diseñada para operaciones de búsqueda heterogéneas, con el fin de realizar comparaciones sin conversión previa a un objeto temporal key_type [SWS_CORE_01495]. Pregunta Q-e2572768e5600da7 (abierta) De este modo, se pueden evitar asignaciones innecesarias y costes de conversión en las consultas de búsqueda.

En relación con la seguridad frente a excepciones, el método está declarado como no seguro frente a excepciones (not exception safe) [SWS_CORE_01495], de forma análoga a la sobrecarga afín [SWS_CORE_01494]. No existen canales de error específicos como DET o DEM para esta operación del contenedor [SWS_CORE_01495]; las posibles excepciones del operador de comparación subyacente se propagan al llamador. Dado que el método está calificado con const, no modifica el contenedor [SWS_CORE_01495]; los accesos concurrentes de lectura son seguros, pero los accesos concurrentes de escritura requieren sincronización externa.

usar

La función miembro crbegin de la clase ara::core::Map se proporciona a través del archivo de cabecera #include "ara/core/map.h" [SWS_CORE_01450]. No recibe parámetros y devuelve de forma síncrona un const_reverse_iterator al primer elemento en orden inverso [SWS_CORE_01450]. La semántica funcional sigue la indicación de la especificación «As per corresponding usage in [map]» [SWS_CORE_01450]; es de suponer que esto corresponde a la semántica de std::map::crbegin del estándar de C++. Pregunta Q-0ad5de7dada37aa8 (abierta)

Tratamiento de errores y seguridad frente a excepciones

No se prevén códigos de error específicos, mensajes DET o DEM para esta llamada. Conforme a la especificación, la función está declarada con noexcept y clasificada como segura frente a excepciones («exception safe») [SWS_CORE_01450], de modo que durante la ejecución no se producen excepciones.

Concurrencia y restricciones

Al ser un método cualificado con const, crbegin no modifica el objeto ara::core::Map [SWS_CORE_01450]. El iterador resultante permite exclusivamente accesos de lectura a los elementos contenidos en el contenedor.

Interacción

El concepto de iteración está armonizado entre contenedores en AUTOSAR Adaptive Core:

• ara::core::Vector [SWS_CORE_01342] y ara::core::BasicString [SWS_CORE_03049] proporcionan métodos const noexcept funcionalmente idénticos.
• Para ara::core::Array [SWS_CORE_01260], ara::core::Span [SWS_CORE_01978] y ara::core::StringView [SWS_CORE_02126], crbegin está definido adicionalmente como constexpr.

usar

El método crend de la clase de plantilla ara::core::Map ([SWS_CORE_01451]) está disponible a través de la cabecera ara/core/map.h. Devuelve de forma síncrona un iterador inverso constante (const_reverse_iterator) que, conforme al comportamiento estándar de std::map, marca la llegada al final de una iteración en sentido inverso sobre los elementos.

Tratamiento de errores y seguridad frente a excepciones

La función cuenta con la especificación noexcept y está clasificada como «exception safe» ([SWS_CORE_01451]). La llamada no lanza excepciones y no requiere comprobación de códigos de error.

Concurrencia y condiciones de contorno

Como método cualificado con const, crend no modifica la instancia de mapa subyacente. Por tanto, es probable que los accesos de lectura concurrentes a través de múltiples subprocesos sean seguros, siempre que la instancia no se modifique simultáneamente mediante escritura (interpretación). Pregunta Q-5593deafcef41be3 (abierta)

Interacción

La signatura y la semántica se integran en las interfaces uniformes de iteradores de la biblioteca ara::core. Existen funciones crend análogas para:

• ara::core::Vector ([SWS_CORE_01343]) y ara::core::BasicString ([SWS_CORE_03050]), cada una con declaración const noexcept idéntica, así como
• los contenedores y vistas ara::core::Array ([SWS_CORE_01261]), ara::core::Span ([SWS_CORE_01979]) y ara::core::StringView ([SWS_CORE_02127]), que están declarados adicionalmente como constexpr.

Uso de emplace en ara::core::Map

La función miembro de plantilla emplace de la clase ara::core::Map sirve para construir e insertar directamente un nuevo par clave-valor en la memoria asociativa [SWS_CORE_01458]. La función está definida en la cabecera #include "ara/core/map.h" y acepta los argumentos del constructor a través del paquete de parámetros Args&&... args [SWS_CORE_01458]. Como resultado, la llamada síncrona devuelve un std::pair<iterator, bool> [SWS_CORE_01458]. Interpretación: la referencia a [map] indicaría probablemente que el comportamiento sigue al contenedor estándar de C++ std::map, de modo que el iterador apunta al elemento y el valor booleano señala si la entrada se insertó de nuevo. Pregunta Q-fa496892c1e5e15d (abierta)

En lo relativo al tratamiento de errores y la robustez, emplace está clasificado expresamente en la especificación como not exception safe [SWS_CORE_01458]. Si la asignación de memoria o la construcción del objeto fallan, la implementación no garantiza la consistencia del contenedor. No se contemplan códigos de error de AUTOSAR específicos ni mensajes a DET o DEM para esta interfaz fundamental.

En el módulo core existen operaciones emplace análogas para otros tipos de datos, las cuales poseen sin embargo garantías divergentes: mientras que ara::core::Vector::emplace también está especificado como no seguro frente a excepciones [SWS_CORE_01366], las implementaciones en ara::core::Optional [SWS_CORE_01119] y ara::core::Variant [SWS_CORE_01661] ofrecen seguridad condicional frente a excepciones (conditionally exception safe).

usar

La función miembro plantilla emplace_hint de la clase de contenedor ara::core::Map sirve para insertar un nuevo elemento utilizando una posición sugerida como pista de búsqueda ([SWS_CORE_01459]). Se proporciona a través de la cabecera ara/core/map.h y acepta el iterador position así como un paquete de parámetros args para su reenvío ([SWS_CORE_01459]). El modo de funcionamiento se corresponde con el uso en [map] ([SWS_CORE_01459]). Presumiblemente, los argumentos pasados se utilizan directamente para la construcción in situ de la entrada, con lo que se lograría una inserción acelerada en caso de un posicionamiento adecuado. Pregunta Q-564dd9bab5c0293f (abierta)

Tratamiento de errores y seguridad frente a excepciones

En cuanto a la tolerancia a fallos, la operación está clasificada explícitamente como not exception safe ([SWS_CORE_01459]). Si se produce un error durante la asignación de memoria o la construcción del par clave-valor, es de esperar que no aplique ninguna garantía respecto al estado del contenedor. Pregunta (abierta) Para esta interfaz no se han definido códigos de error específicos ni mensajes de diagnóstico tales como DET o DEM ([SWS_CORE_01459]).

Concurrencia y restricciones

La especificación no realiza ninguna declaración acerca de la concurrencia ni de los contextos de llamada ([SWS_CORE_01459]). Interpretación: como operación que modifica el estado de ara::core::Map, emplace_hint requiere sincronización externa en caso de acceso simultáneo desde varios hilos a fin de prevenir inconsistencias de datos. Pregunta Q-04b3ab58544ceba4 (abierta)

usar

La función miembro síncrona equal_range de la clase ara::core::Map se proporciona a través del encabezado #include "ara/core/map.h" [SWS_CORE_01506]. Toma una clave x de tipo const key_type & y devuelve un par de iteradores modificables (std::pair<iterator, iterator>) que delimita el rango de todas las entradas coincidentes [SWS_CORE_01506]. El comportamiento sigue la semántica habitual en [map] [SWS_CORE_01506]; dado que Map normalmente posee claves únicas, es probable que el rango de resultados comprenda como máximo un elemento (interpretación). Pregunta Q-d26df1f3ac3b6232 (abierta)

Tratamiento de errores y seguridad frente a excepciones

La especificación clasifica la función expresamente como not exception safe [SWS_CORE_01506]. No se definen códigos de error específicos, valores de retorno para la señalización de errores ni informes a DET o DEM. Si no se encuentra la clave buscada, es probable que ambos iteradores del par sean idénticos y apunten a la posición potencial de inserción (interpretación conforme a [map]). Pregunta (abierta)

Concurrencia y restricciones

La operación no es constante y devuelve iteradores no constantes [SWS_CORE_01506]. Dado que no hay mecanismos de sincronización documentados, los accesos simultáneos de lectura o escritura a la misma instancia de ara::core::Map probablemente no sean seguros para subprocesos (interpretación) y requieren sincronización externa. Pregunta Q-3fb76368d9de336f (abierta)

Interacción

Para accesos de lectura a instancias constantes, está disponible la sobrecarga con pares de const_iterator [SWS_CORE_01507]. Además, existen variantes de plantilla para operaciones de búsqueda heterogéneas con cualquier tipo de clave K, tanto para llamadas no constantes [SWS_CORE_01508] como para llamadas constantes [SWS_CORE_01509].

usar

La función miembro equal_range de la clase ara::core::Map determina en una instancia constante el rango de todas las entradas que coinciden con una clave predeterminada [SWS_CORE_01507]. Recibe el parámetro const key_type &x y devuelve un std::pair<const_iterator, const_iterator> que representa los límites del rango [SWS_CORE_01507]. La función se proporciona mediante el archivo de cabecera ara/core/map.h y se ejecuta de forma síncrona [SWS_CORE_01507]. La semántica se corresponde con la especificación de [map] [SWS_CORE_01507]; en consecuencia, es probable que en un mapa con claves unívocas el rango devuelto abarque una amplitud de a lo sumo una entrada. Pregunta Q-f2bdc3bf2c17948e (abierta)

Tratamiento de errores y condiciones límite

En lo que respecta al comportamiento frente a errores y excepciones, el método está especificado como no seguro frente a excepciones («not exception safe») [SWS_CORE_01507]. No se establecen códigos de error específicos, notificaciones DET ni eventos DEM. Dado que el método está declarado como const, no modifica el estado del objeto llamador.

Interacción

La operación se encuentra integrada en una serie de sobrecargas relacionadas dentro de ara::core::Map:

• Para instancias no constantes, [SWS_CORE_01506] ofrece la misma búsqueda, pero devuelve iteradores modificables.
• A través de las funciones de plantilla [SWS_CORE_01508] y [SWS_CORE_01509], la búsqueda también se puede llevar a cabo con claves compatibles del tipo K tanto para mapas modificables como constantes.

Uso y semántica

La función miembro plantilla equal_range de la clase ara::core::Map ([SWS_CORE_01508]) se proporciona a través de la cabecera ara/core/map.h. Sirve para localizar el rango de todos los elementos cuya clave coincide con el valor proporcionado. El comportamiento se rige por el uso correspondiente en [map] ([SWS_CORE_01508]). La llamada síncrona recibe un parámetro de clave x de tipo genérico const K& y devuelve como valor de retorno un std::pair<iterator, iterator> ([SWS_CORE_01508]). Interpretación: debido al tipo de parámetro genérico K, es probable que la función admita una búsqueda heterogénea, de modo que las comparaciones sean posibles sin una conversión previa a key_type. Pregunta Q-19f39bf5b68f9a3c (abierta)

Tratamiento de errores y condiciones límite

Según la especificación, la función está clasificada como no segura frente a excepciones (not exception safe) ([SWS_CORE_01508]). No se contemplan códigos de error específicos, valores de retorno para la indicación de errores ni notificaciones a DET o DEM. Dado que la función no está cualificada como const, devuelve iteradores modificables que permiten accesos de escritura a los valores contenidos.

Interacción

La función miembro forma parte de un grupo de sobrecargas equal_range relacionadas dentro de ara::core::Map:

• [SWS_CORE_01506]: variante no constante para claves directas del tipo const key_type&.
• [SWS_CORE_01507]: variante constante para claves directas del tipo const key_type&, que devuelve const_iterator.
• [SWS_CORE_01509]: sobrecarga de plantilla constante para claves genéricas del tipo const K&.

usar

La función miembro plantilla equal_range de la clase ara::core::Map de la cabecera ara/core/map.h determina el rango de elementos que se corresponden con una clave de búsqueda x transferida del tipo K [SWS_CORE_01509]. Como método constante, devuelve un par de valores de iteradores constantes std::pair<const_iterator, const_iterator> y no modifica el contenedor subyacente [SWS_CORE_01509]. Según la especificación, la semántica se rige por el uso correspondiente en [map] [SWS_CORE_01509]. Interpretación: es probable que el parámetro de plantilla K permita una búsqueda heterogénea de claves, de modo que no sea necesario construir un objeto temporal del tipo de clave. Pregunta Q-7f7a93cef3cf7d8f (abierta)

Tratamiento de errores y seguridad frente a excepciones

Respecto a la seguridad frente a excepciones, la función está clasificada expresamente como no segura frente a excepciones («not exception safe») [SWS_CORE_01509]. En el alcance de la especificación para esta función no se contemplan códigos de error específicos ni avisos a interfaces de diagnóstico o de error (como DET o DEM) [SWS_CORE_01509].

Interacción y sobrecargas

La función forma un conjunto directo con las demás variantes de equal_range en ara::core::Map:

• La sobrecarga de plantilla no constante [SWS_CORE_01508], que devuelve un par de iteradores modificables.
• Las sobrecargas no basadas en plantillas para const key_type &x en forma no constante [SWS_CORE_01506], así como en forma constante [SWS_CORE_01507].

La función erase de la clase ara::core::Map elimina de forma síncrona del contenedor aquel elemento referenciado por el parámetro pasado position [SWS_CORE_01480]. La definición se incluye mediante la cabecera <ara/core/map.h> [SWS_CORE_01480]. Como valor de retorno, la función proporciona un iterador al elemento del mapa inmediatamente posterior al elemento eliminado [SWS_CORE_01480]. La semántica sigue la especificación según el uso correspondiente en [map] [SWS_CORE_01480].

En lo referente al tratamiento de errores, la operación está clasificada como no segura ante excepciones (not exception safe) [SWS_CORE_01480]. Para esta llamada no se especifican códigos de error específicos, canales de repliegue ni mensajes de error a través de DET o DEM [SWS_CORE_01480]. Dado que el comportamiento se basa en [map], es probable que el iterador pasado quede invalidado por el proceso de eliminación, mientras que los iteradores a los elementos restantes probablemente permanezcan intactos [SWS_CORE_01480]. El paso de un iterador no válido o no desreferenciable probablemente conduzca, a falta de validación, a un comportamiento indefinido (interpretación). Pregunta Q-1a4a3eae317fc52e (abierta)

En la interacción dentro de ara::core::Map existen sobrecargas alternativas: además de la eliminación a través de un iterator modificable, se encuentra disponible una sobrecarga para const_iterator [SWS_CORE_01481]. De igual modo, los elementos se pueden eliminar en función de la clave mediante key_type [SWS_CORE_01482] o como un rango completo de iteradores [SWS_CORE_01483].

La función miembro erase de la clase ara::core::Map sirve para el borrado síncrono de un único elemento en la posición indicada por el iterador position [SWS_CORE_01481]. La declaración se realiza a través del archivo de cabecera ara/core/map.h [SWS_CORE_01481]. El comportamiento corresponde a la definición en [map], devolviendo la función un iterator al elemento sucesor del mapa [SWS_CORE_01481].

En lo relativo al tratamiento de excepciones, la función está especificada como «not exception safe» [SWS_CORE_01481]. Para esta operación no se definen códigos de error específicos, violaciones ni mensajes de error [SWS_CORE_01481]. Interpretación: La transferencia de un iterador no válido o no desreferenciable como position probablemente dé lugar a un comportamiento indefinido, ya que la especificación no prevé comprobaciones de errores. Pregunta Q-9a3242ae4773cc0b (abierta)

En interacción con la interfaz de contenedor de ara::core::Map, se encuentran disponibles otras sobrecargas:

• Borrado mediante un iterador modificable iterator position [SWS_CORE_01480],
• Borrado a partir de una clave mediante erase(const key_type &x) con devolución del número de elementos eliminados [SWS_CORE_01482],
• Borrado de rango mediante dos iteradores first y last [SWS_CORE_01483].

Las sobrecargas correspondientes para posiciones individuales de const_iterator están definidas de forma análoga también para otros contenedores como ara::core::Vector [SWS_CORE_01372] o ara::core::BasicString [SWS_CORE_03103].

usar

La función miembro síncrona erase de la clase ara::core::Map sirve para eliminar entradas a través de una clave indicada x de tipo const key_type& ([SWS_CORE_01482]). La interfaz se incluye a través de la cabecera ara/core/map.h. El comportamiento funcional está definido como equivalente al uso en [map] ([SWS_CORE_01482]). Interpretación: Conforme a esta referencia del estándar de C++, es probable que el valor de retorno de tipo size_type indique el número de elementos eliminados con éxito del contenedor. Pregunta Q-03637eb7e5efe502 (abierta)

Tratamiento de errores y condiciones límite

En la especificación, la función está clasificada como not exception safe ([SWS_CORE_01482]). Para esta llamada de contenedor no se definen códigos de retorno específicos para situaciones de error ni vías de notificación mediante DET o DEM. Interpretación: Debido a la falta de seguridad frente a excepciones, es probable que en caso de error no apliquen garantías relativas al estado del contenedor, por lo que el invocador debería garantizar la consistencia de los datos y la validez de los parámetros de llamada antes de la ejecución. Pregunta (abierta)

Interacción

El método constituye la contrapartida basada en clave de las operaciones de borrado basadas en iteradores de ara::core::Map, las cuales limpian posiciones individuales ([SWS_CORE_01480], [SWS_CORE_01481]) o rangos cerrados de iteradores ([SWS_CORE_01483]). El patrón de funciones estandarizadas de erase se reproduce en ara::core de forma transversal a los contenedores, por ejemplo para ara::core::Vector ([SWS_CORE_01372]) o para ara::core::BasicString ([SWS_CORE_03102]).

usar

La función miembro erase del contenedor ara::core::Map sirve para eliminar un rango de valores [SWS_CORE_01483] delimitado por dos iteradores. Está definida en el encabezado #include "ara/core/map.h" y posee la firma iterator erase (const_iterator first, const_iterator last); [SWS_CORE_01483]. Desde el punto de vista funcional, el comportamiento sigue la semántica habitual en [map] [SWS_CORE_01483]. Como valor de retorno devuelve un iterator al elemento que sigue inmediatamente al rango eliminado, o bien al final del contenedor [SWS_CORE_01483].

Tratamiento de errores y restricciones

En la especificación, la operación está clasificada explícitamente como not exception safe [SWS_CORE_01483]. No se han definido códigos de error de AUTOSAR específicos ni mensajes a DET o DEM para esta función. Por lo tanto, el llamador debería tener que asegurarse bajo su propia responsabilidad de que first y last referencien un rango válido y bien formado dentro de la misma instancia, ya que no se contemplan comprobaciones adicionales (interpretación). Pregunta Q-69e88ecc6f04bb64 (abierta)

Interacción

Dentro de ara::core::Map, esta eliminación de rango complementa las sobrecargas para eliminar elementos individuales mediante iterator [SWS_CORE_01480], mediante const_iterator [SWS_CORE_01481] así como a partir de una clave key_type [SWS_CORE_01482]. Interfaces erase similares para rangos de iteradores se encuentran también en otros contenedores de Adaptive Core Library, concretamente en ara::core::Vector [SWS_CORE_01373] y ara::core::BasicString [SWS_CORE_03104].

La función miembro extract de la clase ara::core::Map extrae el elemento en la posición designada por el iterador position y devuelve un nodo de tipo node_type [SWS_CORE_01470]. La declaración y la semántica siguen el uso correspondiente en [map], con lo cual el nodo se desacopla directamente del contenedor asociativo. La función se proporciona a través de la cabecera ara/core/map.h.

Uso y comportamiento

La llamada se realiza de forma síncrona sobre una instancia de ara::core::Map. Como parámetro se pasa un const_iterator position, el cual, interpretación: debe apuntar a un elemento válido y desreferenciable dentro del mapa llamado. Mediante la extracción, el elemento se elimina del contenedor, mientras que el objeto node_type devuelto asume la propiedad del nodo.

Tratamiento de errores y seguridad frente a excepciones

En cuanto al tratamiento de excepciones, según la especificación la función está clasificada expresamente como not exception safe [SWS_CORE_01470]. Si se produce una excepción durante la ejecución, la operación no garantiza determinismo en el contenedor, por lo que el código llamador debería prever las medidas de protección oportunas.

Interacción y alternativas

Como sobrecarga, además de la extracción basada en posición, también está disponible la variante basada en clave extract(const key_type &x) [SWS_CORE_01471]. Esta última permite extraer una entrada directamente a partir de su valor de clave, sin tener que determinar previamente un iterador de forma manual.

usar

La función miembro sincrónica extract está definida en el archivo de cabecera #include "ara/core/map.h" dentro de la clase ara::core::Map [SWS_CORE_01471]. Recibe como parámetro una referencia constante a la clave const key_type &x y devuelve el elemento encontrado como node_type [SWS_CORE_01471]. La semántica funcional remite al uso correspondiente en [map] [SWS_CORE_01471]; esto probablemente se corresponda con el estándar de C++, según el cual el nodo se extrae directamente del contenedor sin que sea necesario copiar la clave ni el valor. Pregunta (abierta)

Tratamiento de errores y restricciones

La función está clasificada explícitamente en la especificación como «not exception safe» [SWS_CORE_01471]. En el payload no se definen códigos de error específicos, clases de error ni notificaciones DET o DEM. Por lo tanto, en caso de error probablemente no haya garantías respecto a la preservación o coherencia del estado del contenedor, por lo que las entidades invocadoras deberían prever las medidas de protección correspondientes. Pregunta (abierta)

Interacción

El elemento de especificación está directamente relacionado con la sobrecarga node_type extract(const_iterator position) [SWS_CORE_01470]. Mientras que la presente función identifica y extrae un elemento mediante la clave de búsqueda [SWS_CORE_01471], la variante afín permite la extracción específica a través de una posición de iterador ya conocida [SWS_CORE_01470]. Ambas interfaces pertenecen al alcance de ara::core::Map y comparten la misma propiedad de falta de seguridad frente a excepciones [SWS_CORE_01470] [SWS_CORE_01471].

usar

La función miembro find de la clase ara::core::Map sirve para localizar de forma síncrona un elemento a partir de su clave [SWS_CORE_01490]. La función está declarada en el archivo de cabecera ara/core/map.h. Recibe una referencia a la clave buscada (const key_type &x) y devuelve un iterator modificable al par clave-valor encontrado; si no se encuentra ninguna entrada coincidente, la devolución se corresponde con el iterador de final del mapa [SWS_CORE_01490].

Tratamiento de fallos y seguridad frente a excepciones

Según la especificación, esta función está clasificada como not exception safe [SWS_CORE_01490]. No se especifican mensajes de error a través de DET o DEM para este servicio básico de contenedor. Si se producen errores operativos durante la comparación, se pueden propagar las excepciones del operador de comparación subyacente.

Concurrencia e interacción

Al tratarse de una función miembro no constante que proporciona un iterador con capacidad de escritura, el acceso simultáneo sin sincronización probablemente no sea seguro para hilos. Pregunta Q-0f9f56b506cfd318 (abierta) Para el acceso de solo lectura a instancias constantes de ara::core::Map se encuentra disponible la sobrecarga con const_iterator [SWS_CORE_01491]. De forma complementaria, las sobrecargas basadas en plantillas admiten una búsqueda transparente con tipos de comparación compatibles K, tanto modificadora [SWS_CORE_01492] como constante [SWS_CORE_01493]. A diferencia de las funciones find basadas en caracteres en ara::core::StringView [SWS_CORE_02157] o ara::core::BasicString [SWS_CORE_03315], las cuales proporcionan índices de tipo size_type y son en parte noexcept, esta función opera a nivel de contenedor mediante iteradores.

La función miembro constante find de la clase ara::core::Map sirve para localizar de forma síncrona una entrada a partir de su clave [SWS_CORE_01491]. Para la llamada debe incluirse la cabecera #include "ara/core/map.h". Como parámetro, la función espera una referencia a la clave buscada const key_type &x. El comportamiento corresponde a la especificación de [map] en el estándar de C++, de modo que, si la búsqueda tiene éxito, se devuelve un const_iterator al elemento y, en caso contrario, presumiblemente se proporciona end() [SWS_CORE_01491]. Pregunta Q-dca69a1ec5423a8b (abierta)

En cuanto al tratamiento de errores, la función está declarada como not exception safe [SWS_CORE_01491]. Dado que el proceso de búsqueda se basa en la comparación de claves, es probable que las excepciones que surjan se deban principalmente a la operación de comparación definida por el usuario. Para este contenedor elemental no se han definido mensajes de error de DET ni de DEM. Al tratarse de una operación de lectura sobre una instancia constante, el acceso concurrente de varios hilos al mismo objeto es paralelizable según la semántica habitual de contenedores de C++, siempre que no se produzcan modificaciones simultáneas (interpretación). Pregunta Q-a8ec748711885418 (abierta)

En interacción con otras interfaces, el método complementa la variante no constante [SWS_CORE_01490], que devuelve un iterator modificable. Para operaciones de búsqueda heterogéneas sin conversión de tipos, en ara::core::Map también están disponibles sobrecargas de plantilla para instancias modificables [SWS_CORE_01492] y constantes [SWS_CORE_01493]. Asimismo, en el módulo Core existen funciones de búsqueda con el mismo nombre para clases de cadenas de caracteres como ara::core::BasicString [SWS_CORE_03407] y ara::core::StringView [SWS_CORE_02157].

La función miembro de plantilla find según [SWS_CORE_01492] sirve para localizar de forma síncrona un elemento dentro de una instancia de ara::core::Map a través del archivo de cabecera ara/core/map.h. Recibe un parámetro por referencia const K &x y devuelve un iterator modificable al par clave-valor encontrado o el iterador de fin del contenedor. La especificación remite al comportamiento de [map]; la forma genérica del parámetro probablemente deba interpretarse aquí como una búsqueda heterogénea de claves para comparar claves de búsqueda de tipo diferente sin conversión previa. Pregunta Q-425357890b9ea3fe (abierta)

En cuanto al tratamiento de errores y la seguridad frente a excepciones, la función está catalogada explícitamente como not exception safe ([SWS_CORE_01492]). En el payload no se definen códigos de error específicos, valores de retorno para estados de error ni notificaciones de DET/DEM. Si se produce una excepción durante la comparación o el recorrido interno, la llamada no ofrece ninguna garantía frente a excepciones.

En la interacción dentro de ara::core::Map, la función constituye la contrapartida no constante de la búsqueda heterogénea constante [SWS_CORE_01493], así como de las sobrecargas no genéricas [SWS_CORE_01490] y [SWS_CORE_01491], las cuales están vinculadas de forma fija a const key_type &x en cada caso. Difiere fundamentalmente de las funciones de búsqueda homónimas de otros contenedores como ara::core::StringView ([SWS_CORE_02157]) o ara::core::BasicString ([SWS_CORE_03315]), que realizan búsquedas de posición basadas en cadenas de caracteres y en parte están declaradas como noexcept.

usar

La función miembro de plantilla find en el espacio de nombres ara::core::Map sirve para localizar elementos en modo de solo lectura a partir de una clave x de tipo K [SWS_CORE_01493]. La función está definida en la cabecera #include "ara/core/map.h" y se invoca de forma síncrona sobre una instancia constante [SWS_CORE_01493]. Devuelve un const_iterator al elemento encontrado; interpretación: en caso de que la clave no exista, es probable que el iterador devuelto corresponda al iterador de fin del map, ya que según la especificación la semántica sigue el comportamiento de [map] [SWS_CORE_01493]. Pregunta Q-3fa354022f0bca9b (abierta)

Tratamiento de errores y condiciones límite

Respecto a la tolerancia a fallos, la función está catalogada explícitamente como not exception safe [SWS_CORE_01493]. En la especificación no se definen códigos de error específicos, valores de retorno para indicar errores ni notificaciones a DET o DEM. Quienes invoquen la función deben tener en cuenta que, si se producen excepciones durante el proceso de búsqueda o comparación, no se proporciona ninguna garantía de seguridad frente a excepciones [SWS_CORE_01493].

Interacción

Dentro de ara::core::Map, esta sobrecarga completa las operaciones de búsqueda:

• Complementa la variante de plantilla no constante iterator find(const K &x) [SWS_CORE_01492].
• Constituye la contrapartida genérica de las sobrecargas con const key_type &x fijo, las cuales están declaradas como no constante [SWS_CORE_01490] y constante [SWS_CORE_01491].

Por tanto, difiere de las operaciones homónimas en ara::core::StringView (p. ej. [SWS_CORE_02157]) y ara::core::BasicString (p. ej. [SWS_CORE_03315]), que operan sobre cadenas de caracteres, devuelven posiciones de tipo size_type y están declaradas como exception safe.

usar

La función insert en el contexto de ara::core::Map sirve para añadir sincrónicamente un elemento de valor por copia mediante el parámetro const value_type &x ([SWS_CORE_01460]). La operación se incluye a través del archivo de cabecera ara/core/map.h. El tipo de retorno std::pair<iterator, bool> sigue la especificación «As per corresponding usage in [map]»: Interpretación: en este caso, es probable que el iterador apunte al elemento recién insertado o ya existente, mientras que la bandera booleana señala la nueva inserción correcta. Pregunta Q-b059c1d0f4dd6665 (abierta)

Manejo de errores

En la especificación no se prevén códigos de error de AUTOSAR específicos, tales como mensajes de DET o DEM. La función está declarada expresamente como no segura frente a excepciones («not exception safe») ([SWS_CORE_01460]). Si falla una asignación interna de memoria o la copia del elemento, el contenedor no ofrece garantías de excepción ni de reversión (rollback); es de suponer que dicho fallo provocaría una interrupción o un estado indefinido. Pregunta Q-cbe74b301167bcc4 (abierta)

Concurrencia y restricciones

La llamada se realiza de forma síncrona en el hilo del llamador. Las operaciones del contenedor no disponen de sincronización integrada, por lo que la función no es reentrante respecto a la misma instancia. Los accesos concurrentes de lectura o escritura deben protegerse del lado del llamador.

Interacción

Para ara::core::Map existen sobrecargas complementarias de insert:

• Variantes basadas en movimiento para valores temporales ([SWS_CORE_01461], [SWS_CORE_01462]),
• Operaciones de inserción posicionales con sugerencia de iterador ([SWS_CORE_01463], [SWS_CORE_01464]),
• Listas de inicialización y de rango ([SWS_CORE_01466], [SWS_CORE_01467]), así como transferencias de manejadores de nodos ([SWS_CORE_01468], [SWS_CORE_01469]).

Se encuentran operaciones de inserción análogas con firmas adaptadas en otras clases de Core, como ara::core::Vector ([SWS_CORE_01367]) y ara::core::BasicString ([SWS_CORE_03093]).

La función miembro insert de ara::core::Map inserta un elemento de forma síncrona en el contenedor asociativo mediante semántica de movimiento a través de una referencia rvalue (value_type &&x) ([SWS_CORE_01461]). La declaración se realiza mediante el archivo de cabecera #include "ara/core/map.h" ([SWS_CORE_01461]). El comportamiento funcional se rige, según la especificación, por el uso correspondiente en [map] del estándar de C++ ([SWS_CORE_01461]). Como valor de retorno, la función proporciona un std::pair<iterator, bool>; interpretación: en este caso, es probable que el valor booleano señale si el elemento se insertó de nuevo, mientras que el iterador apunta al elemento dentro del contenedor ([SWS_CORE_01461]). Pregunta Q-e1901e26d8be3470 (abierta)

En lo referente al tratamiento de errores y la seguridad frente a excepciones, la función está clasificada explícitamente en la especificación como not exception safe ([SWS_CORE_01461]). No se especifican códigos de error ni mensajes de error de AUTOSAR como DET o DEM para esta llamada.

En la interacción dentro de ara::core::Map, esta sobrecarga representa la contraparte basada en rvalues de la variante de copia insert(const value_type &) ([SWS_CORE_01460]) y de la versión genérica de plantilla insert(P &&) ([SWS_CORE_01462]). Para operaciones de inserción con indicación de posición también están disponibles sobrecargas con iterador de sugerencia (hint) como insert(const_iterator, value_type &&) ([SWS_CORE_01464]), así como para handles de nodo a través de insert(node_type &&) ([SWS_CORE_01468]) utilizando insert_return_type ([SWS_CORE_01418]).

La función miembro de plantilla insert de la clase ara::core::Map sirve para la inserción síncrona de un par clave-valor compatible mediante una referencia de reenvío P&& x en la instancia de contenedor asociativo [SWS_CORE_01462]. Se incluye a través del encabezado #include "ara/core/map.h" y remite para su comportamiento a la semántica de [map] [SWS_CORE_01462]. Como valor de retorno proporciona un std::pair<iterator, bool> [SWS_CORE_01462]. Interpretación: el valor de retorno booleano probablemente indique si se creó una nueva entrada, mientras que el iterador apunta al elemento recién insertado o ya existente. Pregunta Q-64d2947d60792374 (abierta)

En cuanto al tratamiento de errores, la función está clasificada expresamente en la especificación como no segura frente a excepciones (not exception safe) [SWS_CORE_01462]. No se especifican códigos de error, mensajes de error ni interfaces a memorias de diagnóstico y de averías como DET o DEM para esta llamada.

En cuanto a concurrencia y condiciones de contorno, la llamada modifica el estado del mapa; por lo tanto, el acceso simultáneo a la misma instancia probablemente no sea reentrante y requiere protección externa contra carreras de datos. Pregunta (abierta) La ejecución se realiza de forma síncrona en el contexto del hilo que realiza la llamada.

En la interacción dentro de ara::core::Map, esta función genérica representa un complemento a las sobrecargas directas para const value_type& [SWS_CORE_01460] y value_type&& [SWS_CORE_01461]. Además, existen operaciones de inserción basadas en posición con sugerencia de iterador [SWS_CORE_01465], operaciones de rango [SWS_CORE_01466], así como la inserción de node handles mediante insert_return_type [SWS_CORE_01418] [SWS_CORE_01468].