Estendendo Transformações C++ em UML

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:

  1. Crie um projeto de plug-in na área de trabalho do Eclipse:
    1. Clique em Arquivo > Novo > Autoria da Transformação > Projeto de Transformação Genérico; depois clique em Avançar.
  2. 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.
  3. Clique em Avançar.
  4. Na página Conteúdo do Plug-in, aceite os valores padrão e clique em Avançar.
  5. Clique em Finish. Se você for solicitado a alternar para a perspectiva Desenvolvimento de Plug-in, clique em Sim.
  6. 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.
  7. No arquivo de manifesto de plug-in, crie um elemento TransformationExtension:
    1. Na página Extensões, clique em Incluir.
    2. No assistente Nova Extensão, na página Seleção de Ponto de Extensão, clique na guia Assistentes de Extensão.
    3. Na página Assistentes de Extensão, clique em Modelos de Transformação > Extensões de Transformação; e depois clique em Avançar.
  8. 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.
  9. Clique em Avançar.
  10. Na página Nova Extensão de Transformação, defina uma regra para a extensão da transformação:
    1. Clique em Inserir.
    2. Na coluna Tipo de Elemento, na lista de elementos, selecione Regra.
    3. Nas colunas ID e Nome, especifiquecom.ibm.xtools.cpp.uml2.attributetypeextn.attrtyperule.
    4. 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.
  11. Clique em Avançar.
  12. 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
  13. 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:
    1. Na tabela "Transformações estendidas", clique em uma célula na coluna ID de Transformação de Destino.
    2. Ao lado da tabela "Adições à transformação estendida selecionada", clique em Inserir.
    3. Na coluna Tipo de Elemento, na lista, selecione Regra.
    4. 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".
  14. Clique em Avançar, e depois clique em Concluir. Se for solicitado a salvar as mudanças feitas no plug-in, clique em Sim.
  15. 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:
    1. Clique no elemento AddRule associado com a regra com.ibm.xtools.cpp.uml2.attributetypeextn.attrtyperule.
    2. Na área Detalhes do Elemento de Extensão, no campo índice digite 1. A indexação começa em 0.
  16. Clique em Arquivo > Salvar.
  17. 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
  18. Clique em Arquivo > Salvar.
  19. 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.

Feedback