Relationships between UML model elements and UML-to-C++ transformation output

Traceability options enable you to create relationships between a source model and the transformation output.

The options in the transformation configuration enable to you specify the type of relationship that the transformation generates between a model element and the transformation output. By default, the transformation does not create traceable relationships.

Trace relationships between source model elements and transformation output

To understand how the elements of a source model relate to the elements in a target project, you can have the transformation create trace relationships from the source model elements to the generated elements in the target project. You can then view the trace relationships in a topic diagram by creating and running model queries.

Creating trace relationships is useful in large projects that might contain multiple models and multiple transformation configurations. You can also create and run traceability queries that display how transformation output relates to software specifications and model elements.

When you run a transformation that is configured to generate trace relationships between the source model and transformation output, for each UML element that supports the @generated tag, the transformation If you rename elements in the source UML model, this unique identifier enables the merge functionality to refactor and merge the appropriate elements.

Note: If you move a UML element out of the scope of its top-level class, when you rerun the transformation, the merge algorithm does not refactor or merge the renamed element because the scope of the element changed.

The transformation does not alter the source model when you specify that the transformation generate trace relationships.

To view the relationships between source model elements and transformation output, you can visualize the source model element in a diagram and drag the code element that the transformation generates into that diagram. The following table lists the following things: the UML representation for a source model element named Class1, which contains an integer attribute named attribute1, and two operations named Operation1 and Operation2, which do not have any parameters; the code that the transformation generates; and the class diagram that shows the trace relationship between the elements.

UML element	Transformation output	Derived relationship in a class diagram
	#ifndef CLASS1_H #define CLASS1_H //Begin section for file Class1.h //TODO: Add definitions that you want preserved //End section for file Class1.h //@uml.annotationsderived_abstraction="platform:/resource/MyModels/UMLModel.emx#_biwQUHdCEduVaMk1fL7Qcw" //@generated "UML to C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)" class Class1 { //Begin section for Class1 //TODO: Add attributes that you want preserved //End section for Class1 private: //@generated "UML to C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)" int attribute1; public: //@generated "UML to C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)" int Operation1(); //@generated "UML to C++ (com.ibm.xtools.transform.uml2.cpp.CPPTransformation)" int Operation2(); }; //end Class Class1 #endif

UML element

Transformation output

Derived relationship in a class diagram

This image shows a UML class named Class1 that has an integer attribute and two operations that do not have any input or output parameters.

#ifndef CLASS1_H
#define CLASS1_H
//Begin section for file Class1.h
//TODO: Add definitions that you want preserved
//End section for file Class1.h

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

    //Begin section for Class1
    //TODO: Add attributes that you want preserved
    //End section for Class1

    private:

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

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

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

};  //end Class Class1

#endif

This image shows the abstraction relationship, with the derive stereotype applied, between Class1 and its visual representation.

Direct references between model elements and transformation output

You can instruct a transformation to create direct references between source model elements and transformation output. The transformation replaces source model elements with pointers to the transformation output. The source code that the transformation generates becomes the primary engineering artifact, and the elements in the model become visual representations of the code. This practice is useful if you want to work in the target domain instead of working with the UML model. The changes that you make to the visual representations of the objects in the model are immediately visible in the code.

Running a transformation that creates direct references between model elements and transformation output changes the source model. To avoid possible problems, you should place your source model under version control.

To realize the benefits of working in the target domain, you should create direct references when you make incremental changes to a UML model, and then convert the model into visual representations of code. If the transformation cannot transform UML elements, such as nested elements, it moves these elements to the nearest package. If the transformation cannot move a model element to the nearest package, it deletes the element.

To learn about creating direct references between model elements and transformation output, see the related tutorial for this topic. Although the tutorial demonstrates this concept using the UML-to-Java transformation, you can perform the same procedure using the UML-to-C++ transformation.