classe ara::core::Map

usar

A função síncrona de acesso a elementos at da classe ara::core::Map ([SWS_CORE_01456]) destina-se à recuperação controlada de um valor para uma chave existente. Ela é disponibilizada através do cabeçalho ara/core/map.h. Como parâmetro de entrada, aceita uma referência de chave const key_type &x e retorna uma referência modificável mapped_type & para o valor correspondente ([SWS_CORE_01456]). A semântica corresponde fundamentalmente ao uso habitual de std::map; para instâncias constantes, está disponível a sobrecarga separada [SWS_CORE_01457].

Tratamento de erros e condições de contorno

Em caso de erro, a função desvia-se deliberadamente do comportamento padrão ISO: se o elemento especificado x não estiver presente no contêiner, é disparada uma IsoStdOutOfRangeViolation em vez de uma exceção C++ clássica do tipo std::out_of_range ([SWS_CORE_01456]). A assinatura é explicitamente declarada como noexcept e classificada como segura contra exceções (exception safe) ([SWS_CORE_01456]).

Interação

O conceito de indicar violações de intervalo através de IsoStdOutOfRangeViolation é implementado de forma uniforme em todo o módulo:

• Dentro de ara::core::Map, a sobrecarga de leitura com const possui o mesmo comportamento de erro ([SWS_CORE_01457]).
• Funções at correspondentes com IsoStdOutOfRangeViolation existem 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]), bem como ara::core::BasicString ([SWS_CORE_03063], [SWS_CORE_03064]).
• A violation disparada provavelmente está relacionada, no sistema geral, com mecanismos de aborto e terminação como AddAbortHandler ([SWS_CORE_00054]). Pergunta Q-9427d214713f7508 (aberta)

usar

A função-membro at, de acordo com [SWS_CORE_01457], permite o acesso de leitura síncrono a um elemento dentro de uma instância de ara::core::Map por meio do cabeçalho #include "ara/core/map.h". Como parâmetro, a chave pesquisada x é transmitida como const key_type &. Em caso de busca bem-sucedida, o método retorna uma referência constante ao valor associado (const mapped_type &).

Tratamento de erros e comportamento com exceções

O comportamento corresponde essencialmente ao comportamento padrão de std::map::at, mas apresenta um desvio específico: se a chave x não for encontrada no contêiner, é lançada uma IsoStdOutOfRangeViolation em vez de std::out_of_range, de acordo com [SWS_CORE_01457]. Como a função é especificada com noexcept, essa violação não resulta em uma exceção C++ regular; isso provavelmente acarreta o encerramento controlado do processo por meio dos mecanismos de tratamento de erro, conforme podem ser registrados no contexto de [SWS_CORE_00054]. Pergunta Q-d7dd2c332f88ed14 (aberta)

Concorrência e interação

Como método constante, a chamada qualifica-se para o acesso de leitura simultâneo, desde que não ocorram acessos modificadores concorrentes à mesma instância de mapa. Além desta interface constante, existe com [SWS_CORE_01456] uma sobrecarga não constante que retorna uma referência modificável. A mesma estratégia para sinalizar violações de limites por meio de IsoStdOutOfRangeViolation também é implementada de forma consistente em outros contêineres adaptativos do Core, como em ara::core::Array ([SWS_CORE_01274]) e ara::core::Vector ([SWS_CORE_01354]).

A função-membro clear da classe ara::core::Map destina-se ao esvaziamento completo do conteúdo do contêiner, conforme a especificação em [SWS_CORE_01485]. A função requer a inclusão do arquivo de cabeçalho #include "ara/core/map.h". A semântica de chamada e o comportamento orientam-se pelo uso correspondente do padrão ISO C++ para mapas associativos padrão ([map]).

Em relação à interface e ao tratamento de erros, a função apresenta as seguintes propriedades:

• Parâmetros e valor de retorno: A operação possui a assinatura void clear () noexcept;, não recebe parâmetros e não retorna nenhum valor [SWS_CORE_01485].
• Segurança contra exceções: A função é explicitamente declarada como noexcept e especificada como exception safe [SWS_CORE_01485]. Ela, portanto, não lança exceções C++ em caso de erro.
• Execução síncrona: A chamada é executada sincronamente na instância; após o retorno, presume-se que o contêiner esteja vazio (tamanho 0). Pergunta Q-1d0cf2a1a33d818e (aberta)

No módulo core, a limpeza de contêineres padrão segue um paradigma uniforme. Funções clear análogas com assinatura e segurança contra exceções idênticas encontram-se, por exemplo, para contêineres sequenciais em ara::core::Vector conforme [SWS_CORE_01375] (ara/core/vector.h), bem como para cadeias de caracteres em ara::core::BasicString conforme [SWS_CORE_03057] (ara/core/string.h). Os desenvolvedores podem confiar, em todos os contêineres, na habitual semântica padrão do C++ e na ausência garantida de exceções.

O método template contains da classe ara::core::Map serve para a verificação síncrona se uma chave buscada existe em um contêiner associativo [SWS_CORE_01497]. Ele é disponibilizado através do cabeçalho #include "ara/core/map.h" e chamado como função-membro constante (const) em uma instância de ara::core::Map [SWS_CORE_01497]. Como parâmetro de chamada, aceita uma referência constante const K &x para a chave a ser buscada e fornece um valor de retorno do tipo bool [SWS_CORE_01497].

Quanto à sua semântica, a especificação remete ao uso correspondente em [map] [SWS_CORE_01497]. Isso provavelmente deve ser interpretado como uma adoção do comportamento de std::map::contains, segundo o qual o método retorna true se, e somente se, uma chave equivalente estiver contida no map, e false caso contrário. Pergunta Q-664d5a3d099db549 (aberta)

Em relação à robustez e ao tratamento de erros, a função é categorizada explicitamente como not exception safe [SWS_CORE_01497]. Códigos de erro específicos do AUTOSAR ou mensagens para DET ou DEM não existem para esta operação. Os chamadores devem considerar que, durante a execução, provavelmente desencadeadas por comparações de chave ou conversões do tipo K, exceções podem ser lançadas e propagadas para fora. Pergunta (aberta)

Como contains não modifica o estado do map por ser uma operação de leitura const, acessos de leitura simultâneos à mesma instância são normalmente não críticos, enquanto modificações de escrita paralelas no contêiner provavelmente exigirão sincronização externa. Pergunta Q-f3ca0e3d094f8f0a (aberta)

Utilização e semântica

A função-membro contains pertence ao escopo da classe ara::core::Map e é disponibilizada através do arquivo de cabeçalho ara/core/map.h [SWS_CORE_01510]. A função possui a assinatura bool contains (const key_type &x) const; e é executada de forma síncrona. Ela serve para verificar se um elemento com a chave x está presente no contêiner. A especificação remete ao comportamento correspondente em [map], com o que presume-se que se refira à semântica do contêiner padrão C++ std::map::contains, que retorna true se a chave estiver presente e, caso contrário, false. Pergunta Q-fea394bd408bf925 (aberta)

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

O comportamento de contains é expressamente classificado na especificação como not exception safe [SWS_CORE_01510]. Códigos de erro específicos, domínios de erro bem como mensagens DET ou DEM não estão definidos no escopo da especificação. Os chamadores devem, portanto, considerar que nenhuma garantia de segurança contra exceções é concedida durante a busca e que as exceções ocorridas devem ser tratadas.

Simultaneidade e restrições

Quanto à segurança de thread, a especificação não faz nenhuma declaração explícita em [SWS_CORE_01510]. Como se trata de uma função-membro constante (const), o estado do contêiner não é modificado. Interpretação: Acessos de leitura paralelos deverão ser admissíveis, ao passo que modificações simultâneas de escrita na mesma instância requerem sincronização externa. Pergunta Q-7d8ce1efc81ec781 (aberta)

Interação no módulo core

Em comparação com outras funções de verificação de estado do módulo core — como, por exemplo, HasValue [SWS_CORE_00751] ou CheckError [SWS_CORE_00765] em ara::core::Result, que são definidas como exception safe e noexcept —, contains em ara::core::Map não oferece garantia de noexcept e é declarada como não segura contra exceções [SWS_CORE_01510].

A função-membro síncrona count da classe ara::core::Map determina, com base na chave x fornecida do tipo const key_type&, quantas vezes essa chave ocorre no contêiner e retorna o resultado como size_type [SWS_CORE_01494]. A declaração ocorre por meio do cabeçalho #include "ara/core/map.h" [SWS_CORE_01494]. Interpretação: de acordo com a referência ao comportamento padrão em [map], presume-se que o valor de retorno para chaves exclusivas seja 0 ou 1. Pergunta Q-a713cfc1019b40d0 (aberta)

Em relação ao tratamento de erros, a função é explicitamente classificada, de acordo com a especificação, como “not exception safe” [SWS_CORE_01494]. Não são definidos códigos de erro específicos ou mensagens DET/DEM; se a operação de comparação de chaves lançar uma exceção, presume-se que ela seja propagada diretamente para o chamador. Pergunta (aberta)

Em relação à concorrência e restrições, trata-se de uma operação constante (const) [SWS_CORE_01494]. Interpretação: acessos de leitura concorrentes à mesma instância de ara::core::Map devem ser possíveis sem condições de corrida (data races), ao passo que operações modificadoras simultâneas devem ser protegidas por sincronização externa. Pergunta (aberta)

Na interação com requisitos relacionados, existe com [SWS_CORE_01495] uma sobrecarga de template template <class K> size_type count (const K &x) const dentro de ara::core::Map. Esta permite consultas de busca heterogêneas com tipos de comparação compatíveis K, sem a necessidade mandatória de criar previamente um objeto temporário do tipo key_type, mas está sujeita à mesma classificação em relação à segurança contra exceções [SWS_CORE_01495].

A função-membro de template count da classe ara::core::Map verifica sincronamente a ocorrência de elementos com base em uma chave e determina a sua quantidade [SWS_CORE_01495]. A função está declarada no cabeçalho ara/core/map.h e retorna a quantidade de elementos encontrados como size_type [SWS_CORE_01495]. De acordo com a referência especificada ao uso em [map], a chamada fornece para chaves unívocas o valor 1, se existir um elemento correspondente, e, caso contrário, 0 [SWS_CORE_01495].

Na interação direta com a sobrecarga count(const key_type&) [SWS_CORE_01494], esta variante permite a passagem de qualquer tipo de chave compatível const K& [SWS_CORE_01495]. Interpretação: A parametrização por template provavelmente foi projetada para operações de busca heterogêneas, visando realizar comparações sem conversão prévia em um objeto temporário key_type [SWS_CORE_01495]. Pergunta Q-e2572768e5600da7 (aberta) Com isso, podem ser evitadas alocações desnecessárias e custos de conversão em consultas de busca.

Em relação à segurança contra exceções, o método está declarado como não seguro contra exceções (not exception safe) [SWS_CORE_01495], analogamente à sobrecarga relacionada [SWS_CORE_01494]. Canais de erro específicos como DET ou DEM não existem para esta operação de contêiner [SWS_CORE_01495]; eventuais exceções do operador de comparação subjacente propagam-se para o chamador. Como o método é qualificado como const, ele não modifica o contêiner [SWS_CORE_01495]; acessos concorrentes de leitura são seguros, contudo acessos concorrentes de escrita requerem sincronização externa.

usar

A função de membro crbegin da classe ara::core::Map é disponibilizada por meio do arquivo de cabeçalho #include "ara/core/map.h" [SWS_CORE_01450]. Ela não recebe parâmetros e retorna sincronamente um const_reverse_iterator para o primeiro elemento da ordem reversa [SWS_CORE_01450]. A semântica funcional segue a declaração de especificação “As per corresponding usage in [map]” [SWS_CORE_01450]; presume-se que isso corresponda à semântica de std::map::crbegin do padrão C++. Pergunta Q-0ad5de7dada37aa8 (aberta)

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

Códigos de erro específicos, mensagens DET ou DEM não estão previstos para esta chamada. De acordo com a especificação, a função é declarada com noexcept e classificada como segura contra exceções («exception safe») [SWS_CORE_01450], de modo que nenhuma exceção ocorra durante a execução.

Simultaneidade e restrições

Como um método qualificado com const, crbegin não modifica o objeto ara::core::Map [SWS_CORE_01450]. O iterador resultante permite exclusivamente acessos de leitura aos elementos contidos no contêiner.

Interação

O conceito de iteração é harmonizado entre contêineres na AUTOSAR Adaptive Core:

• ara::core::Vector [SWS_CORE_01342] e ara::core::BasicString [SWS_CORE_03049] disponibilizam métodos const noexcept com funções equivalentes.
• Para ara::core::Array [SWS_CORE_01260], ara::core::Span [SWS_CORE_01978] e ara::core::StringView [SWS_CORE_02126], crbegin é adicionalmente definido como constexpr.

usar

O método crend da classe template ara::core::Map ([SWS_CORE_01451]) está disponível através do cabeçalho ara/core/map.h. Ele retorna sincronamente um iterador reverso constante (const_reverse_iterator) que, de acordo com o comportamento padrão de std::map, marca o alcance do final de uma iteração reversa sobre os elementos.

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

A função possui a especificação noexcept e é classificada como “exception safe” ([SWS_CORE_01451]). A chamada não lança exceções e não requer verificação de códigos de erro.

Simultaneidade e condições marginais

Como um método qualificado com const, crend não modifica a instância subjacente do map. Acessos simultâneos de leitura por meio de várias threads devem, portanto, ser seguros, desde que a instância não seja modificada concomitantemente por escrita (interpretação). Pergunta Q-5593deafcef41be3 (aberta)

Interação

A assinatura e a semântica inserem-se nas interfaces uniformes de iteradores da biblioteca ara::core. Funções crend análogas existem para:

• ara::core::Vector ([SWS_CORE_01343]) e ara::core::BasicString ([SWS_CORE_03050]), cada um com declaração const noexcept idêntica, bem como
• os contêineres e views ara::core::Array ([SWS_CORE_01261]), ara::core::Span ([SWS_CORE_01979]) e ara::core::StringView ([SWS_CORE_02127]), que são adicionalmente declarados como constexpr.

Uso de emplace em ara::core::Map

A função de elemento de modelo emplace da classe ara::core::Map serve para construir e inserir diretamente um novo par chave-valor no armazenamento associativo [SWS_CORE_01458]. A função está definida no cabeçalho #include "ara/core/map.h" e recebe os argumentos do construtor através do pacote de parâmetros Args&&... args [SWS_CORE_01458]. Como resultado, a chamada síncrona retorna um std::pair<iterator, bool> [SWS_CORE_01458]. Interpretação: a referência a [map] provavelmente significa que o comportamento segue o contêiner padrão do C++ std::map, de modo que o iterador aponta para o elemento e o valor booleano sinaliza se a entrada foi recém-inserida. Pergunta Q-fa496892c1e5e15d (aberta)

Em relação ao tratamento de erros e à robustez, emplace é expressamente classificado na especificação como not exception safe [SWS_CORE_01458]. Se a alocação de memória ou a construção do objeto falhar, a implementação não garante a consistência do contêiner. Códigos de erro específicos do AUTOSAR ou mensagens para DET ou DEM não estão previstos para esta interface fundamental.

No módulo core existem operações emplace análogas para outros tipos de dados que, no entanto, possuem garantias divergentes: enquanto ara::core::Vector::emplace também é especificado como não seguro contra exceções [SWS_CORE_01366], as implementações em ara::core::Optional [SWS_CORE_01119] bem como ara::core::Variant [SWS_CORE_01661] oferecem segurança condicional contra exceções (conditionally exception safe).

usar

A função-membro template emplace_hint da classe de contêiner ara::core::Map serve para inserir um novo elemento utilizando uma posição sugerida como dica de busca ([SWS_CORE_01459]). Ela é disponibilizada através do cabeçalho ara/core/map.h e aceita o iterador position bem como um pacote de parâmetros args para encaminhamento ([SWS_CORE_01459]). O funcionamento corresponde ao uso em [map] ([SWS_CORE_01459]). Supõe-se que os argumentos passados sejam utilizados diretamente para a construção in-place do registro, o que provavelmente permite obter uma inserção acelerada mediante posicionamento adequado. Pergunta Q-564dd9bab5c0293f (aberta)

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

Quanto à tolerância a falhas, a operação é categorizada explicitamente como not exception safe ([SWS_CORE_01459]). Caso ocorra um erro durante a alocação de memória ou a construção do par chave-valor, nenhuma garantia quanto ao estado do contêiner deverá ser válida. Pergunta (aberta) Códigos de erro específicos ou mensagens de diagnóstico como DET ou DEM não estão definidos para esta interface ([SWS_CORE_01459]).

Simultaneidade e restrições

A especificação não faz nenhuma declaração sobre concorrência e contextos de chamada ([SWS_CORE_01459]). Interpretação: como operação que modifica o estado de ara::core::Map, emplace_hint requer sincronização externa no acesso simultâneo de múltiplas threads para evitar inconsistências de dados. Pergunta Q-04b3ab58544ceba4 (aberta)

usar

A função-membro síncrona equal_range da classe ara::core::Map é disponibilizada através do cabeçalho #include "ara/core/map.h" [SWS_CORE_01506]. Recebe uma chave x do tipo const key_type & e retorna um par de iteradores modificáveis (std::pair<iterator, iterator>) que delimita o intervalo de todas as entradas correspondentes [SWS_CORE_01506]. O comportamento segue a semântica habitual em [map] [SWS_CORE_01506]; uma vez que Map tem habitualmente chaves únicas, o intervalo resultante deverá abranger no máximo um elemento (Interpretação). Pergunta Q-d26df1f3ac3b6232 (aberta)

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

A especificação classifica a função expressamente como not exception safe [SWS_CORE_01506]. Códigos de erro específicos, valores de retorno para sinalização de erros ou relatórios ao DET ou DEM não estão definidos. Se a chave procurada não for encontrada, ambos os iteradores do par deverão ser idênticos e apontar para a potencial posição de inserção (Interpretação de acordo com [map]). Pergunta (aberta)

Simultaneidade e restrições

A operação é não constante e retorna iteradores não constantes [SWS_CORE_01506]. Dado que não estão documentados mecanismos de sincronização, acessos simultâneos de leitura ou escrita à mesma instância de ara::core::Map são presumivelmente inseguros para threads (Interpretação) e requerem sincronização externa. Pergunta Q-3fb76368d9de336f (aberta)

Interação

Para acessos de leitura a instâncias constantes, está disponível a sobrecarga com pares const_iterator [SWS_CORE_01507]. Adicionalmente, existem variantes template para processos de pesquisa heterogéneos com tipo de chave arbitrário K, tanto para chamadas não constantes [SWS_CORE_01508] como para chamadas constantes [SWS_CORE_01509].

usar

A função-membro equal_range da classe ara::core::Map determina, numa instância constante, o intervalo de todas as entradas que correspondem a uma chave especificada [SWS_CORE_01507]. Ela aceita o parâmetro const key_type &x e retorna um std::pair<const_iterator, const_iterator>, que representa os limites do intervalo [SWS_CORE_01507]. A função é disponibilizada através do ficheiro de cabeçalho ara/core/map.h e executada sincronamente [SWS_CORE_01507]. A semântica corresponde à especificação de [map] [SWS_CORE_01507]; consequentemente, o intervalo retornado num map com chaves únicas deverá abranger uma extensão de, no máximo, uma entrada. Pergunta Q-f2bdc3bf2c17948e (aberta)

Tratamento de erros e condições de contorno

Relativamente ao comportamento de erro e de exceções, o método é especificado como não seguro contra exceções («not exception safe») [SWS_CORE_01507]. Não estão definidos códigos de erro específicos, mensagens DET ou eventos DEM. Como o método está declarado como const, ele não altera o estado do objeto chamador.

Interação

A operação está integrada numa série de sobrecargas relacionadas dentro de ara::core::Map:

• Para instâncias não constantes, [SWS_CORE_01506] oferece a mesma busca, mas retorna iteradores modificáveis.
• Através das funções de template [SWS_CORE_01508] e [SWS_CORE_01509], a busca também pode ser realizada com chaves compatíveis do tipo K tanto para maps modificáveis quanto constantes.

Utilização e semântica

A função-membro de template equal_range da classe ara::core::Map ([SWS_CORE_01508]) é disponibilizada através do cabeçalho ara/core/map.h. Ela serve para localizar o intervalo de todos os elementos cuja chave coincide com o valor passado. O comportamento orienta-se pela utilização correspondente em [map] ([SWS_CORE_01508]). A chamada síncrona aceita um parâmetro de chave x do tipo genérico const K& e fornece como valor de retorno um std::pair<iterator, iterator> ([SWS_CORE_01508]). Interpretação: Através do tipo de parâmetro genérico K, a função deve suportar uma consulta heterogênea, de modo que sejam possíveis comparações sem conversão prévia em key_type. Pergunta Q-19f39bf5b68f9a3c (aberta)

Tratamento de erros e condições de contorno

De acordo com a especificação, a função é classificada como não segura contra exceções (not exception safe) ([SWS_CORE_01508]). Não estão previstos códigos de erro específicos, valores de retorno para indicação de erro ou mensagens para DET ou DEM. Como a função não está qualificada como const, ela retorna iteradores modificáveis que permitem acessos de escrita aos valores contidos.

Interação

A função-membro faz parte de um grupo de sobrecargas equal_range relacionadas dentro de ara::core::Map:

• [SWS_CORE_01506]: Variante não constante para chaves diretas do tipo const key_type&.
• [SWS_CORE_01507]: Variante constante para chaves diretas do tipo const key_type&, que retorna const_iterator.
• [SWS_CORE_01509]: Sobrecarga de template constante para chaves genéricas do tipo const K&.

usar

A função-membro de template equal_range da classe ara::core::Map do cabeçalho ara/core/map.h determina o intervalo de elementos que correspondem a uma chave de busca x passada do tipo K [SWS_CORE_01509]. Como método constante, ela retorna um par de valores de iteradores constantes std::pair<const_iterator, const_iterator> e não altera o contentor subjacente [SWS_CORE_01509]. De acordo com a especificação, a semântica rege-se pelo uso correspondente em [map] [SWS_CORE_01509]. Interpretação: O parâmetro de template K deverá permitir uma busca heterogênea por chaves, de modo que nenhum objeto temporário do tipo de chave precise de ser construído. Pergunta Q-7f7a93cef3cf7d8f (aberta)

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

Relativamente à segurança contra exceções, a função é categorizada expressamente como não segura contra exceções («not exception safe») [SWS_CORE_01509]. Códigos de erro específicos ou respostas a interfaces de diagnóstico ou de erro (como DET ou DEM) não estão previstos no âmbito da especificação para esta função [SWS_CORE_01509].

Interação e sobrecargas

A função está diretamente associada às outras variantes de equal_range em ara::core::Map:

• À sobrecarga de template não constante [SWS_CORE_01508], que retorna um par de iteradores modificáveis.
• Às sobrecargas não baseadas em template para const key_type &x na forma não constante [SWS_CORE_01506], bem como na forma constante [SWS_CORE_01507].

A função erase da classe ara::core::Map remove de forma síncrona do contentor o elemento que é referenciado pelo parâmetro position transmitido [SWS_CORE_01480]. A definição é incluída através do cabeçalho <ara/core/map.h> [SWS_CORE_01480]. Como valor de retorno, a função devolve um iterador para o elemento do mapa imediatamente subsequente ao elemento removido [SWS_CORE_01480]. A semântica segue a especificação de acordo com a utilização correspondente em [map] [SWS_CORE_01480].

No que respeita ao tratamento de erros, a operação está classificada como não segura quanto a exceções (not exception safe) [SWS_CORE_01480]. Códigos de erro específicos, canais de fallback ou mensagens de erro via DET ou DEM não estão especificados para esta chamada [SWS_CORE_01480]. Dado que o comportamento se orienta por [map], o iterador transmitido deverá ficar inválido devido ao processo de eliminação, enquanto os iteradores para os elementos restantes presumivelmente permanecem intactos [SWS_CORE_01480]. A transmissão de um iterador inválido ou não desreferenciável conduz presumivelmente a comportamento indefinido devido à falta de validação (Interpretação). Pergunta Q-1a4a3eae317fc52e (aberta)

Na interação dentro de ara::core::Map, existem sobrecargas alternativas: além da eliminação através de um iterator mutável, está disponível uma sobrecarga para const_iterator [SWS_CORE_01481]. Do mesmo modo, os elementos podem ser removidos com base na chave através de key_type [SWS_CORE_01482] ou como um intervalo completo de iteradores [SWS_CORE_01483].

A função-membro erase da classe ara::core::Map destina-se à exclusão síncrona de um único elemento na posição indicada pelo iterador position [SWS_CORE_01481]. A declaração ocorre por meio do arquivo de cabeçalho ara/core/map.h [SWS_CORE_01481]. O comportamento corresponde à definição em [map], sendo que a função retorna um iterator para o elemento subsequente do map [SWS_CORE_01481].

Em relação ao tratamento de exceções, a função é especificada como «not exception safe» [SWS_CORE_01481]. Códigos de erro específicos, violations ou mensagens de erro não estão definidos para esta operação [SWS_CORE_01481]. Interpretação: A passagem de um iterador inválido ou não desreferenciável como position deverá levar a comportamento indefinido, uma vez que a especificação não prevê verificações de erro. Pergunta Q-9a3242ae4773cc0b (aberta)

Na interação com a interface de contêiner de ara::core::Map, estão disponíveis outras sobrecargas:

• Exclusão por meio de um iterador modificável iterator position [SWS_CORE_01480],
• Exclusão com base em uma chave via erase(const key_type &x) com retorno da quantidade de elementos removidos [SWS_CORE_01482],
• Exclusão de intervalo por meio de dois iteradores first e last [SWS_CORE_01483].

Sobrecargas correspondentes para posições const_iterator individuais também estão definidas de forma análoga para outros contêineres como ara::core::Vector [SWS_CORE_01372] ou ara::core::BasicString [SWS_CORE_03103].

usar

A função-membro síncrona erase da classe ara::core::Map destina-se à remoção de entradas por meio de uma chave especificada x do tipo const key_type& ([SWS_CORE_01482]). A interface é incluída por meio do cabeçalho ara/core/map.h. O comportamento funcional é definido como equivalente ao uso em [map] ([SWS_CORE_01482]). Interpretação: De acordo com esta referência ao padrão C++, o valor de retorno do tipo size_type deverá indicar a quantidade de elementos excluídos do contêiner com sucesso. Pergunta Q-03637eb7e5efe502 (aberta)

Tratamento de erros e condições de contorno

Na especificação, a função é classificada como not exception safe ([SWS_CORE_01482]). Códigos de retorno específicos para situações de erro ou canais de relato via DET ou DEM não estão definidos para esta chamada de contêiner. Interpretação: Devido à ausência de segurança contra exceções, nenhuma garantia em relação ao estado do contêiner deverá ser válida em caso de erro, razão pela qual o chamador deve assegurar dados consistentes e parâmetros de chamada válidos antes da execução. Pergunta (aberta)

Interação

O método constitui o equivalente baseado em chave para as operações de exclusão baseadas em iteradores de ara::core::Map, que limpam posições individuais ([SWS_CORE_01480], [SWS_CORE_01481]) ou intervalos fechados de iteradores ([SWS_CORE_01483]). O padrão de funções erase padronizadas é encontrado em ara::core entre diferentes contêineres, como para ara::core::Vector ([SWS_CORE_01372]) ou para ara::core::BasicString ([SWS_CORE_03102]).

usar

A função de elemento erase do contêiner ara::core::Map serve para remover um intervalo de valores delimitado por dois iteradores [SWS_CORE_01483]. Ela está definida no cabeçalho #include "ara/core/map.h" e possui a assinatura iterator erase (const_iterator first, const_iterator last); [SWS_CORE_01483]. Tecnicamente, o comportamento segue a semântica habitual em [map] [SWS_CORE_01483]. Como valor de retorno, ela retorna um iterator para o elemento que sucede imediatamente o intervalo removido, ou o final do contêiner [SWS_CORE_01483].

Tratamento de erros e restrições

A operação é explicitamente classificada na especificação como not exception safe [SWS_CORE_01483]. Códigos de erro específicos do AUTOSAR ou mensagens para DET ou DEM não estão definidos para esta função. O chamador provavelmente deve ter a responsabilidade de garantir que first e last referenciem um intervalo válido e bem-formado dentro da mesma instância, uma vez que não estão previstas verificações adicionais (Interpretação). Pergunta Q-69e88ecc6f04bb64 (aberta)

Interação

Dentro de ara::core::Map, esta exclusão de intervalo complementa as sobrecargas para a remoção de elementos individuais por meio de iterator [SWS_CORE_01480], por meio de const_iterator [SWS_CORE_01481] bem como com base em uma chave key_type [SWS_CORE_01482]. Interfaces erase semelhantes para intervalos de iteradores também são encontradas em outros contêineres da Adaptive Core Library, nomeadamente em ara::core::Vector [SWS_CORE_01373] e ara::core::BasicString [SWS_CORE_03104].

A função-membro extract da classe ara::core::Map remove o elemento na posição indicada pelo iterador position e retorna um nó do tipo node_type [SWS_CORE_01470]. A declaração e a semântica seguem o uso correspondente em [map], desvinculando o nó diretamente do contêiner associativo. A função é fornecida através do cabeçalho ara/core/map.h.

Uso e comportamento

A chamada ocorre de forma síncrona sobre uma instância de ara::core::Map. Como parâmetro, é passado um const_iterator position, que Interpretação: deve apontar para um elemento válido e desreferenciável dentro do mapa chamado. Através da extração, o elemento é removido do contêiner, enquanto o objeto node_type retornado assume a propriedade do nó.

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

Em relação ao tratamento de exceções, a função está expressamente classificada de acordo com a especificação como not exception safe [SWS_CORE_01470]. Se ocorrer uma exceção durante a execução, a operação não assegura garantias determinísticas do contêiner, razão pela qual o código chamador deve prever proteções adequadas.

Interação e alternativas

Como sobrecarga, além da remoção baseada em posição, também está disponível a variante baseada em chave extract(const key_type &x) [SWS_CORE_01471]. Esta última permite a extração de uma entrada diretamente com base em seu valor de chave, sem a necessidade de determinar manualmente um iterador previamente.

usar

A função-membro síncrona extract está definida no arquivo de cabeçalho #include "ara/core/map.h" dentro da classe ara::core::Map [SWS_CORE_01471]. Ela aceita como parâmetro uma referência constante de chave const key_type &x e retorna o elemento encontrado como node_type [SWS_CORE_01471]. A semântica funcional remete ao uso correspondente em [map] [SWS_CORE_01471]; isto deverá corresponder ao padrão C++, segundo o qual o nó é extraído diretamente do contêiner sem que a chave ou o valor precisem ser copiados. Pergunta (aberta)

Tratamento de erros e restrições

A função é expressamente classificada na especificação como “not exception safe” [SWS_CORE_01471]. Códigos de erro específicos, classes de erro ou mensagens DET ou DEM não estão definidos no payload. Em caso de erro, presume-se, portanto, que não haja garantias quanto à preservação ou consistência do estado do contêiner, razão pela qual os pontos de chamada devem prever medidas de proteção adequadas. Pergunta (aberta)

Interação

O elemento de especificação está em relação direta com a sobrecarga node_type extract(const_iterator position) [SWS_CORE_01470]. Enquanto a presente função identifica e extrai um elemento através da chave de busca [SWS_CORE_01471], a variante relacionada permite a remoção orientada através de uma posição de iterador já conhecida [SWS_CORE_01470]. Ambas as interfaces pertencem ao escopo de ara::core::Map e compartilham a mesma característica de ausência de segurança contra exceções [SWS_CORE_01470] [SWS_CORE_01471].

usar

A função-membro find da classe ara::core::Map destina-se à localização síncrona de um elemento com base na sua chave [SWS_CORE_01490]. A função está declarada no ficheiro de cabeçalho ara/core/map.h. Aceita uma referência para a chave pesquisada (const key_type &x) e devolve um iterator modificável para o par chave-valor encontrado; se não for encontrada nenhuma entrada correspondente, o retorno equivale ao iterador de fim (end iterator) do mapa [SWS_CORE_01490].

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

De acordo com a especificação, esta função está classificada como not exception safe [SWS_CORE_01490]. Mensagens de erro via DET ou DEM não estão especificadas para este serviço básico de contentor. Se ocorrerem erros operacionais durante a comparação, podem ser propagadas exceções do operador de comparação subjacente.

Concorrência e interação

Dado tratar-se de uma função-membro não constante que fornece um iterador com capacidade de escrita, o acesso simultâneo sem sincronização presumivelmente não é seguro para threads. Pergunta Q-0f9f56b506cfd318 (aberta) Para o acesso puramente de leitura em instâncias constantes de ara::core::Map, está disponível a sobrecarga com const_iterator [SWS_CORE_01491]. Complementarmente, sobrecargas baseadas em modelos suportam uma pesquisa transparente com tipos de comparação compatíveis K, tanto de forma modificadora [SWS_CORE_01492] como constante [SWS_CORE_01493]. Ao contrário das funções find baseadas em carateres em ara::core::StringView [SWS_CORE_02157] ou ara::core::BasicString [SWS_CORE_03315], que devolvem índices do tipo size_type e são parcialmente noexcept, esta função opera com base em contentor através de iteradores.

A função-membro constante find da classe ara::core::Map destina-se à localização síncrona de uma entrada com base em sua chave [SWS_CORE_01491]. Para a chamada, o cabeçalho #include "ara/core/map.h" deve ser incluído. Como parâmetro, a função espera uma referência à chave pesquisada const key_type &x. O comportamento corresponde à especificação de [map] no padrão C++, de modo que, havendo sucesso na busca, é retornado um const_iterator para o elemento e, caso contrário, presume-se que seja fornecido end() [SWS_CORE_01491]. Pergunta Q-dca69a1ec5423a8b (aberta)

Em relação ao tratamento de erros, a função é declarada como not exception safe [SWS_CORE_01491]. Como o processo de busca se baseia na comparação de chaves, eventuais exceções ocorridas devem resultar primariamente da operação de comparação definida pelo usuário. Para este contêiner elementar, não estão definidas mensagens de erro DET ou DEM. Por se tratar de uma operação de leitura sobre uma instância constante, o acesso concorrente de múltiplas threads ao mesmo objeto pode ser paralelizado de acordo com a semântica habitual de contêineres C++, desde que não ocorram modificações simultâneas (interpretação). Pergunta Q-a8ec748711885418 (aberta)

Na interação com outras interfaces, o método complementa a variante não constante [SWS_CORE_01490], a qual fornece um iterator modificável. Para operações de busca heterogêneas sem conversão de tipo, estão disponíveis em ara::core::Map sobrecargas de template adicionais para instâncias modificáveis [SWS_CORE_01492] e constantes [SWS_CORE_01493]. Funções de busca com o mesmo nome também existem no módulo Core para classes de cadeias de caracteres como ara::core::BasicString [SWS_CORE_03407] e ara::core::StringView [SWS_CORE_02157].

A função-membro de template find, conforme [SWS_CORE_01492], destina-se à localização síncrona de um elemento dentro de uma instância de ara::core::Map por meio do arquivo de cabeçalho ara/core/map.h. Ela recebe um parâmetro de referência const K &x e retorna um iterator modificável para o par chave-valor encontrado ou o iterador final do contêiner. A especificação remete ao comportamento de [map]; presume-se que a forma genérica do parâmetro seja interpretada aqui como uma busca de chave heterogênea, a fim de comparar chaves de busca de tipos divergentes sem conversão prévia. Pergunta Q-425357890b9ea3fe (aberta)

Em relação ao tratamento de erros e à segurança contra exceções, a função é classificada explicitamente como not exception safe ([SWS_CORE_01492]). Códigos de erro específicos, valores de retorno para estados de erro ou mensagens DET/DEM não estão definidos no payload. Caso ocorra uma exceção durante a comparação ou o percurso interno, a chamada não oferece garantia de exceção.

Na interação dentro de ara::core::Map, a função constitui o equivalente não constante à busca heterogênea constante [SWS_CORE_01493], bem como às sobrecargas não genéricas [SWS_CORE_01490] e [SWS_CORE_01491], que estão vinculadas fixamente a const key_type &x em cada caso. Ela difere fundamentalmente das funções de busca homônimas de outros contêineres como ara::core::StringView ([SWS_CORE_02157]) ou ara::core::BasicString ([SWS_CORE_03315]), as quais realizam buscas de posição baseadas em cadeias de caracteres e são parcialmente declaradas como noexcept.

usar

A função-membro de template find no namespace ara::core::Map destina-se à localização somente leitura de elementos com base em uma chave x do tipo K [SWS_CORE_01493]. A função está definida no cabeçalho #include "ara/core/map.h" e é chamada sincronamente sobre uma instância constante [SWS_CORE_01493]. Ela retorna um const_iterator para o elemento encontrado; interpretação: no caso de uma chave inexistente, presume-se que o iterador retornado corresponda ao iterador final do mapa, já que a semântica segue, de acordo com a especificação, o comportamento de [map] [SWS_CORE_01493]. Pergunta Q-3fa354022f0bca9b (aberta)

Tratamento de erros e condições de contorno

Em relação à tolerância a falhas, a função é classificada explicitamente como not exception safe [SWS_CORE_01493]. Códigos de erro específicos, valores de retorno para indicação de erro ou notificações para DET ou DEM não estão definidos na especificação. Os chamadores devem observar que, no caso de ocorrência de exceções durante o processo de busca ou comparação, nenhuma garantia de segurança contra exceções é fornecida [SWS_CORE_01493].

Interação

Dentro de ara::core::Map, esta sobrecarga completa as operações de busca:

• Ela complementa a variante de template não constante iterator find(const K &x) [SWS_CORE_01492].
• Ela forma a contraparte genérica para as sobrecargas com const key_type &x fixo, as quais são declaradas como não constante [SWS_CORE_01490] e constante [SWS_CORE_01491].

Ela difere, portanto, das operações homônimas em ara::core::StringView (por exemplo, [SWS_CORE_02157]) e ara::core::BasicString (por exemplo, [SWS_CORE_03315]), que operam sobre cadeias de caracteres, fornecem posições do tipo size_type e são declaradas como exception safe.

usar

A função insert no contexto de ara::core::Map serve para adicionar sincronicamente um elemento de valor por cópia através do parâmetro const value_type &x ([SWS_CORE_01460]). A operação é incluída através do ficheiro de cabeçalho ara/core/map.h. O tipo de retorno std::pair<iterator, bool> segue a especificação “As per corresponding usage in [map]”: Interpretação: neste caso, o iterador deverá apontar para o elemento recém-inserido ou já existente, enquanto a flag booleana assinala a nova inserção bem-sucedida. Pergunta Q-b059c1d0f4dd6665 (aberta)

Tratamento de erros

Na especificação não estão previstos códigos de erro AUTOSAR específicos, tais como mensagens DET ou DEM. A função está expressamente declarada como não segura contra exceções (“not exception safe”) ([SWS_CORE_01460]). Se uma alocação de memória interna ou a cópia do elemento falhar, o contentor não oferece garantias de exceção ou de rollback; tal erro deverá presumivelmente conduzir a uma interrupção ou a um estado indefinido. Pergunta Q-cbe74b301167bcc4 (aberta)

Simultaneidade e restrições

A chamada ocorre sincronicamente na thread do chamador. As operações do contentor não possuem sincronização integrada, pelo que a função não é reentrante em relação à mesma instância. Os acessos paralelos de leitura ou escrita devem ser protegidos pelo chamador.

Interação

Para ara::core::Map existem sobrecargas complementares de insert:

• Variantes baseadas em move para valores temporários ([SWS_CORE_01461], [SWS_CORE_01462]),
• Operações de inserção baseadas em posição com sugestão de iterador ([SWS_CORE_01463], [SWS_CORE_01464]),
• Listas de intervalos e de inicialização ([SWS_CORE_01466], [SWS_CORE_01467]), bem como transferências de node handle ([SWS_CORE_01468], [SWS_CORE_01469]).

Operações de inserção análogas encontram-se com assinaturas adaptadas noutras classes do Core, como ara::core::Vector ([SWS_CORE_01367]) e ara::core::BasicString ([SWS_CORE_03093]).

A função de elemento insert de ara::core::Map insere um elemento de forma síncrona no contêiner associativo por meio da semântica de movimento através de uma referência rvalue (value_type &&x) ([SWS_CORE_01461]). A declaração ocorre através do arquivo de cabeçalho #include "ara/core/map.h" ([SWS_CORE_01461]). O comportamento funcional orienta-se, conforme a especificação, pelo uso correspondente em [map] do padrão C++ ([SWS_CORE_01461]). Como valor de retorno, a função devolve um std::pair<iterator, bool>; Interpretação: aqui o valor booleano provavelmente deve sinalizar se o elemento foi recém-inserido, enquanto o iterador aponta para o elemento no contêiner ([SWS_CORE_01461]). Pergunta Q-e1901e26d8be3470 (aberta)

Em relação ao tratamento de erros e à segurança contra exceções, a função é explicitamente classificada na especificação como not exception safe ([SWS_CORE_01461]). Códigos de erro específicos ou mensagens de erro do AUTOSAR como DET ou DEM não estão especificados para esta chamada.

Na interação dentro de ara::core::Map, esta sobrecarga representa a contraparte baseada em rvalue para a variante de cópia insert(const value_type &) ([SWS_CORE_01460]) e para a versão genérica de template insert(P &&) ([SWS_CORE_01462]). Para processos de inserção com especificação de posição, estão disponíveis adicionalmente sobrecargas com iterador de dica como insert(const_iterator, value_type &&) ([SWS_CORE_01464]) bem como para manipuladores de nós através de insert(node_type &&) ([SWS_CORE_01468]) utilizando insert_return_type ([SWS_CORE_01418]).

A função-membro template insert da classe ara::core::Map destina-se à inserção síncrona de um par chave-valor compatível através de uma referência de encaminhamento P&& x na instância de contêiner associativo [SWS_CORE_01462]. Ela é incluída através do cabeçalho #include "ara/core/map.h" e remete, quanto ao seu comportamento, à semântica de [map] [SWS_CORE_01462]. Como valor de retorno, fornece um std::pair<iterator, bool> [SWS_CORE_01462]. Interpretação: o valor de retorno booleano deve sinalizar se uma nova entrada foi criada, enquanto o iterador aponta para o elemento recém-inserido ou já existente. Pergunta Q-64d2947d60792374 (aberta)

No que diz respeito ao tratamento de erros, a função é expressamente classificada na especificação como não segura contra exceções (not exception safe) [SWS_CORE_01462]. Códigos de erro específicos, mensagens de erro ou interfaces para memórias de diagnóstico e de falhas, como DET ou DEM, não estão especificados para esta chamada.

Em relação à simultaneidade e condições de contorno, a chamada modifica o estado do mapa; portanto, o acesso simultâneo à mesma instância provavelmente não é reentrante e requer proteção externa contra corridas de dados (data races). Pergunta (aberta) A execução ocorre de forma síncrona no contexto da thread chamadora.

Na interação dentro de ara::core::Map, esta função genérica representa uma complementação às sobrecargas diretas para const value_type& [SWS_CORE_01460] e value_type&& [SWS_CORE_01461]. Além disso, existem operações de inserção baseadas em posição com dica de iterador (iterator hint) [SWS_CORE_01465], operações de intervalo [SWS_CORE_01466], bem como a inserção de node handles através de insert_return_type [SWS_CORE_01418] [SWS_CORE_01468].