Para customizar como a transformação transforma elementos C++ em elementos UML correspondentes, é
possível estender a transformação C++ em UML e a transformação que ela contém.
Antes de Iniciar
O procedimento a seguir
presume que você saiba como criar, testar e distribuir plug-ins e que
esteja familiarizado com o Eclipse Plug-in Development Environment (PDE).
Por Que e Quando Desempenhar Esta Tarefa
O exemplo nesse tópico explica como estender a transformação C++ em UML para customizar a
transformação de atributos C++ em classes C++ em atributos UML. Para obter informações sobre as conversões
que transformam outros elementos C++ em UML, consulte os tópicos de referência relacionados abaixo.
Para
estender a transformação de C++ em UML:
- Crie um projeto de plug-in na área de trabalho do Eclipse:
- Clique em ; depois
clique em Avançar.
- Na página Projeto de Plug-in, no campo Nome do projeto, especifique um nome de
projeto. Para esse exemplo, especifique
com.ibm.xtools.cpp.uml2.attributetypeextn.transformation.Extension.
- Clique em Avançar.
- Na página Conteúdo do Plug-in, aceite os valores padrão e clique em Avançar.
- Clique em Finish. Se você for solicitado a alternar
para a perspectiva Desenvolvimento de Plug-in, clique em Sim.
- Na visualização de navegação, no projeto de plug-in criado
na etapa 1, na pasta META-INF,
dê um clique duplo em MANIFEST.MF.
- No arquivo de manifesto de plug-in, crie um elemento TransformationExtension:
- Na página Extensões, clique em Incluir.
- No assistente Nova Extensão, na página Seleção de Ponto de Extensão, clique na guia
Assistentes de Extensão.
- Na página Assistentes de Extensão, clique em ; e depois clique em
Avançar.
- Na página Nova Extensão de Transformação, conclua as seguintes etapas:
- No campo ID, especifique um valor exclusivo que
identifique a extensão de transformação para o serviço de transformação. Esse campo normalmente é preenchido
com o nome do projeto e com um sufixo transformationExtension. Para esse exemplo, verifique se esse campo
contém o
valorcom.ibm.xtools.cpp.uml2.attributetypeextn.transformation.Extension.transformationExtension.
- No campo Nome, especifique um nome para a extensão
de transformação. Para esse exemplo, especifique Minha Extensão de Atributo de
Transformação.
- No campo ID de transformação de destino, especifique
com.ibm.xtools.transform.cpp.uml2.transformation.
Nota: Para obter
informações adicionais sobre os outros campos desta página e de páginas restantes
no assistente, consulte a ajuda contextual pressionando F1 quando
essa página for exibida no produto. Se estiver usando a plataforma
Linux®, pressione Shift+F1.
- Clique em Avançar.
- Na página Nova Extensão de Transformação, defina uma regra para a extensão da transformação:
- Clique em Inserir.
- Na coluna Tipo de Elemento, na lista de elementos, selecione Regra.
- Nas colunas ID e Nome,
especifiquecom.ibm.xtools.cpp.uml2.attributetypeextn.attrtyperule.
- Na coluna Classe, especifique attrtyperule.
Essa ação somente declara a regra; ela não a inclui em nenhuma das conversões que você estendeu.
- Clique em Avançar.
- Na próxima página Nova Extensão de Transformação, na tabela "Transformações estendidas", especifique as
transformações a estender. As transformações na lista a seguir transformam atributos C++ e atributos de
interface em elementos UML correspondentes. Para cada uma dessas transformações, ao lado da tabela
"Transformações estendidas", clique em Inserir, e especifique o nome da transformação
na coluna ID de Transformação de Destino:
- com.ibm.xtools.transform.cpp.uml2.CPPProjectMemberTransform.CPPFolderMemberTransform.CPPNamespaceMemberTransform.CPPClassStructUnionMemberTransform.CPPMemberVariableTransform
- com.ibm.xtools.transform.cpp.uml2.CPPProjectMemberTransform.CPPSourceMemberTransform.CPPNamespaceMemberTransform.CPPClassStructUnionMemberTransform.CPPMemberVariableTransform
- com.ibm.xtools.transform.cpp.uml2.CPPProjectMemberTransform.CPPSourceMemberTransform.CPPClassStructMemberTransform.CPPMemberVariableTransform
- Especifique que cada transformação estendida deve implementar a regra que você declarou na etapa
10.
Para cada transformação especificada na tabela "Transformações estendidas", conclua as seguintes etapas:
- Na tabela "Transformações estendidas", clique em uma célula na coluna ID de Transformação de Destino.
- Ao lado da tabela "Adições à transformação estendida selecionada", clique em
Inserir.
- Na coluna Tipo de Elemento, na lista, selecione Regra.
- Na coluna ID, especifique o ID da classe contida na regra que você declarou em
10.
Para esse exemplo, especifiquecom.ibm.xtools.cpp.uml2.attributetypeextn.attrtyperule.
Ao clicar em uma célula na coluna ID da Transformação de Destino da tabela "Transformações
estendidas", a tabela "Adições à transformação estendida selecionada" exibe os elementos associados com essa
transformação. Para esse exemplo, a regra attrtyperule está associada com cada transformação na tabela
"Transformações estendidas".
- Clique em Avançar, e depois clique em Concluir.
Se for solicitado a salvar as mudanças feitas no plug-in, clique em Sim.
- Para cada transformação, especifique se a regra attrtyperule executa como uma segunda regra em cada uma
das transformações estendidas: no editor de manifesto de plug-in, na página Extensões, na seção Todas as
Extensões, para cada elemento ExtendTransform, conclua as seguintes etapas:
- Clique no elemento AddRule associado com a regra com.ibm.xtools.cpp.uml2.attributetypeextn.attrtyperule.
- Na área Detalhes do Elemento de Extensão, no campo índice digite
1. A indexação começa em 0.
- Clique em .
- Na página Dependências, na seção Plug-ins Necessários, se eles ainda não existirem, inclua os seguintes
plug-ins:
- org.eclipse.uml2.uml
- com.ibm.xtools.cpp.model
- com.ibm.xtools.transform.core
- com.ibm.xtools.transform.cpp.uml2
- Clique em .
- Defina a implementação Java™ da regra attrtype que uma
transformação na transformação de C++ em UML invoque ao encontrar um atributo C++ na origem da transformação.
Nesse exemplo, a classe de implementação está localizada em um projeto diferente da extensão da
transformação. O fragmento de código a seguir mostra uma possível implementação:
/*
*+------------------------------------------------------------------------+
*| Materiais Licenciados - Propriedade da IBM |
*| (C) Copyright IBM Corp. 2004. Todos os Direitos Reservados. |
*| |
*| Direitos Restritos para Usuários do Governo dos Estados Unidos - Uso, duplicação e divulgação |
*| restritos pelo GSA ADP Schedule Contract com a IBM Corp. |
*+------------------------------------------------------------------------+
*/
package com.ibm.xtools.cpp.uml2.attributetypeextn;
import org.eclipse.uml2.uml.Classifier;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.Package;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.Type;
import com.ibm.xtools.cpp.model.CPPOwnedAttribute;
import com.ibm.xtools.transform.core.AbstractRule;
import com.ibm.xtools.transform.core.ITransformContext;
import com.ibm.xtools.transform.cpp.uml2.internal.CPPModelToUML.util.CPPModelToUMLUtil;
/**
* attrtyperule está registrado em plugin.xml como uma RuleDefinition.
*/
/*
* (não-Javadoc)
*
* @see com.ibm.xtools.transform.core.AbstractRule
*/
public class attrtyperule extends AbstractRule {
/*
* (não-Javadoc)
*
* @see
com.ibm.xtools.transform.core.AbstractRule#createTarget(com.ibm.xtools.transform.core.ITransformContext)
*/
public static final String UML_TYPE_STRING = "String";
public Object createTarget(ITransformContext ruleContext) {
// TAREFA A FAZER Stub de método gerado automaticamente
Object source = ruleContext.getSource();
if (source instanceof CPPOwnedAttribute) {
CPPOwnedAttribute attribute = (CPPOwnedAttribute) source;
Classifier klass = (Classifier) ruleContext.getTargetContainer();
NamedElement umlElement = null;
if(klass instanceof org.eclipse.uml2.uml.Class){
umlElement = ((org.eclipse.uml2.uml.Class)klass).getOwnedMember(attribute.getName());
}
Property umlProperty = (Property) umlElement;
if(attribute.getQualifierString().contains("*")
&&(umlProperty.getType().getName().equalsIgnoreCase("char")) ){
setStringType(umlProperty);
}
return umlElement;
}
return null;
}
public static Type setStringType( Property umlProperty ){
Package rootElement = CPPModelToUMLUtil.getRootElement(umlProperty);
Type umlString = (Type) rootElement.getImportedMember(UML_TYPE_STRING);
umlProperty.setType(umlString);
return null;
}
}
Resultados
Na próxima vez que a transformação de C++ para UML for executada, ela transformará os atributos
conforme especificado no fragmento de código anterior.