Descrição das Transformações UML-para-C++

A transformação UML em C++ transforma os elementos de modelo UML em código C++.

Preferências para Geração de Códigos e Formatação

É possível configurar as preferências a seguir para transformações UML-para-C++:

Formato dos comentários que a transformação insere no início e final dos arquivos que ele gera
Espaçamento da guia, a ordem de exibição dos atributos de classe e operações e estilos de indentação
Geração de diretivas de inclusão que se relacionam às classes Standard Template Library (STL)
Exibição de avisos ao substituir elementos de modelo de UML de origem por ponteiros para os elementos gerados

Para obter informações adicionais sobre como configurar preferências de transformação, consulte o link para o tópico da tarefa "Transformando Modelos" relacionado no final deste tópico.

Origens de Transformação Válidas

A tabela a seguir lista os objetos de origem UML que a transformação pode converter em código C++, dependendo do design contract management protocol (DCMP) que você especificar na configuração de transformação:

DCMP	Objetos de Origem de UML
Modelos Concretos de Valor Inicial de Modelos Conceituais	É possível selecionar os seguintes elementos de um ou mais projetos UML na área de trabalho atual: Modelos Pacotes Classificadores não aninhados: Classes Enumerações Interfaces Componentes
Desenvolvimento de Unidade de Modelos Conceituais
Modelagem Reconciliada	É possível selecionar um ou mais elementos na lista anterior: Se você selecionar vários pacotes ou classificadores não aninhados como a origem da transformação de UML em C++, eles devem estar contidos no mesmo modelo UML. Se você selecionar um ou mais classificadores não aninhados como a origem da transformação de UML em C++, a transformação reversa, ou de C++ em UML, determina o pacote de nível-raiz do primeiro classificador não aninhado que a transformação reversa processa. A transformação reversa gera sua saída nesse pacote de nível-raiz.

DCMP

Objetos de Origem de UML

Modelos Concretos de Valor Inicial de Modelos Conceituais

É possível selecionar os seguintes elementos de um ou mais projetos UML na área de trabalho atual:

Modelos
Pacotes
Classificadores não aninhados:
- Classes
- Enumerações
- Interfaces
- Componentes

Desenvolvimento de Unidade de Modelos Conceituais

Modelagem Reconciliada

É possível selecionar um ou mais elementos na lista anterior:

Se você selecionar vários pacotes ou classificadores não aninhados como a origem da transformação de UML em C++, eles devem estar contidos no mesmo modelo UML.

Se você selecionar um ou mais classificadores não aninhados como a origem da transformação de UML em C++, a transformação reversa, ou de C++ em UML, determina o pacote de nível-raiz do primeiro classificador não aninhado que a transformação reversa processa. A transformação reversa gera sua saída nesse pacote de nível-raiz.

É possível especificar os elementos de modelo que a transformação deve converter em código C++ ao criar ou editar uma configuração de transformação, ou selecionando os elementos de modelo diretamente no modelo. Os elementos de modelo selecionados são a origem para uma transformação. Uma mensagem de erro será gerada pela transformação se você selecionar um contêiner e seus elementos de modelo ou o mesmo elemento de modelo duas vezes.

É possível utilizar componentes para organizar os elementos de um modelo que você deseja converter em código C++. Se você selecionar um componente, a transformação UML-para-C++ converterá pacotes e classes relacionados em código C++ quando um componente tiver um relacionamento de uso com pacotes e classes.

Nomes Válidos para Origens de Transformação

Os nomes dos elementos de origem UML podem começar com uma letra minúscula, letra maiúscula ou um sublinhado (_). Os caracteres subsequentes podem ser letras minúsculas, letras maiúsculas ou números. É possível utilizar dois-pontos (:) em um nome de operação para especificar nomes completos para funções amigáveis. A transformação prefixa um nome que começa com um número ou um caractere inválido com um sublinhado (_). A transformação verifica se os nomes em um espaço de nomes relevante são exclusivos; se os nomes não forem exclusivos, a transformação designará o nome duplicado como um sufixo que consiste em um sublinhado e um número incremental; por exemplo _1.

Para melhorar a capacidade de leitura do código gerado e minimizar as diferenças entre o modelo UML e o código gerado, você deve corrigir nomes inutilizáveis no modelo UML de origem antes de executar a transformação.

Destinos de Transformação Válidos

Um destino de transformação válido é um projeto C++. Se você criar um contêiner de destino, será possível criar um projeto C++ padrão, que usa um comando makefile criado ou existente, ou criar um projeto de criação gerenciado, que gera o comando makefile automaticamente.

Quando a transformação UML em C++ é executada, ela gera a saída no projeto C++ de destino e a saída possui a mesma hierarquia que os elementos no modelo UML de origem. Se você selecionar o DCMP Modelagem Reconciliada na configuração de transformação, na transformação C++ em UML ou reversa, a transformação gerará elementos UML na mesma hierarquia que o projeto C++.

Local da Saída da Transformação

A transformação gera arquivos de código C++ nos projetos e pastas C++ que são especificados como o destino da transformação.

Sincronização dos Elementos de Modelo de UML e Código C++

Para facilitar a sincronização de código C++ e elementos de modelo UML, é possível especificar que a transformação define um tipo de link chamado de relacionamento rastreável entre os elementos UML e os elementos de código C++. É possível especificar esta opção ao configurar uma transformação C++ em UML ou UML-para-C++ para usar o Protocolo de Gerenciamento de Contrato de Design (DCMP) do Modelagem Reconciliada ou Conceitual. Ao executar a transformação, ela cria relacionamentos rastreáveis incluindo anotações e identificadores nos elementos gerados. A geração de relacionamentos rastreáveis evita que a transformação C++ em UML gere elementos duplicados no modelo de UML.

A transformação gera relacionamentos rastreáveis para os seguintes elementos:

Classes, estruturas e uniões
Interfaces
Métodos
Atributos
Tipos de Typedef
Enumerações
Literais de Enumeração

Customização de Código C++ Gerado

A transformação UML-para-C++ chama uma transformação JET para gerar o código C++. É possível criar uma transformação JET de substituição e modificar os modelos nessa transformação para incluir elementos de código, tais como comentários específicos da organização, no código gerado. Ao criar uma configuração para a transformação UML-para-C++, é necessário especificar o identificador da transformação JET de substituição.

Transformação de Elementos de Modelo UML

A tabela a seguir lista como a transformação UML-para-C++ transforma elementos de modelo UML em código C++.

Elemento de Modelo UML	Elemento de código C++
Relacionamento de associação	Atributo de classe
Classe	Classe (arquivos .h e .cpp)
Relacionamento de dependência	Inclusão, referência de encaminhamento ou nenhum Nota: As configurações na página Propriedades de C++ da janela Propriedades determinam o que é gerado no cabeçalho e nos arquivos de implementação.
Enumeração	Enum (arquivo .h)
Relacionamento de generalização	Herança de classe
Operação	Operação
Pacote	Pasta
Parâmetro	Argumento de operação
Propriedade	Atributo de classe
Relacionamento de Ligação de Gabarito	Classe instanciada (arquivo .h)
Classe de modelo	Arquivo de cabeçalho (arquivo .h) que tem o mesmo nome que a classe de modelo UML Nota: O código do corpo de método também é gerado no arquivo de cabeçalho.
Parâmetro de gabarito	Parâmetro para uma classe parametrizada

Para obter informações adicionais sobre como a transformação transforma elementos de modelo UML, consulte o tópico de referência relacionada no final desse tópico.

Suporte para Métodos e Variáveis Globais C++

É possível modelar métodos e variáveis globais C++ incluindo esses elementos a uma classe UML que tenha o estereótipo «cpp_globals» aplicado. Para obter mais informações sobre métodos globais e modelagem reconciliada, consulte o tópico de tarefa relacionado abaixo.

Relacionamentos de Rastreio entre os Elementos de Modelo de Origem e a Saída da Transformação

Para entender como os elementos de um modelo de origem estão relacionados aos elementos em um projeto de destino, é possível permitir que uma transformação crie relacionamentos de rastreio dos elementos de modelo de origem com os elementos gerados no projeto de destino. Depois, é possível visualizar os relacionamentos de rastreio em um diagrama de tópicos, criando e executado consultas do modelo.

A criação de relacionamentos de rastreio é útil em projetos grandes que podem conter vários modelos e várias configurações de transformação. Você também pode criar e executar consultas de rastreabilidade que exibem como a saída da transformação está relacionada às especificações de software e aos elementos de modelo.

Quando você executa uma transformação configurada para gerar relacionamentos de rastreio entre o modelo de origem e a saída da transformação, para cada elemento UML que suporta a tag @generated, a transformação inclui um comentário de código-fonte na saída da transformação. O comentário começa com //@uml.annotations e contém um identificador exclusivo para o elemento de modelo. Se você renomear os elementos no modelo UML de origem, esse identificador exclusivo ativará a funcionalidade de mesclagem para refatorar e mesclar os elementos apropriados. Além disso, se você renomear, mover ou excluir elementos a partir do modelo UML de origem e esses elementos possuírem representações C++ visuais correspondentes, quando você reexecutar a transformação UML em C++, a transformação atualizará as referências nas representações visuais C++.

Nota: Se mover um elemento UML fora do escopo de sua classe de nível mais alto, quando você reexecutar a transformação, o algoritmo de mesclagem não refatorará ou mesclará o elemento renomeado porque o escopo do elemento foi alterado.

A transformação não altera o modelo de origem quando você especifica para a transformação gerar relacionamentos de rastreio.

Para visualizar os relacionamentos entre os elementos de modelo de origem e a saída da transformação, é possível visualizar o elemento de modelo de origem em um diagrama e arrastar o elemento de código gerado pela transformação para esse diagrama. A tabela a seguir lista o seguinte: a representação UML para um elemento de modelo de origem nomeado Class1, que contém um atributo de número inteiro nomeado attribute1 e duas operações nomeadas Operation1 e Operation2, que não possuem nenhum parâmetro; o código gerado pela transformação; o diagrama de classes que mostra o relacionamento de rastreio entre os elementos.

Elemento UML Saída da Transformação Relacionamento Derivado em um Diagrama de Classes

Elemento UML	Saída da Transformação	Relacionamento Derivado em um Diagrama de Classes
	#ifndef CLASS1_H #define CLASS1_H //Iniciar seção para o arquivo Class1.h //TAREFA A FAZER: Incluir definições preservadas //Encerrar seção para o arquivo Class1.h //@uml.annotationsderived_abstraction="platform:/resource/MyModels/UMLModel.emx#_biwQUHdCEduVaMk1fL7Qcw" //@generated "UML para C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)" class Class1 { //Iniciar seção para Class1 //TAREFA A FAZER: Incluir atributos a serem preservados //Encerrar seção para Class1 private: //@generated "UML para C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)" int attribute1; public: //@generated "UML para C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)" int Operation1(); //@generated "UML para C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)" int Operation2(); }; //encerrar Classe Class1 #endif

Esta imagem mostra uma classe UML nomeada Class1 que tem um atributo de número inteiro e duas operações que não têm parâmetros de entrada ou saída.

#ifndef CLASS1_H
#define CLASS1_H
//Iniciar seção para o arquivo Class1.h
//TAREFA A FAZER: Incluir definições preservadas
//Encerrar seção para o arquivo Class1.h

//@uml.annotationsderived_abstraction="platform:/resource/MyModels/UMLModel.emx#_biwQUHdCEduVaMk1fL7Qcw"
//@generated "UML para C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)"
class Class1 {

    //Iniciar seção para Class1
    //TAREFA A FAZER: Incluir atributos a serem preservados
    //Encerrar seção para Class1

    private:

        //@generated "UML para C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)"
        int attribute1;
    public:

        //@generated "UML para C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)"
        int Operation1();

        //@generated "UML para C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)"
        int Operation2();

};  //encerrar Classe Class1

#endif

Esta imagem mostra o relacionamento de abstração, com o estereótipo de derivação aplicado, entre Class1 e sua representação visual.

Operações Padrão de C++

As operações padrão são construtores, construtores de cópia, destrutores virtuais e não virtuais, operadores de designação e métodos getter e setter. É possível especificar quais operações padrão a transformação UML para C++ gera para as classes, estruturas e uniões em um modelo UML. Também é possível incluir um estereótipo, que representa uma das operações padrão, na operação de uma classe no modelo. A transformação de UML em C++ aplica a visibilidade da operação UML para as operações padrão geradas, mas ignora o nome e os parâmetros da operação UML.

Integração com a Equipe de Suporte

A transformação fornece funcionalidade de integração com os sistemas de controle de versão IBM® Rational Team Concert, CVS, Rational ClearCase, e Rational ClearCase LT, que possibilita efetuar o registro de saída dos arquivos automaticamente ou incluir novos arquivos. É necessário ativar os recursos de equipe para trabalhar com os sistemas de gerenciamento de configuração.