classe ara::core::Vector

Utilização e contexto de chamada

A função de membro template assign para ara::core::Vector substitui o conteúdo atual do vetor pelos elementos do intervalo [first, last) de acordo com o uso correspondente em std::vector [SWS_CORE_01328]. A função é definida no arquivo de cabeçalho #include "ara/core/vector.h", recebe dois iteradores de entrada e não retorna nenhum valor (void) [SWS_CORE_01328].

Tratamento de erros e segurança contra exceções

A função de atribuição é classificada como não segura contra exceções (not exception safe) [SWS_CORE_01328]. Se ocorrer uma exceção durante o processamento de elementos ou em alocações de memória internas necessárias, o contêiner poderá permanecer em um estado incompleto sem garantias de segurança definidas.

Simultaneidade e condições marginais

Para chamadas concorrentes, presume-se que seja necessária sincronização externa no caso de uso simultâneo da mesma instância de ara::core::Vector, uma vez que a especificação não garante segurança de threads. Pergunta Q-5ada879738b3856d (aberta) Além disso, o pré-requisito para o processamento sem erros é que first e last definam um intervalo de iteradores válido.

Interação no módulo core

Além da atribuição de intervalo por meio de iteradores, estão disponíveis em ara::core::Vector sobrecargas com contagem e valor de referência [SWS_CORE_01329], bem como para std::initializer_list<T> [SWS_CORE_01330], as quais também são declaradas como não seguras contra exceções. Padrões de atribuição comparáveis também existem no contexto de módulo de ara::core::BasicString [SWS_CORE_03091].

usar

A função assign pertence à classe de contêiner ara::core::Vector e é disponibilizada por meio do arquivo de cabeçalho #include "ara/core/vector.h" [SWS_CORE_01329]. Com a assinatura void assign (size_type n, const T &u);, ela substitui completamente o conteúdo atual do vetor por n elementos com o valor u. A chamada ocorre de forma síncrona e não fornece valor de retorno (void). De acordo com a especificação, o comportamento segue o uso correspondente no contêiner padrão [vector] [SWS_CORE_01329], o que provavelmente se refere à semântica de std::vector::assign. Pergunta Q-3630162224047ee0 (aberta)

Tratamento de erros

No que se refere à resiliência a falhas, a função é classificada explicitamente como not exception safe [SWS_CORE_01329]. Não são definidos códigos de erro específicos de AUTOSAR, classes de erro ou mensagens para DET ou DEM. Se ocorrer uma exceção durante a alocação de memória ou na atribuição dos elementos, a função provavelmente não oferece garantias para a restauração do estado original do objeto. Pergunta Q-f4eb9afa74847bf7 (aberta)

Simultaneidade e restrições

Como assign modifica o estado e potencialmente a capacidade da instância do contêiner, a chamada não é reentrante na mesma instância. Na ausência de garantias específicas de segurança de thread na especificação, um acesso concorrente de leitura ou escrita ao mesmo objeto Vector sem sincronização externa provavelmente não será seguro para threads. Pergunta Q-1df95afd2340ec57 (aberta)

Interação

Junto com outras sobrecargas da classe ara::core::Vector, a função compõe a interface para a nova atribuição de conteúdos de vetores:

• Atribuição baseada em iterador sobre um intervalo assign(InputIterator first, InputIterator last) de acordo com [SWS_CORE_01328].
• Atribuição por meio de uma lista de inicialização assign(std::initializer_list<T>) de acordo com [SWS_CORE_01330].

Ambas as sobrecargas alternativas compartilham com [SWS_CORE_01329] a propriedade de serem especificadas como not exception safe.

A função-membro assign da classe ara::core::Vector substitui de forma síncrona todo o conteúdo anterior de uma instância de vetor pelos elementos da lista de inicialização std::initializer_list<T> fornecida ([SWS_CORE_01330]). O comportamento funcional segue o uso correspondente do contêiner padrão em [vector] ([SWS_CORE_01330]). A função não possui valor de retorno (void) e é declarada por meio do cabeçalho ara/core/vector.h ([SWS_CORE_01330]).

Para o tratamento de erros, está definido que o método é classificado como not exception safe ([SWS_CORE_01330]). Interpretação: Se ocorrer uma exceção durante a alocação de memória ou ao copiar ou mover os elementos, a implementação provavelmente não oferece uma forte segurança contra exceções; o vetor deve permanecer em um estado alterado ou incompleto. Pergunta Q-ac196ecfba85d821 (aberta)

Na interação com outras interfaces de ara::core::Vector, a função complementa sobrecargas alternativas de atribuição, como a inicialização por meio de intervalos de iteradores ([SWS_CORE_01328]) e a atribuição repetida de um valor individual ([SWS_CORE_01329]). Todas essas variantes de assign compartilham a propriedade de não serem seguras contra exceções. Uma semântica de atribuição comparável mediante std::initializer_list encontra-se dentro da biblioteca principal também em ara::core::BasicString ([SWS_CORE_03092]).

Utilização e semântica

A função-membro at fornece acesso de leitura síncrono a um elemento do contêiner ara::core::Vector no índice especificado n e retorna uma const_reference para o elemento [SWS_CORE_01354]. A declaração está disponível por meio do cabeçalho ara/core/vector.h [SWS_CORE_01354]. A semântica corresponde à função padrão std::vector::at do padrão C++, mas difere no tratamento de erros [SWS_CORE_01354].

Tratamento de erros e condições de contorno

Se for requisitado um índice que atinja ou exceda o tamanho do contêiner (n >= size()), uma IsoStdOutOfRangeViolation é disparada em vez da exceção padrão std::out_of_range [SWS_CORE_01354]. A função está declarada como not exception safe [SWS_CORE_01354]. Interpretação: como nenhuma exceção C++ é lançada, o disparo da violação deve provavelmente levar a uma interrupção do fluxo do programa, a qual pode potencialmente interagir com mecanismos de tratamento como AddAbortHandler [SWS_CORE_00054]. Pergunta Q-2182d648ff4a28b8 (aberta)

Interação no módulo

Para acessos modificadores, está disponível a sobrecarga não constante com o retorno reference, que segue o mesmo caminho de erro [SWS_CORE_01355]. O comportamento de desvio idêntico com IsoStdOutOfRangeViolation também se encontra em outros tipos de dados centrais, como ara::core::Array [SWS_CORE_01273] [SWS_CORE_01274] e ara::core::BasicString [SWS_CORE_03063].

A função-membro at da classe ara::core::Vector ([SWS_CORE_01355]), disponibilizada através do cabeçalho #include "ara/core/vector.h", permite o acesso indexado de leitura e escrita a elementos individuais de um vetor. A função aceita um índice de posição n do tipo size_type e devolve uma referência modificável (reference) para o elemento na posição indicada. A semântica segue a implementação correspondente em [vector]. Interpretação: dado que a interface está declarada de forma síncrona segundo a norma C++, a execução deverá ocorrer de forma bloqueante diretamente no contexto da thread chamadora. Pergunta Q-81f43622c244ce91 (aberta)

Diferentemente do vetor padrão ISO-C++, em caso de excedência de índice (n >= size()), a função aciona a violação IsoStdOutOfRangeViolation em vez da exceção padrão std::out_of_range ([SWS_CORE_01355]). Na especificação, a função está classificada como não segura quanto a exceções (not exception safe) ([SWS_CORE_01355]). Interpretação: dado que não estão especificados mecanismos de sincronização para este acesso ao vetor, um acesso concorrente desprotegido à mesma instância não deverá ser seguro para threads. Pergunta Q-e65ae0c574610719 (aberta)

Para o acesso constante de apenas leitura, está disponível a sobrecarga const_reference at(size_type n) const, que também comunica IsoStdOutOfRangeViolation e é considerada não segura quanto a exceções ([SWS_CORE_01354]). A mesma semântica de violação em caso de acesso incorreto é igualmente utilizada por contentores e tipos relacionados da biblioteca Core, incluindo ara::core::Array ([SWS_CORE_01273], [SWS_CORE_01274]), ara::core::Map ([SWS_CORE_01456], [SWS_CORE_01457]), ara::core::StringView ([SWS_CORE_02133]) bem como ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).

Utilização e semântica

O método clear() da classe ara::core::Vector serve para o esvaziamento completo do vetor de acordo com [SWS_CORE_01375]. A função está declarada no cabeçalho ara/core/vector.h, pode ser chamada de forma síncrona, não aceita parâmetros e não fornece valor de retorno (void). Sua semântica funcional segue a especificação correspondente para [vector]. Interpretação: isso deve significar que todos os elementos presentes no vetor são destruídos e a quantidade de elementos é reduzida a 0, devendo a capacidade de memória alocada permanecer inalterada. Pergunta Q-ecde315e61455c32 (aberta)

Tratamento de erros e segurança de exceções

Para a chamada, aplica-se a identificação noexcept, bem como a classificação como seguro contra exceções (exception safe) de acordo com [SWS_CORE_01375]. Como o método garante não lançar exceções, não existem códigos de erro específicos e não são emitidas mensagens de erro DET nem DEM em caso de falha.

Interação com contêineres relacionados

O conceito de uma função clear() segura contra exceções é transferido consistentemente em ara::core para outras estruturas de dados. Assim, ara::core::Map no cabeçalho ara/core/map.h fornece um método clear() idêntico de acordo com [map] [SWS_CORE_01485]. Da mesma forma, ara::core::BasicString no cabeçalho ara/core/string.h oferece uma operação clear() equivalente de acordo com [basic.string] [SWS_CORE_03057].

A função-membro crbegin de ara::core::Vector disponibiliza, de acordo com [SWS_CORE_01342], um iterador reverso constante (const_reverse_iterator) para o último elemento da sequência. A chamada ocorre de forma síncrona e sem parâmetros através do cabeçalho ara/core/vector.h. O comportamento corresponde à especificação da biblioteca padrão de C++ subjacente para [vector]. No caso de um contêiner vazio, é provável que o iterador retornado corresponda ao valor de crend() (interpretação baseada em [vector]). Pergunta Q-a2badba87f86486c (aberta)

No que diz respeito ao tratamento de erros, a interface é provida com o identificador noexcept e declarada como segura contra exceções (exception safe) ([SWS_CORE_01342]). As chamadas não lançam exceções e não reportam erros a monitoramentos de tempo de execução ou de diagnóstico.

Em relação à simultaneidade e restrições, o método é qualificado como const. O acesso de leitura simultâneo à mesma instância a partir de múltiplas threads provavelmente é reentrante e seguro para threads (thread-safe), desde que nenhuma operação de escrita concorrente seja executada no vetor (interpretação análoga ao modelo de contêineres do C++). Pergunta Q-094ba5878c1adc74 (aberta)

No módulo core, o conceito de iteração reversa constante é implementado de forma consistente em diversos tipos. Interfaces semelhantes encontram-se em ara::core::Array ([SWS_CORE_01260]), ara::core::Map ([SWS_CORE_01450]), ara::core::Span ([SWS_CORE_01978]), ara::core::StringView ([SWS_CORE_02126]), bem como em ara::core::BasicString ([SWS_CORE_03049]).

A função-membro crend da classe ara::core::Vector disponibiliza um iterador reverso constante que aponta para o elemento teórico antes do primeiro elemento do vetor [SWS_CORE_01343]. A semântica segue o uso correspondente no padrão C++ para std::vector («As per corresponding usage in [vector]») [SWS_CORE_01343].

Uso e comportamento

• Contexto de chamada e parâmetros: o método não possui parâmetros e é declarado como const, de modo que pode ser chamado sincronicamente em instâncias constantes e não constantes de ara::core::Vector [SWS_CORE_01343].
• Valor de retorno: é retornado um const_reverse_iterator que marca o fim lógico de uma iteração no sentido inverso [SWS_CORE_01343].

Tratamento de erros e segurança de exceções

A função é especificada com noexcept e, de acordo com a especificação, é considerada segura contra exceções («exception safe») [SWS_CORE_01343]. Nenhum código de erro específico é retornado e não ocorrem exceções.

Interação com contêineres relacionados

O conceito de um iterador reverso constante para o ponto final de uma iteração reversa é disponibilizado de forma uniforme entre contêineres em ara::core. Interfaces semelhantes com tratamento de exceções idêntico (noexcept) existem, entre outros, 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], bem como para ara::core::BasicString [SWS_CORE_03050].

A função emplace insere um elemento diretamente na posição especificada em um ara::core::Vector, encaminhando os argumentos passados [SWS_CORE_01366]. A declaração encontra-se no cabeçalho #include "ara/core/vector.h" e segue o uso correspondente em [vector] [SWS_CORE_01366].

usar

A chamada de emplace ocorre de forma síncrona e recebe como parâmetros um iterador de posição position do tipo const_iterator bem como um pacote de parâmetros args do tipo Args&&... [SWS_CORE_01366]. Como valor de retorno, a função fornece um iterator para o elemento recém-construído [SWS_CORE_01366].

Tratamento de erros e simultaneidade

Para emplace em ara::core::Vector, a segurança contra exceções está explicitamente especificada como not exception safe [SWS_CORE_01366]. Códigos de erro específicos, mensagens DET ou DEM não estão definidos no padrão. Interpretação: na ausência de mecanismos internos de sincronização, a chamada concorrente de emplace na mesma instância provavelmente não é segura para threads sem proteção externa. Pergunta Q-d72278df37e86c8a (aberta)

Interação

Dentro de ara::core, a segurança contra exceções para emplace varia de acordo com o tipo:

• Em ara::core::Map, emplace também está definido como not exception safe, mas retorna std::pair<iterator, bool> [SWS_CORE_01458].
• Em ara::core::Optional, as variantes são condicionalmente seguras contra exceções ([SWS_CORE_01119], [SWS_CORE_01120]) ou, para referências, totalmente seguras contra exceções [SWS_CORE_01164].
• Em ara::core::Variant, emplace está declarado como conditionally exception safe com noexcept ([SWS_CORE_01661], [SWS_CORE_01662], [SWS_CORE_01663], [SWS_CORE_01664]).

usar

O método de template emplace_back da classe ara::core::Vector serve, de acordo com [SWS_CORE_01362], para construir um novo elemento diretamente no final do vetor. Os parâmetros passados Args&&... args são repassados diretamente ao construtor do tipo de elemento, segundo a semântica de [vector]. Como valor de retorno, a função retorna uma referência (reference) para o elemento recém-criado. Para a utilização, o cabeçalho #include "ara/core/vector.h" deve ser incluído [SWS_CORE_01362].

Tratamento de erros e segurança de exceções

No tocante à segurança contra exceções, a operação em [SWS_CORE_01362] é explicitamente declarada como not exception safe. Códigos de erro específicos, valores de fallback ou mensagens para serviços de erro como DET ou DEM não são definidos na especificação.

Restrições e comportamento

Devido à propriedade not exception safe e à orientação por [vector], presume-se que em caso de erro, como em uma alocação de memória ou construção com falha, não haja garantia para a preservação do estado anterior do contêiner (interpretação). Pergunta Q-ca44b2f27d8ae1c8 (aberta) Os chamadores devem, portanto, assegurar que possíveis condições de erro sejam evitadas previamente.

A função erase da classe ara::core::Vector destina-se, de acordo com [SWS_CORE_01372], à remoção síncrona de um único elemento na posição indicada pelo parâmetro position (const_iterator). Como valor de retorno, ela fornece um iterator para o elemento seguinte ou para o fim do contêiner, caso o elemento excluído estivesse na última posição, de acordo com a semântica referenciada em [vector]. A função está declarada no arquivo de cabeçalho #include "ara/core/vector.h".

Em relação ao tratamento de erros, a operação é explicitamente identificada na especificação como não segura contra exceções («not exception safe») [SWS_CORE_01372]. Não estão definidos retornos de erro específicos, nem mensagens DET ou DEM; iteradores inválidos ou não desreferenciáveis devem, portanto, levar a um comportamento indefinido. Pergunta Q-efa4c40e48a6f98d (aberta) Devido ao deslocamento dos elementos no vetor, deve-se assumir como interpretação: que iteradores e referências subsequentes se tornem inválidos, conforme corresponde à semântica padrão de [vector].

Na interação dentro de ara::core::Vector, além da exclusão em uma única posição, existe a sobrecarga erase(first, last) para intervalos completos de acordo com [SWS_CORE_01373]. Interfaces análogas para remover entradas encontram-se em outros contêineres da biblioteca Adaptive Core: ara::core::Map disponibiliza sobrecargas baseadas em posição e em chave ([SWS_CORE_01480], [SWS_CORE_01481], [SWS_CORE_01482], [SWS_CORE_01483]), enquanto ara::core::BasicString engloba variantes baseadas em índice e em iterador ([SWS_CORE_03102], [SWS_CORE_03103], [SWS_CORE_03104]).

A função-membro erase da classe ara::core::Vector destina-se à remoção de um intervalo de elementos do vetor de acordo com a especificação [SWS_CORE_01373]. A declaração está disponível através do cabeçalho ara/core/vector.h. A semântica segue o uso correspondente no vetor padrão («As per corresponding usage in [vector]»). Como parâmetros, são passados dois iteradores first e last, que delimitam o intervalo a ser excluído; é retornado um iterator para o elemento subsequente.

No que diz respeito ao tratamento de erros e à segurança contra exceções, a operação é explicitamente classificada na especificação como «not exception safe» [SWS_CORE_01373]. Códigos de erro específicos ou violações (violations) de erro não estão definidos para esta função, ao contrário de outras operações de contêiner. Caso ocorra um erro durante a execução, isso provavelmente deixará o contêiner em um estado inconsistente. Pergunta (aberta)

Quanto à simultaneidade e restrições, a especificação é omissa; operações modificadoras em ara::core::Vector, no entanto, provavelmente não são reentrantes e previsivelmente exigem proteção externa em operação multithread. Pergunta Q-07fc291a523a82f1 (aberta)

Na interação com outras interfaces do módulo Core, esta função complementa a sobrecarga para a remoção de um único elemento em uma posição determinada através de iterator erase(const_iterator position) [SWS_CORE_01372]. Exclusões de intervalo correspondentes seguindo o mesmo padrão também estão definidas para contêineres associativos como ara::core::Map através de [SWS_CORE_01483], bem como cadeias de caracteres em ara::core::BasicString através de [SWS_CORE_03104].

usar

A função-membro insert da classe ara::core::Vector serve para a inserção síncrona de um elemento numa posição predefinida [SWS_CORE_01367]. Está definida no cabeçalho #include "ara/core/vector.h" [SWS_CORE_01367]. A função recebe como parâmetro um iterador position do tipo const_iterator, que marca a posição de destino, bem como uma referência constante x para o objeto a inserir do tipo const T & [SWS_CORE_01367]. O valor de retorno é um iterator que aponta para o elemento recém-inserido [SWS_CORE_01367]. O comportamento funcional orienta-se pela utilização no vetor padrão (“As per corresponding usage in [vector]”) [SWS_CORE_01367].

Tratamento de erros e restrições

A especificação classifica a função expressamente como não segura contra exceções (“not exception safe”) [SWS_CORE_01367]. Não estão definidos códigos de erro específicos, valores de retorno para casos de erro ou mensagens para DET ou DEM. Interpretação: se uma alocação de memória interna ou a cópia do elemento falhar, não deverá existir qualquer garantia quanto à preservação do estado do contentor ou à validade dos iteradores. Pergunta Q-d2b5552bb124d16e (aberta)

Interação

Dentro de ara::core::Vector existem várias sobrecargas de insert que possibilitam operações de inserção alternativas:

• Inserção de um elemento através de referência rvalue T &&x [SWS_CORE_01368],
• Inserção de um determinado número de elementos idênticos com size_type n, const T &x [SWS_CORE_01369],
• Inserção de uma sequência através de um intervalo de iteradores [first, last) [SWS_CORE_01370],
• Inserção através de uma lista de inicialização std::initializer_list<T> [SWS_CORE_01371].

Métodos insert análogos são definidos no módulo core também por contentores associativos como ara::core::Map [SWS_CORE_01460], bem como classes de cadeias de caracteres como ara::core::BasicString [SWS_CORE_03093].

usar

O método insert de acordo com [SWS_CORE_01368] está definido no cabeçalho #include "ara/core/vector.h" como função-membro da classe ara::core::Vector. Ele destina-se à inserção síncrona de um elemento por meio de uma referência rvalue (T&& x) na posição anterior ao iterador position. De acordo com a referência a [vector], a função deve transferir o conteúdo de x por semântica de movimentação para o vetor e retornar um iterator para o elemento recém-inserido. Pergunta Q-97f2551da8fd303f (aberta)

Tratamento de erros e restrições

A especificação classifica a função em [SWS_CORE_01368] como not exception safe. Códigos de erro específicos, valores de retorno para indicação de erro ou mensagens para DET ou DEM não estão definidos. Interpretação: se uma alocação interna de memória ou a movimentação dos elementos falhar, nenhuma segurança contra exceções deve ser garantida, o que pode deixar o contêiner em um estado inconsistente ou levar ao aborto. Pergunta Q-297ef8ff6f6eb76b (aberta) Além disso, presumivelmente não existe proteção interna de concorrência, razão pela qual acessos simultâneos devem ser sincronizados externamente.

Interação

A variante rvalue [SWS_CORE_01368] compõe, com outras sobrecargas de insert de ara::core::Vector, uma interface coerente:

• [SWS_CORE_01367]: inserção por cópia de um valor por meio de referência lvalue (const T& x).
• [SWS_CORE_01369]: inserção de n cópias de um valor (size_type n, const T& x).
• [SWS_CORE_01370]: inserção de uma sequência por meio de um intervalo de iteradores (InputIterator first, InputIterator last).
• [SWS_CORE_01371]: inserção de uma lista por meio de std::initializer_list<T>.

A função-membro insert de [SWS_CORE_01369] pertence à classe ara::core::Vector e é disponibilizada através do arquivo de cabeçalho #include "ara/core/vector.h". A operação síncrona serve para inserir múltiplos elementos idênticos. Interpretação: de acordo com a referência especificada „As per corresponding usage in [vector]”, a chamada provavelmente deve inserir exatamente n cópias do valor passado x imediatamente antes da posição do iterador position no vetor e retornar um iterator para o primeiro elemento recém-inserido. Pergunta Q-c92add148c490868 (aberta)

Em relação ao tratamento de erros e à robustez, a função em [SWS_CORE_01369] é expressamente classificada como „not exception safe”. Códigos de erro específicos do AUTOSAR ou mensagens para DET ou DEM não estão previstos para esta chamada de método.

Quanto à concorrência e condições de chamada, a especificação não contém garantias adicionais. Provavelmente, a modificação do contêiner requer sincronização externa, como ocorre com vetores padrão, já que acessos concorrentes de leitura ou escrita não devem ser seguros para threads. Pergunta (aberta)

Dentro de ara::core::Vector, além desta sobrecarga para valores repetidos, existem outras variantes de insert:

• inserção de um único valor por cópia ([SWS_CORE_01367]) ou por semântica de movimentação ([SWS_CORE_01368]).
• inserção de um intervalo de valores via iteradores de entrada ([SWS_CORE_01370]) ou através de uma std::initializer_list ([SWS_CORE_01371]).

A função-membro de template insert do contêiner sequencial ara::core::Vector ([SWS_CORE_01370]) do cabeçalho #include "ara/core/vector.h" insere uma sequência de elementos de forma síncrona no vetor. O intervalo a ser inserido é determinado através dos iteradores de entrada first e last e posicionado imediatamente antes do local designado por position (tipo const_iterator). Como valor de retorno, a função fornece um iterator que aponta para o primeiro elemento inserido. A semântica funcional é descrita na especificação como „As per corresponding usage in [vector]” ([SWS_CORE_01370]); Interpretação: isso provavelmente corresponde ao comportamento de inserção de intervalo padronizado de std::vector. Pergunta Q-c6cd06fb1964ead6 (aberta)

Em relação ao tratamento de erros e à robustez, a função é expressamente especificada como not exception safe ([SWS_CORE_01370]). Códigos de erro especiais, exceções ou notificações para monitores de erro e diagnóstico (como DET ou DEM) não estão previstos no escopo da especificação.

No escopo da interface de ara::core::Vector, esta sobrecarga de intervalo complementa os demais métodos de inserção:

• a inserção de um único valor por cópia ([SWS_CORE_01367]) ou por semântica de movimentação ([SWS_CORE_01368]),
• a inserção de uma quantidade definida de valores idênticos ([SWS_CORE_01369]),
• bem como a inserção a partir de uma lista de inicializadores via std::initializer_list ([SWS_CORE_01371]).

Todas as sobrecargas mencionadas dentro do vetor compartilham a limitação de não serem seguras contra exceções ([SWS_CORE_01367], [SWS_CORE_01371]).

A função de membro síncrona insert da classe ara::core::Vector insere os elementos de uma lista de inicialização em uma posição predefinida no contêiner [SWS_CORE_01371]. Ela está declarada no arquivo de cabeçalho ara/core/vector.h [SWS_CORE_01371]. Como parâmetros, a função espera um iterador position do tipo const_iterator, que marca o local de inserção, bem como il do tipo std::initializer_list<T> [SWS_CORE_01371]. O valor de retorno é um iterator para o primeiro elemento inserido ou para position, caso a lista esteja vazia [SWS_CORE_01371].

Em relação ao tratamento de erros e à robustez, a especificação classifica esta operação explicitamente como «not exception safe» [SWS_CORE_01371]. Não estão previstos códigos de erro AUTOSAR específicos ou mensagens de erro (DET/DEM). Interpretação: Pela referência «As per corresponding usage in [vector]», o comportamento em tempo de execução, incluindo possíveis realocações e a consequente invalidação de iteradores existentes, deverá corresponder à semântica de std::vector::insert [SWS_CORE_01371]. Pergunta Q-67ac8e3de4d4ce7a (aberta) Não estão especificados mecanismos especiais de sincronização para acessos concorrentes.

No módulo core, a função encontra-se no contexto de outras operações de inserção de ara::core::Vector:

• Inserção de um elemento único por cópia [SWS_CORE_01367] ou semântica de movimentação (move) [SWS_CORE_01368],
• Inserção de n cópias de um valor [SWS_CORE_01369],
• Inserção baseada em intervalo através de dois iteradores de entrada [SWS_CORE_01370].

Todas as sobrecargas em ara::core::Vector compartilham a propriedade de não serem seguras contra exceções [SWS_CORE_01367], [SWS_CORE_01368], [SWS_CORE_01369], [SWS_CORE_01370].

Utilização e semântica

A função-membro pop_back do contêiner ara::core::Vector serve para a remoção síncrona do último elemento [SWS_CORE_01365]. A função está declarada no arquivo de cabeçalho ara/core/vector.h e possui a assinatura void pop_back () [SWS_CORE_01365]. A AUTOSAR remete explicitamente, para o comportamento funcional, ao uso correspondente em [vector], de modo que nenhum parâmetro é passado e nenhum valor de retorno existe [SWS_CORE_01365].

Tratamento de erros e segurança de exceções

Em relação ao tratamento de erros, a especificação indica a propriedade not exception safe [SWS_CORE_01365]. Como não há códigos de erro específicos, valores de retorno ou mecanismos de verificação definidos no payload, não existe tratamento de erro integrado em caso de chamadas indevidas [SWS_CORE_01365]. Interpretação: Antes da chamada, o chamador deve assegurar que o vetor não esteja vazio; uma chamada sobre uma instância vazia provavelmente leva a comportamento indefinido, de modo análogo a [vector]. Pergunta Q-add313a489db4726 (aberta)

Interação e requisitos relacionados

Um padrão correspondente é encontrado na classe ara::core::BasicString de ara/core/string.h, cuja função pop_back remove o último caractere conforme [basic.string] e é igualmente especificada como not exception safe [SWS_CORE_03105]. Ambas as definições padronizam a modificação de estruturas de dados sequenciais no módulo core [SWS_CORE_01365], [SWS_CORE_03105].

usar

A função-membro push_back no escopo de ara::core::Vector insere um elemento passado por meio de cópia ao final do contêiner [SWS_CORE_01363]. Ela é definida através do cabeçalho #include "ara/core/vector.h", recebe uma referência a um valor constante const T &x e não possui valor de retorno (void) [SWS_CORE_01363]. A chamada ocorre de forma síncrona no contexto do chamador.

Tratamento de erros e segurança contra exceções

A especificação difere de [vector] pelo fato de a função ser declarada como condicionalmente noexcept: É garantido que ela não lança exceções exatamente quando std::is_nothrow_copy_assignable<T>::value for verdadeiro [SWS_CORE_01363]. De maneira correspondente, a segurança contra exceções é definida como «conditionally exception safe» [SWS_CORE_01363]. Códigos de erro específicos, bem como mensagens de erro via DET ou DEM, não estão definidos para esta função.

Interação e requisitos relacionados

Para objetos móveis, ara::core::Vector disponibiliza a sobrecarga void push_back(T &&x), cuja propriedade noexcept está acoplada de forma análoga a std::is_nothrow_move_assignable<T>::value [SWS_CORE_01364]. Em contrapartida, push_back em ara::core::BasicString não possui garantia noexcept e está classificada como «not exception safe» [SWS_CORE_03083].

Interpretação: O comportamento interno de memória e realocação durante a inserção provavelmente deve se orientar, excetuando-se a declaração específica de noexcept, pelas diretrizes do padrão C++ para [vector]. Pergunta Q-202fb07b334cde64 (aberta)

A função-membro push_back de ara::core::Vector serve para anexar sincronamente um elemento ao final do vetor utilizando semântica de movimento ([SWS_CORE_01364]). Ela é disponibilizada através do cabeçalho #include "ara/core/vector.h", recebe uma referência rvalue T &&x e não possui valor de retorno (void) ([SWS_CORE_01364]).

Em relação ao tratamento de erros e ao comportamento com exceções, aplicam-se as seguintes propriedades:

• O método é classificado como condicionalmente seguro contra exceções (conditionally exception safe) ([SWS_CORE_01364]).
• A garantia noexcept está vinculada ao tipo: noexcept(std::is_nothrow_move_assignable<T>::value) ([SWS_CORE_01364]). Se o operador de atribuição por movimento de T não estiver declarado como livre de exceções, podem ocorrer exceções em alocações de memória ou em movimentações de elementos. Pergunta Q-3b8b58d0b218fe21 (aberta)

O funcionamento segue a semântica habitual em [vector], diferindo contudo pela declaração condicional de noexcept ([SWS_CORE_01364]). Como a operação modifica o contêiner, acessos simultâneos à mesma instância sem sincronização externa provavelmente não são seguros para threads. Pergunta (aberta)

Na interação das interfaces, esta variante de movimento complementa a sobrecarga por cópia push_back(const T &x) ([SWS_CORE_01363]), que está acoplada de forma análoga a is_nothrow_copy_assignable. Distingue-se desta a função-membro de mesmo nome em ara::core::BasicString ([SWS_CORE_03083]), que anexa caracteres individuais e é definida como não segura contra exceções.