namespace std

O namespace std disponibiliza no módulo core especializações de template de std::hash, std::tuple_size e std::tuple_element para tipos de dados da AUTOSAR Adaptive Platform. Isto permite a utilização direta de tipos como ara::core::String, ara::core::Optional, ara::core::Variant, ara::core::Vector e ara::core::Array em contentores padrão e com recursos de tuplas de C++. O requisito de contorno é que, em tipos aninhados, os tipos de dados contidos também devem dispor de especializações válidas em tempo de compilação.

mais ›

Contexto

No módulo core da AUTOSAR Adaptive Platform, o namespace std serve para a integração transparente de tipos base específicos da plataforma na biblioteca padrão C++. Em vez de introduzir novos tipos, o namespace fornece especializações direcionadas de templates de classes utilitárias padronizadas. Os intervenientes na interação abrangem três componentes essenciais: os tipos genéricos da biblioteca padrão C++ (em particular contentores associativos não ordenados e utilitários de tuplas), as especializações de template dentro de std, bem como os tipos de dados ara::core::Array, ara::core::Monostate, ara::core::Optional, ara::core::String, ara::core::StringView, ara::core::Variant e ara::core::Vector definidos no módulo core.

Diagrama de contexto: Interação de contentores padrão, das especializações em std e dos tipos ara::core. Fontes: Declarações de payload do módulo core

As especializações de std::hash permitem utilizar tipos de dados nucleares adaptativos diretamente como chaves em contentores padrão como std::unordered_map ou std::unordered_set. Paralelamente, as especializações std::tuple_size e std::tuple_element para ara::core::Array expandem o suporte para interfaces padronizadas de metaprogramação e recursos da linguagem.

Caminho de utilização

Um percurso de utilização típico começa com a utilização de um tipo de dados ara::core em código genérico C++. Por exemplo, uma aplicação declara uma tabela de hash com chaves do tipo ara::core::String ou ara::core::Optional<T>. Ao inserir, remover ou consultar, o contentor acede implicitamente a std::hash<ara::core::String> ou std::hash<ara::core::Optional<T>> para determinar o valor de hash da chave.

As especializações cobrem diferentes estruturas de dados:

• Strings e vistas: std::hash<ara::core::String> e std::hash<ara::core::StringView> calculam valores de hash sobre a sequência de caracteres contida.
• Tipos compostos: std::hash<ara::core::Optional<T>>, std::hash<ara::core::Variant<...>> e std::hash<ara::core::Vector<T, Allocator>> possibilitam o hashing de estruturas de tipos complexas. Interpretação: É provável que as especializações para ara::core::Optional e ara::core::Variant se orientem pelo comportamento semântico dos modelos padronizados e produzam valores determinísticos para estados vazios ou não preenchidos. Pergunta Q-c432b06f0ba32c5e (aberta)
• Tipos sem estado: std::hash<ara::core::Monostate> disponibiliza uma função de hash para estados vazios, tal como são tipicamente utilizados em variantes.
• Protocolo de tupla: Para campos de dados fixos, std::tuple_size<ara::core::Array<T, N>> fornece o número de elementos em tempo de compilação, enquanto std::tuple_element<I, ara::core::Array<T, N>> determina o tipo de dados da posição I. Interpretação: As especializações de std::tuple_size e std::tuple_element deverão assim viabilizar a utilização de ara::core::Array com vinculações estruturadas (Structured Bindings). Pergunta Q-3abb70390e67dbce (aberta)

Cenários de erro

Dado que os elementos no namespace std são exclusivamente especializações de template, os cenários de erro ocorrem predominantemente em tempo de compilação. As constelações de problemas típicas incluem:

• Capacidade de hashing em falta nos tipos base: Se std::hash for instanciado para um tipo aninhado como ara::core::Optional<T> ou ara::core::Vector<T, Allocator>, deve existir também uma especialização válida de std::hash para o tipo de elemento T. Se esta faltar, tal resulta num erro de compilação.
• Indexação inválida no protocolo de tupla: O acesso a std::tuple_element<I, ara::core::Array<T, N>> com um índice I >= N viola a pré-condição do template e aborta o processo de compilação.

Interpretação: Os cenários de erro devem limitar-se essencialmente a erros em tempo de compilação no caso de especializações de tipo incompletas ou violações estáticas de limites, uma vez que o excerto da especificação não define códigos de erro em tempo de execução nem interfaces de exceção. Pergunta Q-8cda269c72bd701c (aberta)