clase ara::core::Vector

Uso y contexto de llamada

La función miembro de plantilla assign para ara::core::Vector sustituye el contenido actual del vector por los elementos del rango [first, last) conforme al uso correspondiente en std::vector [SWS_CORE_01328]. La función está definida en el archivo de cabecera #include "ara/core/vector.h", recibe dos iteradores de entrada y no devuelve ningún valor (void) [SWS_CORE_01328].

Tratamiento de errores y seguridad frente a excepciones

La función de asignación está clasificada como no segura frente a excepciones (not exception safe) [SWS_CORE_01328]. Si durante el procesamiento de los elementos o en asignaciones de memoria internas necesarias se produce una excepción, el contenedor permanecerá posiblemente en un estado incompleto sin garantías de seguridad definidas.

Concurrencia y condiciones de contorno

Para llamadas concurrentes con uso simultáneo de la misma instancia de ara::core::Vector, es probable que se requiera una sincronización externa, ya que la especificación no garantiza la seguridad para subprocesos. Pregunta Q-5ada879738b3856d (abierta) Además, un requisito previo para la ejecución sin errores es que first y last abarquen un rango de iteradores válido.

Interacción en el módulo core

Junto a la asignación de rangos mediante iteradores, en ara::core::Vector se encuentran disponibles sobrecargas con recuento y valor de referencia [SWS_CORE_01329], así como para std::initializer_list<T> [SWS_CORE_01330], que también están declaradas como no seguras frente a excepciones. Existen asimismo patrones de asignación comparables en el contexto modular de ara::core::BasicString [SWS_CORE_03091].

usar

La función assign pertenece a la clase contenedora ara::core::Vector y se proporciona mediante el archivo de encabezado #include "ara/core/vector.h" [SWS_CORE_01329]. Con la firma void assign (size_type n, const T &u);, reemplaza por completo el contenido actual del vector por n elementos con el valor u. La llamada se realiza de forma síncrona y no proporciona valor de retorno (void). Conforme a la especificación, el comportamiento se rige por el uso correspondiente en el contenedor estándar [vector] [SWS_CORE_01329], con lo cual es de suponer que se refiere a la semántica de std::vector::assign. Pregunta Q-3630162224047ee0 (abierta)

Manejo de errores

En lo referente a la tolerancia a fallos, la función está clasificada explícitamente como not exception safe [SWS_CORE_01329]. No se definen códigos de error específicos de AUTOSAR, clases de error ni avisos a DET o DEM. Si ocurre una excepción durante la asignación de memoria o al asignar los elementos, es de suponer que la función no ofrezca garantías para la restauración del estado original del objeto. Pregunta Q-f4eb9afa74847bf7 (abierta)

Concurrencia y restricciones

Dado que assign modifica el estado y potencialmente la capacidad de la instancia del contenedor, la llamada no es reentrante en la misma instancia. A falta de compromisos específicos de seguridad de hilos en la especificación, es de suponer que un acceso concurrente de lectura o escritura al mismo objeto Vector sin sincronización externa no sea seguro frente a hilos. Pregunta Q-1df95afd2340ec57 (abierta)

Interacción

La función forma, junto con otras sobrecargas de la clase ara::core::Vector, la interfaz para la reasignación del contenido de vectores:

• Asignación basada en iteradores sobre un rango assign(InputIterator first, InputIterator last) según [SWS_CORE_01328].
• Asignación mediante una lista de inicialización assign(std::initializer_list<T>) según [SWS_CORE_01330].

Ambas sobrecargas alternativas comparten con [SWS_CORE_01329] la propiedad de estar especificadas como not exception safe.

La función miembro assign de la clase ara::core::Vector reemplaza todo el contenido anterior de una instancia de vector de forma síncrona por los elementos de la lista de inicialización proporcionada std::initializer_list<T> ([SWS_CORE_01330]). El comportamiento funcional sigue el uso correspondiente del contenedor estándar en [vector] ([SWS_CORE_01330]). La función no tiene valor de retorno (void) y se declara a través del encabezado ara/core/vector.h ([SWS_CORE_01330]).

Para el tratamiento de errores, se establece que el método está clasificado como not exception safe ([SWS_CORE_01330]). Interpretación: si se produce una excepción durante la asignación de memoria o al copiar o mover los elementos, la implementación probablemente no ofrezca una seguridad frente a excepciones fuerte; es probable que el vector permanezca en un estado modificado o incompleto. Pregunta Q-ac196ecfba85d821 (abierta)

En interacción con otras interfaces de ara::core::Vector, la función complementa sobrecargas de asignación alternativas, como la inicialización mediante rangos de iteradores ([SWS_CORE_01328]) y la asignación repetida de un único valor ([SWS_CORE_01329]). Todas estas variantes de assign comparten la propiedad de no ser seguras frente a excepciones. Una semántica de asignación comparable mediante std::initializer_list también se encuentra dentro de la biblioteca central en ara::core::BasicString ([SWS_CORE_03092]).

Uso y semántica

La función miembro at proporciona un acceso de lectura síncrono a un elemento del contenedor ara::core::Vector en el índice indicado n y devuelve una const_reference al elemento [SWS_CORE_01354]. La declaración está disponible a través de la cabecera ara/core/vector.h [SWS_CORE_01354]. La semántica se corresponde con la función estándar std::vector::at del estándar de C++, pero se diferencia en el tratamiento de errores [SWS_CORE_01354].

Tratamiento de errores y condiciones límite

Si se solicita un índice que alcance o supere el tamaño del contenedor (n >= size()), se desencadena una IsoStdOutOfRangeViolation en lugar de la excepción estándar std::out_of_range [SWS_CORE_01354]. La función está declarada como not exception safe [SWS_CORE_01354]. Interpretación: al no lanzarse ninguna excepción de C++, es probable que el desencadenamiento de la infracción provoque una interrupción del flujo del programa que potencialmente pueda interactuar con mecanismos de tratamiento como AddAbortHandler [SWS_CORE_00054]. Pregunta Q-2182d648ff4a28b8 (abierta)

Interacción en el módulo

Para accesos de modificación está disponible la sobrecarga no constante con retorno reference, la cual sigue la misma ruta de error [SWS_CORE_01355]. El comportamiento de discrepancia idéntico con IsoStdOutOfRangeViolation se encuentra también en otros tipos de datos centrales como ara::core::Array [SWS_CORE_01273] [SWS_CORE_01274] y ara::core::BasicString [SWS_CORE_03063].

La función miembro at de la clase ara::core::Vector ([SWS_CORE_01355]), proporcionada a través de la cabecera #include "ara/core/vector.h", permite el acceso indizado de lectura y escritura a elementos individuales de un vector. La función acepta un índice de posición n de tipo size_type y devuelve una referencia modificable (reference) al elemento en la posición especificada. La semántica sigue la implementación correspondiente en [vector]. Interpretación: Dado que la interfaz está declarada de forma síncrona según el estándar de C++, es probable que la ejecución se lleve a cabo de manera bloqueante directamente en el contexto del hilo que realiza la llamada. Pregunta Q-81f43622c244ce91 (abierta)

A diferencia del vector de ISO C++ estándar, en caso de rebasamiento de índice (n >= size()) la función desencadena la vulneración IsoStdOutOfRangeViolation en lugar de la excepción estándar std::out_of_range ([SWS_CORE_01355]). En la especificación, la función está clasificada como no segura ante excepciones (not exception safe) ([SWS_CORE_01355]). Interpretación: Dado que para este acceso al vector no se especifican mecanismos de sincronización, es probable que un acceso concurrente no protegido a la misma instancia no sea seguro para hilos. Pregunta Q-e65ae0c574610719 (abierta)

Para el acceso de solo lectura constante está disponible la sobrecarga const_reference at(size_type n) const, que también notifica IsoStdOutOfRangeViolation y se considera no segura ante excepciones ([SWS_CORE_01354]). La misma semántica de vulneración ante accesos erróneos es utilizada también por contenedores y tipos afines de la biblioteca Core, entre ellos ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]), ara::core::Map ([SWS_CORE_01456], [SWS_CORE_01457]), ara::core::StringView ([SWS_CORE_02133]), así como ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).

Uso y semántica

El método clear() de la clase ara::core::Vector sirve para vaciar completamente el vector según [SWS_CORE_01375]. La función está declarada en el encabezado ara/core/vector.h, se puede invocar de forma síncrona, no recibe parámetros y no devuelve ningún valor (void). Su semántica funcional se rige por la especificación correspondiente para [vector]. Interpretación: esto probablemente signifique que se destruyen todos los elementos presentes en el vector y que el número de elementos pasa a ser 0, manteniendo previsiblemente inalterada la capacidad de memoria asignada. Pregunta Q-ecde315e61455c32 (abierta)

Tratamiento de errores y seguridad frente a excepciones

A la invocación le corresponde la designación noexcept, así como la clasificación como segura frente a excepciones (exception safe) según [SWS_CORE_01375]. Dado que se garantiza que el método no lanza excepciones, no existen códigos de error específicos y no se emiten mensajes de error a DET ni a DEM en caso de fallo.

Interacción con contenedores afines

El concepto de una función clear() segura frente a excepciones se traslada de manera coherente a otras estructuras de datos en ara::core. Así, ara::core::Map en el encabezado ara/core/map.h proporciona un método clear() idéntico según [map] [SWS_CORE_01485]. Del mismo modo, ara::core::BasicString en el encabezado ara/core/string.h ofrece una operación clear() equivalente según [basic.string] [SWS_CORE_03057].

La función miembro crbegin de ara::core::Vector proporciona, según [SWS_CORE_01342], un iterador inverso constante (const_reverse_iterator) al último elemento de la secuencia. La llamada se realiza de forma síncrona y sin parámetros a través del encabezado ara/core/vector.h. El comportamiento corresponde a la especificación de la biblioteca estándar de C++ subyacente para [vector]. En un contenedor vacío, el iterador devuelto probablemente corresponda al valor de crend() (interpretación basada en [vector]). Pregunta Q-a2badba87f86486c (abierta)

Con respecto al tratamiento de errores, la interfaz cuenta con el identificador noexcept y está declarada como segura frente a excepciones (exception safe) ([SWS_CORE_01342]). Las llamadas no lanzan excepciones ni notifican errores a las supervisiones de tiempo de ejecución o de diagnóstico.

En cuanto a concurrencia y restricciones, el método está cualificado como const. El acceso de lectura simultáneo a la misma instancia desde múltiples hilos probablemente sea reentrante y seguro para subprocesos, siempre que no se ejecuten operaciones de escritura concurrentes en el vector (interpretación análoga al modelo de contenedores de C++). Pregunta Q-094ba5878c1adc74 (abierta)

En el módulo core, el concepto de iteración inversa constante se implementa de manera consistente a través de diversos tipos. Se encuentran interfaces similares en ara::core::Array ([SWS_CORE_01260]), ara::core::Map ([SWS_CORE_01450]), ara::core::Span ([SWS_CORE_01978]), ara::core::StringView ([SWS_CORE_02126]), así como en ara::core::BasicString ([SWS_CORE_03049]).

La función miembro crend de la clase ara::core::Vector proporciona un iterador inverso constante que apunta al elemento teórico anterior al primer elemento del vector [SWS_CORE_01343]. La semántica sigue el uso correspondiente en el estándar C++ para std::vector («As per corresponding usage in [vector]») [SWS_CORE_01343].

Uso y comportamiento

• Contexto de llamada y parámetros: El método no tiene parámetros y está declarado como const, de modo que puede invocarse de forma síncrona tanto en instancias constantes como no constantes de ara::core::Vector [SWS_CORE_01343].
• Valor de retorno: Se devuelve un const_reverse_iterator que marca el final lógico de una iteración en sentido inverso [SWS_CORE_01343].

Tratamiento de errores y seguridad frente a excepciones

La función está especificada con noexcept y, según la especificación, se considera segura frente a excepciones («exception safe») [SWS_CORE_01343]. No se devuelven códigos de error específicos y no se producen excepciones.

Interacción con contenedores afines

El concepto de un iterador inverso constante al punto final de una iteración inversa se proporciona de manera uniforme en todos los contenedores de ara::core. Existen interfaces similares con idéntico tratamiento de excepciones (noexcept), entre otros, para ara::core::Array [SWS_CORE_01261], ara::core::Map [SWS_CORE_01451], ara::core::Span [SWS_CORE_01979], ara::core::StringView [SWS_CORE_02127], así como ara::core::BasicString [SWS_CORE_03050].

La función emplace inserta un elemento directamente en un ara::core::Vector en la posición especificada, reenviando los argumentos transferidos [SWS_CORE_01366]. La declaración se encuentra en la cabecera #include "ara/core/vector.h" y sigue el uso correspondiente en [vector] [SWS_CORE_01366].

usar

La llamada a emplace se realiza de forma síncrona y acepta como parámetros un iterador de posición position de tipo const_iterator, así como un paquete de parámetros args de tipo Args&&... [SWS_CORE_01366]. Como valor de retorno, la función proporciona un iterator al elemento recién construido [SWS_CORE_01366].

Tratamiento de errores y concurrencia

Para emplace en ara::core::Vector, la seguridad frente a excepciones se especifica explícitamente como not exception safe [SWS_CORE_01366]. En el estándar no se definen códigos de error específicos ni mensajes de DET o DEM. Interpretación: a falta de mecanismos de sincronización internos, la llamada concurrente a emplace sobre la misma instancia no debería ser segura para hilos sin una protección externa. Pregunta Q-d72278df37e86c8a (abierta)

Interacción

Dentro de ara::core, la seguridad frente a excepciones para emplace varía en función del tipo:

• En ara::core::Map, emplace también se define como not exception safe, pero devuelve std::pair<iterator, bool> [SWS_CORE_01458].
• En ara::core::Optional, las variantes son condicionalmente seguras frente a excepciones ([SWS_CORE_01119], [SWS_CORE_01120]) o, para referencias, totalmente seguras frente a excepciones [SWS_CORE_01164].
• En ara::core::Variant, emplace está declarado como conditionally exception safe con noexcept ([SWS_CORE_01661], [SWS_CORE_01662], [SWS_CORE_01663], [SWS_CORE_01664]).

usar

La función miembro plantilla emplace_back de la clase ara::core::Vector sirve, según [SWS_CORE_01362], para construir un nuevo elemento directamente al final del vector. Los parámetros pasados Args&&... args se reenvían directamente al constructor del tipo de elemento de acuerdo con la semántica de [vector]. Como valor de retorno, la función devuelve una referencia (reference) al elemento recién creado. Para su uso debe incluirse la cabecera #include "ara/core/vector.h" [SWS_CORE_01362].

Tratamiento de errores y seguridad frente a excepciones

En cuanto a la seguridad frente a excepciones, la operación está declarada explícitamente en [SWS_CORE_01362] como not exception safe. En la especificación no se definen códigos de error específicos, valores de reserva ni notificaciones a servicios de error como DET o DEM.

Restricciones y comportamiento

Debido a la propiedad not exception safe y a su orientación según [vector], en caso de error —por ejemplo, si falla una asignación de memoria o la construcción— probablemente no haya garantía de conservación del estado previo del contenedor (interpretación). Pregunta Q-ca44b2f27d8ae1c8 (abierta) Por lo tanto, los llamadores deben asegurarse de evitar de antemano las posibles condiciones de error.

La función erase de la clase ara::core::Vector sirve, según [SWS_CORE_01372], para la eliminación síncrona de un único elemento en la posición designada por el parámetro position (const_iterator). Como valor de retorno proporciona un iterator al elemento siguiente o al final del contenedor si el elemento eliminado se encontraba en la última posición, conforme a la semántica referenciada en [vector]. La función está declarada en el archivo de encabezado #include "ara/core/vector.h".

Con respecto al tratamiento de errores, la operación se designa explícitamente en la especificación como no segura frente a excepciones («not exception safe») [SWS_CORE_01372]. No se definen retornos de error específicos ni mensajes DET o DEM; por lo tanto, es probable que los iteradores no válidos o no desreferenciables provoquen un comportamiento indefinido. Pregunta Q-efa4c40e48a6f98d (abierta) Debido al desplazamiento de los elementos en el vector, como interpretación: debe asumirse que los iteradores y referencias posteriores quedan invalidados, tal como corresponde a la semántica estándar de [vector].

En la interacción dentro de ara::core::Vector, además de la eliminación en una posición individual, existe la sobrecarga erase(first, last) para rangos completos según [SWS_CORE_01373]. Se encuentran interfaces análogas para eliminar entradas en otros contenedores de la biblioteca Adaptive Core: ara::core::Map proporciona sobrecargas basadas en posiciones y en claves ([SWS_CORE_01480], [SWS_CORE_01481], [SWS_CORE_01482], [SWS_CORE_01483]), mientras que ara::core::BasicString incluye variantes basadas en índices e iteradores ([SWS_CORE_03102], [SWS_CORE_03103], [SWS_CORE_03104]).

La función miembro erase de la clase ara::core::Vector sirve para eliminar un rango de elementos del vector según la especificación [SWS_CORE_01373]. La declaración está disponible a través del encabezado ara/core/vector.h. La semántica sigue el uso correspondiente en el vector estándar («As per corresponding usage in [vector]»). Como parámetros se pasan dos iteradores first y last que delimitan el rango a eliminar; se devuelve un iterator al elemento siguiente.

Con respecto al tratamiento de errores y la seguridad frente a excepciones, la operación está clasificada explícitamente en la especificación como «not exception safe» [SWS_CORE_01373]. A diferencia de otras operaciones de contenedor, para esta función no se definen códigos de error o violaciones (violations) específicos. Si se produce un error durante la ejecución, es probable que esto deje al contenedor en un estado inconsistente. Pregunta (abierta)

En cuanto a la concurrencia y las restricciones, la especificación guarda silencio; sin embargo, es probable que las operaciones modificadoras en ara::core::Vector no sean reentrantes y previsiblemente requieran una protección externa en operaciones multihilo. Pregunta Q-07fc291a523a82f1 (abierta)

En interacción con otras interfaces del módulo Core, esta función complementa la sobrecarga para la eliminación de un único elemento en una posición determinada mediante iterator erase(const_iterator position) [SWS_CORE_01372]. También se definen eliminaciones de rangos correspondientes según el mismo patrón para contenedores asociativos como ara::core::Map a través de [SWS_CORE_01483], así como cadenas de caracteres en ara::core::BasicString a través de [SWS_CORE_03104].

usar

La función miembro insert de la clase ara::core::Vector sirve para la inserción síncrona de un elemento en una posición predeterminada [SWS_CORE_01367]. Está definida en la cabecera #include "ara/core/vector.h" [SWS_CORE_01367]. La función recibe como parámetros un iterador position de tipo const_iterator, que marca la posición de destino, así como una referencia constante x al objeto a insertar de tipo const T & [SWS_CORE_01367]. El valor de retorno es un iterator que apunta al elemento recién insertado [SWS_CORE_01367]. El comportamiento funcional sigue el uso en el vector estándar («As per corresponding usage in [vector]») [SWS_CORE_01367].

Tratamiento de errores y restricciones

La especificación clasifica la función expresamente como no segura frente a excepciones («not exception safe») [SWS_CORE_01367]. No se definen códigos de error específicos, valores de retorno para casos de error ni mensajes a DET o DEM. Interpretación: si falla una asignación interna de memoria o la copia del elemento, es de suponer que no exista garantía alguna para la conservación del estado del contenedor ni para la validez de los iteradores. Pregunta Q-d2b5552bb124d16e (abierta)

Interacción

Dentro de ara::core::Vector existen varias sobrecargas de insert que permiten operaciones de inserción alternativas:

• Inserción de un elemento mediante referencia rvalue T &&x [SWS_CORE_01368],
• Inserción de una cantidad determinada de elementos idénticos con size_type n, const T &x [SWS_CORE_01369],
• Inserción de una secuencia mediante un rango de iteradores [first, last) [SWS_CORE_01370],
• Inserción mediante una lista de inicialización std::initializer_list<T> [SWS_CORE_01371].

En el módulo core, definen métodos insert análogos tanto contenedores asociativos como ara::core::Map [SWS_CORE_01460], así como clases de cadenas de caracteres como ara::core::BasicString [SWS_CORE_03093].

usar

El método insert según [SWS_CORE_01368] está definido en la cabecera #include "ara/core/vector.h" como función miembro de la clase ara::core::Vector. Sirve para la inserción síncrona de un elemento mediante una referencia rvalue (T&& x) en la posición anterior al iterador position. Conforme a la referencia a [vector], es probable que la función transfiera el contenido de x al vector mediante semántica de movimiento y devuelva un iterator al elemento recién insertado. Pregunta Q-97f2551da8fd303f (abierta)

Tratamiento de errores y restricciones

La especificación clasifica la función en [SWS_CORE_01368] como not exception safe. No se definen códigos de error específicos, valores de retorno para indicación de errores ni mensajes a DET o DEM. Interpretación: si falla una asignación de memoria interna o el desplazamiento de los elementos, es probable que no se garantice la seguridad frente a excepciones, lo que podría dejar el contenedor en un estado inconsistente o provocar la cancelación. Pregunta Q-297ef8ff6f6eb76b (abierta) Además, es probable que no exista protección interna de concurrencia, por lo que los accesos simultáneos deben sincronizarse externamente.

Interacción

La variante rvalue [SWS_CORE_01368] conforma una interfaz coherente con otras sobrecargas de insert de ara::core::Vector:

• [SWS_CORE_01367]: Inserción por copia de un valor mediante referencia lvalue (const T& x).
• [SWS_CORE_01369]: Inserción de n copias de un valor (size_type n, const T& x).
• [SWS_CORE_01370]: Inserción de una secuencia a través de un rango de iteradores (InputIterator first, InputIterator last).
• [SWS_CORE_01371]: Inserción de una lista mediante std::initializer_list<T>.

La función miembro insert de [SWS_CORE_01369] pertenece a la clase ara::core::Vector y se proporciona mediante el archivo de cabecera #include "ara/core/vector.h". La operación síncrona sirve para insertar múltiples elementos idénticos. Interpretación: según la referencia especificada «As per corresponding usage in [vector]», la llamada debería insertar exactamente n copias del valor pasado x inmediatamente antes de la posición de iterador position en el vector y devolver un iterator al primer elemento recién insertado. Pregunta Q-c92add148c490868 (abierta)

En cuanto al tratamiento de errores y la robustez, la función está clasificada expresamente en [SWS_CORE_01369] como «not exception safe». Para esta llamada al método no están previstos códigos de error específicos de AUTOSAR ni avisos a DET o DEM.

Respecto a las condiciones de concurrencia y de invocación, la especificación no contiene garantías específicas. Presumiblemente, la modificación del contenedor requiere sincronización externa al igual que en los vectores estándar, ya que los accesos concurrentes de escritura o lectura probablemente no sean seguros para subprocesos. Pregunta (abierta)

Dentro de ara::core::Vector existen, además de esta sobrecarga para valores repetidos, otras variantes de insert:

• Inserción de un valor individual por copia ([SWS_CORE_01367]) o por semántica de movimiento ([SWS_CORE_01368]).
• Inserción de un rango de valores mediante iteradores de entrada ([SWS_CORE_01370]) o mediante un std::initializer_list ([SWS_CORE_01371]).

La función miembro de plantilla insert del contenedor secuencial ara::core::Vector ([SWS_CORE_01370]) procedente de la cabecera #include "ara/core/vector.h" inserta una secuencia de elementos de forma síncrona en el vector. El rango a insertar se determina mediante los iteradores de entrada first y last y se sitúa inmediatamente antes de la posición indicada por position (tipo const_iterator). Como valor de retorno, la función devuelve un iterator que apunta al primer elemento insertado. La semántica técnica se describe por parte de la especificación como «As per corresponding usage in [vector]» ([SWS_CORE_01370]); Interpretación: esto debería corresponder al comportamiento de inserción de rangos estandarizado de std::vector. Pregunta Q-c6cd06fb1964ead6 (abierta)

Respecto al tratamiento de errores y la robustez, la función está especificada expresamente como not exception safe ([SWS_CORE_01370]). En el alcance de la especificación no están previstos códigos de error especiales, excepciones ni mensajes a monitores de errores y diagnóstico (como DET o DEM).

En el marco de la interfaz de ara::core::Vector, esta sobrecarga de rango complementa los demás métodos de inserción:

• la inserción de un valor individual por copia ([SWS_CORE_01367]) o por semántica de movimiento ([SWS_CORE_01368]),
• la inserción de un número determinado de valores idénticos ([SWS_CORE_01369]),
• así como la inserción desde una lista de inicialización mediante std::initializer_list ([SWS_CORE_01371]).

Todas las sobrecargas mencionadas dentro del vector comparten la restricción de no ser seguras frente a excepciones ([SWS_CORE_01367], [SWS_CORE_01371]).

La función miembro síncrona insert de la clase ara::core::Vector inserta los elementos de una lista de inicialización en una posición predeterminada del contenedor [SWS_CORE_01371]. Está declarada en el archivo de encabezado ara/core/vector.h [SWS_CORE_01371]. Como parámetros, la función espera un iterador position de tipo const_iterator que marca la posición de inserción, así como il de tipo std::initializer_list<T> [SWS_CORE_01371]. El valor de retorno es un iterator al primer elemento insertado o bien a position si la lista está vacía [SWS_CORE_01371].

En cuanto al tratamiento de fallos y la robustez, la especificación clasifica esta operación explícitamente como «not exception safe» [SWS_CORE_01371]. No se contemplan códigos de error específicos de AUTOSAR ni mensajes de fallo (DET/DEM). Interpretación: Mediante la referencia «As per corresponding usage in [vector]», el comportamiento en tiempo de ejecución, incluidas posibles reasignaciones y la consiguiente invalidación de iteradores existentes, debería corresponder a la semántica de std::vector::insert [SWS_CORE_01371]. Pregunta Q-67ac8e3de4d4ce7a (abierta) No se especifican mecanismos de sincronización particulares para accesos concurrentes.

En el módulo core, la función se enmarca en el contexto de otras operaciones de inserción de ara::core::Vector:

• Inserción de un elemento individual mediante copia [SWS_CORE_01367] o semántica de movimiento [SWS_CORE_01368],
• Inserción de n copias de un valor [SWS_CORE_01369],
• Inserción basada en rangos mediante dos iteradores de entrada [SWS_CORE_01370].

Todas las sobrecargas en ara::core::Vector comparten la propiedad de no ser seguras frente a excepciones [SWS_CORE_01367], [SWS_CORE_01368], [SWS_CORE_01369], [SWS_CORE_01370].

Uso y semántica

La función miembro pop_back del contenedor ara::core::Vector sirve para eliminar de forma síncrona el último elemento [SWS_CORE_01365]. La función está declarada en el archivo de cabecera ara/core/vector.h y posee la signatura void pop_back () [SWS_CORE_01365]. Para el comportamiento funcional, AUTOSAR remite explícitamente al uso correspondiente en [vector], de modo que no se pasan parámetros y no existe valor de retorno [SWS_CORE_01365].

Tratamiento de errores y seguridad frente a excepciones

Respecto al tratamiento de errores, la especificación indica la propiedad not exception safe [SWS_CORE_01365]. Dado que no se definen códigos de error específicos, valores de retorno ni mecanismos de comprobación en la carga útil, no existe un tratamiento de errores integrado ante llamadas no permitidas [SWS_CORE_01365]. Interpretación: antes de la llamada, el llamador debe asegurarse de que el vector no esté vacío; una llamada sobre una instancia vacía probablemente dé lugar a un comportamiento indefinido de forma análoga a [vector]. Pregunta Q-add313a489db4726 (abierta)

Interacción y requisitos relacionados

Un patrón correspondiente se encuentra en la clase ara::core::BasicString de ara/core/string.h, cuya función pop_back elimina el último carácter según [basic.string] y está especificada igualmente como not exception safe [SWS_CORE_03105]. Ambas definiciones homogeneizan la modificación de estructuras de datos secuenciales en el módulo core [SWS_CORE_01365], [SWS_CORE_03105].

usar

La función miembro push_back en el alcance de ara::core::Vector inserta un elemento pasado mediante copia al final del contenedor [SWS_CORE_01363]. Está definida a través de la cabecera #include "ara/core/vector.h", toma una referencia a un valor constante const T &x y no tiene valor de retorno (void) [SWS_CORE_01363]. La llamada se realiza de forma síncrona en el contexto del llamador.

Tratamiento de errores y seguridad frente a excepciones

La especificación difiere de [vector] en que la función está declarada como condicionalmente noexcept: se garantiza que no lance excepciones si y solo si std::is_nothrow_copy_assignable<T>::value se cumple [SWS_CORE_01363]. En consecuencia, la seguridad ante excepciones se define como «conditionally exception safe» [SWS_CORE_01363]. No se definen códigos de error específicos ni mensajes de error a través de DET o DEM para esta función.

Interacción y requisitos relacionados

Para objetos móviles, ara::core::Vector proporciona la sobrecarga void push_back(T &&x), cuya propiedad noexcept está vinculada de manera análoga a std::is_nothrow_move_assignable<T>::value [SWS_CORE_01364]. Por el contrario, push_back en ara::core::BasicString no posee garantía noexcept y está clasificada como «not exception safe» [SWS_CORE_03083].

Interpretación: es probable que el comportamiento interno de memoria y de reasignación durante la inserción se oriente, prescindiendo de la declaración noexcept específica, por las directrices del estándar C++ para [vector]. Pregunta Q-202fb07b334cde64 (abierta)

La función miembro push_back de ara::core::Vector sirve para añadir de forma síncrona un elemento al final del vector utilizando semántica de movimiento ([SWS_CORE_01364]). Se proporciona a través de la cabecera #include "ara/core/vector.h", recibe una referencia rvalue T &&x y no tiene valor de retorno (void) ([SWS_CORE_01364]).

En lo relativo al tratamiento de errores y al comportamiento ante excepciones, se aplican las siguientes propiedades:

• El método está clasificado como condicionalmente seguro frente a excepciones (conditionally exception safe) ([SWS_CORE_01364]).
• La garantía noexcept está vinculada al tipo: noexcept(std::is_nothrow_move_assignable<T>::value) ([SWS_CORE_01364]). Si el operador de asignación por movimiento de T no está declarado como libre de excepciones, es de esperar que se produzcan excepciones durante asignaciones de memoria o desplazamientos de elementos. Pregunta Q-3b8b58d0b218fe21 (abierta)

El funcionamiento sigue la semántica habitual de [vector], pero difiere debido a la declaración noexcept condicional ([SWS_CORE_01364]). Dado que la operación modifica el contenedor, es probable que los accesos simultáneos a la misma instancia sin sincronización externa no sean seguros para subprocesos. Pregunta (abierta)

En la interacción de las interfaces, esta variante de movimiento complementa la sobrecarga de copia push_back(const T &x) ([SWS_CORE_01363]), la cual está vinculada de forma análoga a is_nothrow_copy_assignable. Debe distinguirse de la función miembro homónima en ara::core::BasicString ([SWS_CORE_03083]), que añade caracteres individuales y está definida como no segura frente a excepciones.