< Indietro | Avanti >

Lezione 6: Creazione e perfezionamento della dichiarazione di associazione package-a-package

Questa lezione spiega come creare una dichiarazione di associazione package-a-package e più regole di associazione. Le regole di associazione specificano come il trasformatore generato elabora i package nidificati o gli elementi della classe nel package contenuto dal modello di origine.

Gli oggetti di input e di output del package contengono una funzione chiamata packagedElement. Questa funzione è una raccolta che contiene diversi tipi di oggetti UML validi. Le regole di associazione create in questa lezione definiscono come la trasformazione elabora gli elementi della raccolta di tipo package o classe.

In questa lezione, vengono create le seguenti regole di associazione:
  • Una regola di associazione di spostamento che crea un package nel progetto di destinazione; questo package avrà lo stesso nome del package nel modello di origine
  • Una regola di associazione secondaria che richiama il trasformatore Class2ClassTransform se l'elemento è di tipo classe
  • Una regola di associazione secondaria che richiama il trasformatore Class2InterfaceTransform se l'elemento è di tipo classe
  • Una regola di associazione secondaria che richiama il trasformatore Package2PackageTransform se l'elemento è di tipo package

Nella Lezione 3: Creazione e perfezionamento della dichiarazione di associazione classe-a-classe si è spiegato che per ciascuna regola di associazione di spostamento in una dichiarazione di associazione, viene aggiunta una regola che copia il valore di un attributo dal modello di origine al modello di associazione al codice sorgente del trasformatore generato. Per ciascuna regola di associazione secondaria, nel codice sorgente del trasformatore viene generato un estrattore che estrae gli elementi dalla raccolta specificata. La regola di associazione secondaria viene applicata ad un oggetto se l'oggetto di input corrente è un'istanza del tipo di input definito nella dichiarazione di associazione.

Quando si esegue la trasformazione generata, se il modello di origine contiene un package, viene richiamato il trasformatore Package2PackageTransform che crea un package con lo stesso nome nel modello di destinazione. Il trasformatore Package2PackageTransform attraversa la raccolta della funzione packagedElement. Per ciascun elemento della raccolta di tipo package, che indica che il modello di origine contiene package nidificati, il trasformatore richiama il trasformatore Package2PackageTransform. Per ciascun elemento nella raccolta di tipo classe, il trasformatore richiama le regole per trasformare la classe in una classe e interfaccia corrispondenti nel modello di output di destinazione.

Per creare una dichiarazione di associazione package-a-package nel modello di associazione:

  1. Se il file Generalize_Classes.mapping non è aperto nell'editor di associazione trasformazioni, nella vista Esplora package, fare doppio clic sul file.
  2. Nell'editor di associazione trasformazioni, nella sezione Root di associazione, fare clic con il tasto destro del mouse su Generalizza_Classi; quindi fare clic su Crea associazione.
  3. Nella finestra Nuova associazione, nel campo Nome associazione, immettere Package2Package e fare clic su OK. L'associazione viene visualizzata nella vista Struttura e viene aperta nell'area editor nella sezione Root di associazione.

Aggiunta di oggetti di input e di output alla dichiarazione di associazione package-a-package

Dopo aver creato la dichiarazione di associazione, è necessario aggiungervi un oggetto di input e un oggetto di output. In questa lezione, viene specificato un package UML come oggetto di input e di output.

Per aggiungere un oggetto di input e un oggetto di output alla dichiarazione di associazione package-a-package:

  1. Fare clic sull'icona Aggiungi un oggetto di input, l'icona più a sinistra sulla barra degli strumenti che si sta modificando.
  2. Nella finestra Aggiunta input, nel riquadro Elemento, espandere uml, fare clic su Package, quindi su OK.
  3. Fare clic sull'icona Aggiungi un oggetto di output, la seconda icona da sinistra nella barra degli strumenti dell'associazione che si sta modificando.
  4. Nella finestra Aggiunta output, nel riquadro Elemento, espandere uml, fare clic su Package, quindi su OK.
  5. Fare clic su File > Salva.
È adesso possibile definire le regole di associazione tra le funzioni degli oggetti di input e di output.

Definizione delle regole di associazione tra gli attributi degli oggetti di input e di output del package

Dopo aver aggiunto gli oggetti di input e di output del package alla dichiarazione di associazione, sarà possibile creare le regole di associazione tra gli attributi degli oggetti di input e di output.
Nota: Quando si genera il codice sorgente della trasformazione, viene generato un trasformatore per ciascuna dichiarazione di associazione. Ciascun trasformatore generato contiene un metodo getAccept_Condition(). Per impostazione predefinita, questo metodo restituisce true se l'elemento corrente è un'istanza dell'oggetto di input definito nella dichiarazione di associazione. Se il metodo restituisce false, il trasformatore non elabora l'elemento di input corrente. In questa lezione, è possibile creare filtri di input che verificano inoltre, se l'oggetto di input è un'istanza del tipo di input. Anche se questi filtri di input sono ridondanti, non causano alcun problema, e dimostrano solo come creare filtri di input. I filtri di input nelle regole di associazione secondarie devono essere scritti in Java e restituire un valore booleano.

Per creare le regole di associazione tra gli attributi degli oggetti di input e di output del package:

  1. Creare una regola di associazione di spostamento tra gli attributi name trascinando la maniglia dell'attributo name dell'oggetto di input sull'attributo name nell'oggetto di output.
  2. Creare una regola di associazione secondaria tra l'attributo packagedElement dell'oggetto di input e di output e specificare che questa associazione secondaria richiama il trasformatore Class2ClassTransform se l'elemento è di tipo classe:
    1. Trascinare la maniglia dell'attributo packagedElement dell'oggetti di input sull'attributo packagedElement nell'oggetto di output. Poiché l'attributo packagedElement è una raccolta, per impostazione predefinita, l'editor di associazione crea una regola di associazione secondaria.
    2. Nell'area editor, fare clic con il tasto destro del mouse sull'elemento Associazione secondaria, quindi fare clic su Mostra in proprietà.
    3. Nella vista Proprietà, nella scheda Dettagli, nell'elenco Associazione, selezionare Class2Class.
    Quando si esegue la trasformazione generata, per ciascun elemento nel package di input, la trasformazione richiama il trasformatore Class2ClassTransform, ma solo se l'elemento è di tipo classe.
  3. Opzionale: Nella regola di associazione secondaria creata al punto 2, creare un filtro di input che verifica se l'oggetto corrente è un'istanza della classe:
    1. Nell'area editor, fare clic con il tasto destro del mouse sull'elemento Associazione secondaria creato al punto 2.
    2. Nella vista Proprietà, nella scheda Filtro di input, selezionare la casella di spunta Filtra elementi di input.
    3. Fare clic su Seriale.
    4. Nell'area di testo sotto al campo Codice, al di sotto della firma del metodo, specificare il seguente codice: return packagedElement_src instanceof org.eclipse.uml2.uml.Class;
    5. Fare clic su Applica.
  4. Creare una regola di associazione secondaria tra la funzione packagedElement dell'oggetto di input e di output e specificare che se l'elemento corrente nella raccolta packagedElement è di tipo classe, il trasformatore Package2PackageTransform trasformerà la classe in un'interfaccia nel modello di destinazione.
    1. Ripetere il punto 2a per creare un'altra associazione secondaria tra le funzioni packagedElement.
    2. Nell'area editor, fare clic con il tasto destro del mouse sull'elemento Associazione secondaria, quindi fare clic su Mostra in proprietà.
    3. Nella vista Proprietà, nella scheda Dettagli, nell'elenco Associazione, selezionare Class2Interface.
  5. Opzionale: Nella regola di associazione secondaria creata al punto 4, creare un filtro di input che verifica se l'oggetto corrente è un'istanza di un'interfaccia:
    1. Nell'area editor, fare clic con il tasto destro del mouse sull'elemento Associazione secondaria creato al punto 4; quindi fare clic su Mostra in proprietà.
    2. Ripetere i punti 3b, 3c, 3d, e 3e per specificare lo stesso filtro di input.
  6. Creare una regola di associazione secondaria che elabora i package nidificati. Se l'elemento corrente nella raccolta packagedElement è un package, la trasformazione richiama il trasformatore Package2PackageTransform.
    1. Ripetere il punto 2a per creare un'altra associazione secondaria tra le funzioni packagedElement.
    2. Nell'area editor, fare clic con il tasto destro del mouse sull'elemento Associazione secondaria, quindi fare clic su Mostra in proprietà.
    3. Nella vista Proprietà, nella scheda Dettagli, nell'elenco Associazione, selezionare Package2Package.
  7. Opzionale: Nella regola di associazione secondaria creata al punto 6, creare un filtro di input che verifica se l'elemento di input corrente è un'istanza di un package:
    1. Nell'area editor, fare clic con il tasto destro del mouse sull'elemento Associazione secondaria creato al punto 6; quindi fare clic su Mostra in proprietà.
    2. Ripetere i punti 3b e 3c per specificare che questa regola ha un filtro di input.
    3. Nell'area di testo sotto al campo Codice, al di sotto della firma del metodo, specificare il seguente codice: return packagedElement_src instanceof org.eclipse.uml2.uml.Package;
    4. Fare clic su Applica.
  8. Fare clic su File > Salva.
La dichiarazione di associazione contiene adesso una regola di associazione di spostamento tra gli attributi name e più regole di associazione secondaria tra gli attributi packagedElement.
< Indietro | Avanti >

Feedback