Quarta Etapa de Organização de Transformações

Os transformadores da FOMDA são baseados na categoria de Transformação de Manipulação Direta de modelos (TMD), definida por Czarnecki e Simon (2003). Para escrever transformadores desta categoria, o projetista de transformações precisa criar uma classe que herde de uma classe dedicada em aplicar transformações em modelos. Esta classe é disponibilizada em abordagens para MDA com foco em transformações TMD e é denominada como um transformador. Tipicamente, esta classe é abstrata e define uma operação abstrata. Esta operação deve ser sobrescrita nas classes derivadas e deve especificar o algoritmo de transformação de manipulação direta de modelos. Exemplos de ferramentas que disponibilizam classes abstratas para transformação de modelos são Jamda e UMT.

Os transformadores da FOMDA apresentam suaves modificações em relação a outras abordagens para TMD. A primeira diferença é que os transformadores da FOMDA podem

receber parâmetros, referenciados como parâmetros de transformação. Isto elimina a necessidade de efetuar uma pesquisa interna no modelo do sistema, em busca de um determinado elemento. A segunda diferença é que os transformadores podem compartilhar variáveis com outros transformadores, em tempo de execução. Por fim, a última diferença é relacionada com o FM. É possível determinar que um transformador seja executado, somente se determinada característica do FM for selecionada.

A Figura 14 apresenta parte do meta-modelo da FOMDA. Esta figura especifica os meta-dados que são usados para aplicar transformações da categoria TMD em modelos de entrada. O meta-dado denominado Transformer é uma interface e possui somente operações. Este meta-dado disponibiliza operações para especificar transformações que são: execute e

doTransformation. Toda a classe que realiza a interface Transformer é um transformador na

abordagem FOMDA.

A operação execute da interface Transformer é implementada pela classe abstrata

AbstractTransformer. Tal operação não pode ser sobrescrita pelas classes filhas porque ela

mantém a consistência na composição de transformações (assunto discutido na Seção 7.4.2). Sempre que um transformador for executado na abordagem FOMDA, a operação execute será invocada. Na classe AbstractTransformer, no final da implementação da operação execute, uma chamada para a operação abstrata doTransformation é feita. Isto implica na execução da operação doTransformation de uma classe derivada de AbstractTransformer.

A operação doTransformation precisa ser reimplementada em qualquer classe concreta que herde da classe abstrata AbstractTransformer. Os transformadores somente precisam implementar o algoritmo de transformação na operação doTransformation. O projetista de transformações, na abordagem FOMDA, define uma transformação em uma classe que herda da classe AbstractTransformer e a implementa na operação doTransformation.

Todo o transformador tem associado a si um descritor de transformação. Na terceira etapa de organização de transformações é possível combinar muitos transformadores, para que estes especifiquem novas transformações. Para tornar isto possível é necessário configurar cada transformador em um descritor de transformação. Na Figura 14, é possível visualizar as informações contidas em um descritor de transformação. Este é o meta-dado

TransformationDescriptor, em que os seguintes atributos são importantes: observer –

identifica qual é a característica do FM que contém o transformador descrito pelo descritor de transformação; name – o nome do transformador; className – identifica o nome da classe do transformador associado; result – armazena um objeto que é o resultado da execução do transformador associado; returnType – identifica o tipo do objeto resultante da execução do transformador associado.

Transformadores podem conter parâmetros de transformação. Cada parâmetro de um transformador pode armazenar um elemento do modelo do sistema. Este elemento é adicionado ao parâmetro em tempo de execução de uma transformação, pelo projetista de aplicação. Esses parâmetros podem ser utilizados no algoritmo de um transformador. Isto significa que estes podem ser utilizados em uma transformação, como, por exemplo: Um transformador ‘X’ tem um parâmetro de transformação ‘P1’. Este parâmetro pode armazenar um elemento do tipo mof.core.Class, ou seja, um elemento tipo classe pode ser inserido no parâmetro ‘P1’ do transformador ‘X’. Então, em tempo de execução, o projetista de aplicação

adiciona no parâmetro ‘P1’ uma classe de um modelo de sistema e executa o transformador ‘X’. No algoritmo de transformação do transformador ‘X’, o valor contido no parâmetro ‘P1’ pode ser recuperado e utilizado pelo algoritmo deste transformador.

Um exemplo de um transformador pode ser observado na Figura 15. Esta figura apresenta a classe denominada AddClassTransformer. Esta última é um transformador, porque herda da classe abstrata AbstractTransformer. Esta herança determina que a classe

AddClassTransformer precisa implementar a operação doTransformation (linha 7-20). O

construtor da classe AddClassTransformer recebe como parâmetro um objeto do tipo

TransformationDescriptor e, dessa maneira, pode usá-lo para buscar informações a respeito

da transformação.

Um objeto do tipo TransformationDescriptor descreve a transformação e oferece recursos úteis para o desenvolvimento do algoritmo do transformador. Estes recursos podem ser: objetos de interface gráfica, que podem ser utilizados para reportar uma mensagem ao projetista de aplicação no FOMDA Toolkit; a característica de um Modelo de Features que contém o transformador (transformadores são mapeados para características do FM); parâmetros de entrada do transformador; cláusulas que testam a seleção de características de um FM; variáveis compartilhadas do transformador, sendo possível adicionar nestas variáveis os elementos do modelo do sistema que podem ser usados por outros transformadores.

A implementação da operação doTransformation, mostrada na Figura 15 (linhas 7-20), contém o algoritmo de transformação do transformador AddClassTransformer. O algoritmo é escrito para adicionar uma nova classe em um modelo do sistema. Este modelo é recebido como parâmetro (denominado “model”) pelo transformador em questão. A linha 8 exemplifica como o projetista da transformação pode recuperar um parâmetro de transformação.

A classe AbstractTransformer contém um atributo chamado observer. Este atributo contém o descritor de transformação e pode ser utilizado para recuperar os parâmetros de transformação em um transformador. Isto é feito invocando a operação getParameter do atributo observer. Esta operação recebe como parâmetro um objeto do tipo String. Este parâmetro é o nome do parâmetro de transformação, que foi cadastrado no descritor de um transformador (isto é explicado na Seção 4.4.2). O retorno da operação getParameter é um

parâmetro de um transformador, que, no meta-modelo da FOMDA, é uma instância do meta- dado TransformationParameter (ver Figura 16).

1 public class AddClassTransformer extends AbstractTransformer{ 2

3 public AddClassTransformer(TransformationDescriptor observer){ 4 this.observer=observer;

5 } 6

7 public Object doTransformation(){

8 TransformationParameter tp = observer.getParameter(“model”); 9 mof.core.Model model = (mof.core.Model) tp.getElement(); 10

11 mof.core.Class newClass = new mof.core.Class(model); 12 newClass.setName(“TheNewClass”); 13 newClass.setVisibility(“public”); 14 newClass.setScope(“instance”); 15 newClass.setAbstract(true); 16 17 model.addElement(newClass); 18 19 return newClass; 20 } 21 }

Figura 15 - Exemplo de Transformador TMD da FOMDA

A classe TransformationDescriptor, apresentada na Figura 14, é o meta-dado que representa um descritor de transformação no meta-modelo da FOMDA. Esta classe tem uma associação com a classe AbstractTransformer. Tal associação pode conter um objeto que é um interpretador/parser (se houver). Um interpretador deve ser usado quando um transformador for especificado em linguagens para transformação de modelos. Transformadores que não são instâncias do meta-dado Transformer precisam que um interpretador (este deve ser uma instância de Transformer) converta o algoritmo do transformador para instruções válidas na FOMDA Toolkit.

As transformações da categoria TMD precisam ser executadas pelo projetista de aplicação. Quando transformando um modelo de sistema os projetistas de aplicações precisam selecionar o transformador e os elementos do modelo do sistema que eles querem transformar, adicionar os elementos selecionados para os parâmetros requeridos pelo transformador e requisitar a execução do transformador. Para o projetista de aplicações, as transformações são utilizadas como foram definidas pelo projetista de transformações e, portanto, ele não precisa ter o conhecimento de como construí-las. Ainda assim, nas transformações de terceiro nível, ele pode adaptar uma transformação, efetuando uma combinação de transformadores.

A linha 9 da Figura 15 exemplifica como recuperar um elemento do modelo do sistema. Este elemento é, em tempo de execução, adicionado pelo projetista de aplicação no parâmetro de nome “model” do transformador AddClassTransformer (linha 8). A operação

getElement, do parâmetro de transformação denominado tp, retorna um objeto do tipo Object.

Este último deve ser convertido para um tipo específico e definido na linguagem java (ou, no caso do protótipo FOMDA Toolkit, num tipo de dado do MOF). A linha 9 mostra a conversão do elemento contido no parâmetro tp para o tipo “mof.core.Model”.

Para especificar transformações na abordagem FOMDA, é preciso conhecer os meta- dados do MOF. Alguns dos meta-dados do MOF são definidos no protótipo FOMDA Toolkit. Neste protótipo, esses meta-dados são classes e interfaces codificadas em Java e podem ser utilizados nos algoritmos de transformação escritos nos transformadores. Os elementos do modelo do sistema são instâncias destas classes.

Da linha 11 até a 15 do algoritmo da Figura 15, uma classe é criada e adicionada no modelo do sistema. Na linha 11, um objeto (newClass) do tipo “mof.core.Class” é instanciado. Na linha 12, é especificado o nome dessa classe como “TheNewClass”. Na linha 13, é especificada a visibilidade pública para o elemento criado. Na linha 14, o escopo desse elemento é definido como de instância. Por fim, na linha 15, a classe criada é definida como abstrata.

As linhas 17 e 19 (Figura 15) finalizam o algoritmo da operação doTransformation. A operação addElement é definida para qualquer elemento do MOF. Ela pode ser usada para adicionar elementos em um elemento do modelo. A linha 17 demonstra como adicionar um elemento, que foi criado no algoritmo, em um outro elemento do mesmo modelo. A linha 19 mostra o retorno do objeto denominado model, pela operação doTransformation. O valor retornado pelo transformador pode ser utilizado por outros, no que é chamado de terceira etapa de organização de transformações (apresentada na seção seguinte).