classe ara::core::Variant

A função de elemento emplace constrói um valor alternativo do tipo T diretamente em uma instância existente de ara::core::Variant [SWS_CORE_01661]. A função é disponibilizada através do arquivo de cabeçalho #include "ara/core/variant.h" e executada de forma síncrona [SWS_CORE_01661]. Como parâmetros, ela recebe referências de encaminhamento args..., que são passadas para o construtor do tipo de destino T, e retorna uma referência ao objeto recém-criado [SWS_CORE_01661].

Em relação ao tratamento de erros, a operação é declarada como condicionalmente segura contra exceções («conditionally exception safe») [SWS_CORE_01661]. Ela segue o comportamento padrão de variant, mas diverge através de uma especificação condicional de noexcept: uma exceção é excluída exatamente se std::is_nothrow_constructible<T, Args...>::value for satisfeito [SWS_CORE_01661]. Códigos de erro específicos do AUTOSAR ou mensagens para DET ou DEM não estão definidos para esta função básica.

Em termos de concorrência e contexto de chamada, a especificação não menciona garantias divergentes. Interpretação: o acesso simultâneo de escrita de múltiplas threads à mesma instância de Variant via emplace provavelmente não é seguro para threads sem sincronização externa, já que o AUTOSAR remete à semântica padrão de variant. Pergunta Q-4d9d118b9916a3dc (aberta)

Na interação dentro de ara::core::Variant, existem outras sobrecargas para listas de inicialização [SWS_CORE_01662] bem como construções in-place baseadas em índice [SWS_CORE_01663], [SWS_CORE_01664]. Operações emplace análogas também estão especificadas no módulo Core para ara::core::Optional ([SWS_CORE_01119], [SWS_CORE_01120], [SWS_CORE_01164]), assim como para contêineres como ara::core::Vector [SWS_CORE_01366] e ara::core::Map [SWS_CORE_01458].

A função-membro emplace de ara::core::Variant do cabeçalho ara/core/variant.h destina-se à criação síncrona de uma alternativa do tipo T diretamente na memória da instância existente [SWS_CORE_01662]. Nesse processo, uma std::initializer_list<U>, bem como argumentos encaminhados Args&&... args, são passados ao construtor do tipo. Como valor de retorno, a função fornece uma referência lvalue T& para o objeto recém-inicializado [SWS_CORE_01662].

Em relação ao tratamento de erros e exceções, a função diverge da definição padrão em [variant]: ela é classificada como condicionalmente segura contra exceções (conditionally exception safe) e possui uma especificação condicional noexcept [SWS_CORE_01662]. Uma chamada garante ausência de exceções, desde que std::is_nothrow_constructible<T, std::initializer_list<U>&, Args&&...>::value seja avaliado como true [SWS_CORE_01662]. Não existem códigos de erro AUTOSAR específicos ou canais de notificação para DET e DEM para este elemento.

Em relação à simultaneidade e condições de contorno, aplica-se: como emplace altera o estado da instância de variant, uma chamada concorrente sem sincronização externa provavelmente não é segura para threads. Interpretação: antes da construção do novo objeto, um valor previamente contido é destruído, conforme corresponde ao comportamento geral de [variant]. Pergunta Q-548c84cc1d327030 (aberta)

Na interação com interfaces relacionadas, a função constitui o equivalente baseado em tipo para a sobrecarga sem lista de inicialização [SWS_CORE_01661], bem como para as alternativas baseadas em índice [SWS_CORE_01663] e [SWS_CORE_01664]. Conceitos de interface semelhantes encontram-se em ara::core::Optional [SWS_CORE_01120], bem como em contêineres como ara::core::Vector [SWS_CORE_01366] ou ara::core::Map [SWS_CORE_01458], sendo que as operações emplace de contêineres, diferentemente desta, não são seguras contra exceções.

usar

A função-membro emplace da classe ara::core::Variant ([SWS_CORE_01663]) do arquivo de cabeçalho ara/core/variant.h destina-se à construção direta da alternativa determinada pelo índice de template I na memória existente do objeto. Como parâmetros, são passados os argumentos Args&&... args. A chamada ocorre de forma síncrona e retorna uma referência para o valor recém-criado do tipo variant_alternative_t<I, Variant<Types...>> ([SWS_CORE_01663]). O comportamento orienta-se pela definição em [variant] ([SWS_CORE_01663]).

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

A especificação define, como divergência do padrão C++, uma cláusula condicional noexcept({<cond-noexcept-11>}), bem como a propriedade conditionally exception safe ([SWS_CORE_01663]). Provavelmente, o lançamento de exceções depende de o construtor da alternativa de destino ser seguro contra exceções para os tipos repassados Args.... Pergunta Q-189fe417e9ef4980 (aberta) Códigos de erro específicos, valores de retorno em caso de falha ou notificações ao DET ou DEM não estão especificados para esta função.

Interação e alternativas

Dentro do módulo core e do tipo ara::core::Variant, a função está inserida em um sistema de outras sobrecargas:

• Inicialização baseada em índice com uma std::initializer_list sob [SWS_CORE_01664].
• Criação de uma alternativa baseada em tipo através do nome de tipo T por meio de [SWS_CORE_01661] ou em combinação com std::initializer_list via [SWS_CORE_01662].
• Mecanismos in-place correspondentes também são encontrados entre contêineres em ara::core::Optional ([SWS_CORE_01119], [SWS_CORE_01120], [SWS_CORE_01164]), ara::core::Vector ([SWS_CORE_01366]) e ara::core::Map ([SWS_CORE_01458]).

A função membro emplace de ara/core/variant.h constrói sincronicamente um novo valor alternativo diretamente in-place dentro de uma instância existente de ara::core::Variant [SWS_CORE_01664]. O tipo a ser endereçado é determinado de forma fixa por meio do índice de template I. A chamada recebe uma lista de inicializadores il do tipo std::initializer_list<U> bem como argumentos opcionais args e retorna uma referência ao valor recém-criado do tipo variant_alternative_t<I, Variant<Types...>>& [SWS_CORE_01664].

Para o tratamento de erros, a operação é classificada como condicionalmente segura contra exceções (conditionally exception safe) e dotada de um noexcept condicional [SWS_CORE_01664]. A avaliação da condição {<cond-noexcept-12>} presumivelmente deve depender de o construtor do tipo de destino com il e args não lançar exceções. Pergunta Q-87f90253fc61c883 (aberta) Códigos de erro específicos bem como notificações para DET ou DEM não estão definidos na especificação; o comportamento em caso de exceções segue, à exceção da declaração noexcept, o comportamento padrão de [variant] [SWS_CORE_01664].

Dentro de ara::core::Variant, a função complementa a criação baseada em índice sem lista de inicializadores [SWS_CORE_01663] bem como ambas as variantes baseadas em tipo [SWS_CORE_01661] e [SWS_CORE_01662]. Funções emplace análogas para a construção direta in-place também existem no módulo core para ara::core::Optional ([SWS_CORE_01119], [SWS_CORE_01120], [SWS_CORE_01164]) bem como para contêineres como ara::core::Vector ([SWS_CORE_01366]) e ara::core::Map ([SWS_CORE_01458]).

A função-membro index da classe ara::core::Variant serve para a consulta síncrona do índice de base zero do tipo atualmente contido, conforme a especificação [SWS_CORE_01665]. Ela comporta-se de forma análoga ao uso correspondente no tipo padrão C++ std::variant («As per corresponding usage in [variant]»), não aceita parâmetros e retorna o índice atual como std::size_t. Está declarada no cabeçalho ara/core/variant.h e qualificada como constexpr bem como noexcept.

No que diz respeito ao tratamento de erros e à segurança contra exceções, o método é especificado como exception safe [SWS_CORE_01665]. Como está declarado como noexcept, ele próprio não lança exceções e não dispara condições de erro. Os chamadores podem avaliar o índice retornado a fim de garantir, antes do acesso a valores alternativos, qual tipo está ativo em ara::core::Variant.

Na interação com as funções de acesso tipadas ara::core::get, index desempenha um papel central: as sobrecargas de get para lvalues e rvalues verificam explicitamente a condição variant.index() != I conforme [SWS_CORE_01613], [SWS_CORE_01614], [SWS_CORE_01615] e [SWS_CORE_01616]. Se o índice não coincidir com o índice posicional requisitado I, a violação IsoStdBadVariantAccessViolation é disparada, divergindo de std::bad_variant_access. Uma comparação prévia mediante index() evita este acesso errôneo em tempo de execução.

No que se refere à concorrência, o método é seguro como operação const para acessos de leitura concorrentes ao mesmo variant, desde que não ocorram modificações concorrentes; presume-se que não exista uma sincronização interna contra acessos simultâneos de escrita. Pergunta Q-12e0dad0a6b8c5d0 (aberta)

usar

A função-membro valueless_by_exception da classe ara::core::Variant é disponibilizada no módulo core através do arquivo de cabeçalho #include "ara/core/variant.h" ([SWS_CORE_01666]). Correspondendo à sua assinatura constexpr bool valueless_by_exception () const noexcept;, ela não requer parâmetros de chamada e retorna de forma síncrona um valor booleano ([SWS_CORE_01666]). O significado funcional orienta-se pela semântica habitual de [variant] («As per corresponding usage in [variant]») ([SWS_CORE_01666]). Interpretação: O status retornado true provavelmente sinaliza ao chamador que uma atribuição de valor ou alteração de tipo anterior foi interrompida pela ocorrência de uma exceção e que o objeto Variant, portanto, temporariamente não representa um estado válido. Pergunta Q-af7c00c7eb4ef5a1 (aberta)

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

Quanto ao comportamento perante falhas, o método é declarado como noexcept e formalmente classificado como exception safe ([SWS_CORE_01666]). Não existe um caso de erro próprio na consulta; a função não lança exceções C++ ([SWS_CORE_01666]). Códigos de erro específicos, descrições de resposta ou mensagens para instâncias de diagnóstico e monitoramento de erros como DET ou DEM não estão definidos para este elemento ([SWS_CORE_01666]).

Simultaneidade e restrições

Como valueless_by_exception é especificado como método const e constexpr, não ocorre nenhum acesso modificador ao estado interno do objeto durante a execução ([SWS_CORE_01666]). Interpretação: Consultas simultâneas de leitura da mesma instância a partir de múltiplas threads deverão ser passíveis de execução com segurança sem sincronização especial, desde que operações de escrita concorrentes permaneçam excluídas. Pergunta Q-5c28f8cef1c1f097 (aberta)