- •Table of Contents
- •Mastering UML with Rational Rose 2002
- •Chapter 1: Introduction to UML
- •Encapsulation
- •Inheritance
- •Polymorphism
- •What Is Visual Modeling?
- •Systems of Graphical Notation
- •Booch Notation
- •Object Management Technology (OMT)
- •Unified Modeling Language (UML)
- •Understanding UML Diagrams
- •Business Use Case Diagrams
- •Use Case Diagrams
- •Activity Diagrams
- •Sequence Diagrams
- •Collaboration Diagrams
- •Class Diagrams
- •Statechart Diagrams
- •Component Diagrams
- •Deployment Diagrams
- •Visual Modeling and the Software Development Process
- •Inception
- •Elaboration
- •Construction
- •Transition
- •Summary
- •Chapter 2: A Tour of Rose
- •What Is Rose?
- •Getting Around in Rose
- •Parts of the Screen
- •Exploring Four Views in a Rose Model
- •Use Case View
- •Logical View
- •Component View
- •Deployment View
- •Working with Rose
- •Creating Models
- •Saving Models
- •Exporting and Importing Models
- •Publishing Models to the Web
- •Working with Controlled Units
- •Using the Model Integrator
- •Working with Notes
- •Working with Packages
- •Adding Files and URLs to Rose Model Elements
- •Adding and Deleting Diagrams
- •Setting Global Options
- •Working with Fonts
- •Working with Colors
- •Summary
- •Chapter 3: Business Modeling
- •Introduction to Business Modeling
- •Why Model the Business?
- •Do I Need to Do Business Modeling?
- •Business Modeling in an Iterative Process
- •Business Actors
- •Business Workers
- •Business Use Cases
- •Business Use Case Diagrams
- •Activity Diagrams
- •Business Entities
- •Organization Unit
- •Where Do I Start?
- •Identifying the Business Actors
- •Identifying the Business Workers
- •Identifying the Business Use Cases
- •Showing the Interactions
- •Documenting the Details
- •Creating Business Use Case Diagrams
- •Deleting Business Use Case Diagrams
- •The Use Case Diagram Toolbar
- •Adding Business Use Cases
- •Business Use Case Specifications
- •Assigning a Priority to a Business Use Case
- •Viewing Diagrams for a Business Use Case
- •Viewing Relationships for a Business Use Case
- •Working with Business Actors
- •Adding Business Actors
- •Adding Actor Specifications
- •Assigning an Actor Stereotype
- •Setting Business Actor Multiplicity
- •Viewing Relationships for a Business Actor
- •Working with Relationships
- •Association Relationship
- •Generalization Relationship
- •Working with Organization Units
- •Adding Organization Units
- •Deleting Organization Units
- •Activity Diagrams
- •Adding an Activity Diagram
- •Adding Details to an Activity Diagram
- •Summary
- •Chapter 4: Use Cases and Actors
- •Use Case Modeling Concepts
- •Actors
- •Use Cases
- •Traceability
- •Flow of Events
- •Relationships
- •Use Case Diagrams
- •Activity Diagrams
- •Activity
- •Start and End States
- •Objects and Object Flows
- •Transitions
- •Synchronization
- •Working with Use Cases in Rational Rose
- •The Use Case Diagram Toolbar
- •Creating Use Case Diagrams
- •Deleting Use Case Diagrams
- •Adding Use Cases
- •Deleting Use Cases
- •Use Case Specifications
- •Naming a Use Case
- •Viewing Participants of a Use Case
- •Assigning a Use Case Stereotype
- •Assigning a Priority to a Use Case
- •Creating an Abstract Use Case
- •Viewing Diagrams for a Use Case
- •Viewing Relationships for a Use Case
- •Working with Actors
- •Adding Actors
- •Deleting Actors
- •Actor Specifications
- •Naming Actors
- •Assigning an Actor Stereotype
- •Setting Actor Multiplicity
- •Creating an Abstract Actor
- •Viewing Relationships for an Actor
- •Viewing an Actor's Instances
- •Working with Relationships
- •Association Relationship
- •Includes Relationship
- •Extends Relationship
- •Generalization Relationship
- •Working with Activity Diagrams
- •The Activity Diagram Toolbar
- •Creating Activity Diagrams
- •Deleting Activity Diagrams
- •Exercise
- •Problem Statement
- •Create a Use Case Diagram
- •Summary
- •Chapter 5: Object Interaction
- •Interaction Diagrams
- •What Is an Object?
- •What Is a Class?
- •Where Do I Start?
- •Finding Objects
- •Finding the Actor
- •Using Interaction Diagrams
- •Sequence Diagrams
- •The Sequence Diagram Toolbar
- •Collaboration Diagrams
- •The Collaboration Diagram Toolbar
- •Working with Actors on an Interaction Diagram
- •Working with Objects
- •Adding Objects to an Interaction Diagram
- •Deleting Objects from an Interaction Diagram
- •Setting Object Specifications
- •Naming an Object
- •Mapping an Object to a Class
- •Setting Object Persistence
- •Using Multiple Instances of an Object
- •Working with Messages
- •Adding Messages to an Interaction Diagram
- •Adding Messages to a Sequence Diagram
- •Deleting Messages from a Sequence Diagram
- •Reordering Messages in a Sequence Diagram
- •Message Numbering in a Sequence Diagram
- •Viewing the Focus of Control in a Sequence Diagram
- •Adding Messages to a Collaboration Diagram
- •Deleting Messages from a Collaboration Diagram
- •Message Numbering in a Collaboration Diagram
- •Adding Data Flows to a Collaboration Diagram
- •Setting Message Specifications
- •Naming a Message
- •Mapping a Message to an Operation
- •Setting Message Synchronization Options
- •Setting Message Frequency
- •End of a Lifeline
- •Working with Scripts
- •Switching Between Sequence and Collaboration Diagrams
- •Exercise
- •Problem Statement
- •Create Interaction Diagrams
- •Summary
- •Chapter 6: Classes and Packages
- •Logical View of a Rose Model
- •Class Diagrams
- •What Is a Class?
- •Finding Classes
- •Creating Class Diagrams
- •Deleting Class Diagrams
- •Organizing Items on a Class Diagram
- •Using the Class Diagram Toolbar
- •Working with Classes
- •Adding Classes
- •Class Stereotypes
- •Analysis Stereotypes
- •Class Types
- •Interfaces
- •Web Modeling Stereotypes
- •Other Language Stereotypes
- •Class Specifications
- •Naming a Class
- •Setting Class Visibility
- •Setting Class Multiplicity
- •Setting Storage Requirements for a Class
- •Setting Class Persistence
- •Setting Class Concurrency
- •Creating an Abstract Class
- •Viewing Class Attributes
- •Viewing Class Operations
- •Viewing Class Relationships
- •Using Nested Classes
- •Viewing the Interaction Diagrams That Contain a Class
- •Setting Java Class Specifications
- •Setting CORBA Class Specifications
- •Working with Packages
- •Adding Packages
- •Deleting Packages
- •Exercise
- •Problem Statement
- •Creating a Class Diagram
- •Summary
- •Chapter 7: Attributes and Operations
- •Working with Attributes
- •Finding Attributes
- •Adding Attributes
- •Deleting Attributes
- •Setting Attribute Specifications
- •Setting the Attribute Containment
- •Making an Attribute Static
- •Specifying a Derived Attribute
- •Working with Operations
- •Finding Operations
- •Adding Operations
- •Deleting Operations
- •Setting Operation Specifications
- •Adding Arguments to an Operation
- •Specifying the Operation Protocol
- •Specifying the Operation Qualifications
- •Specifying the Operation Exceptions
- •Specifying the Operation Size
- •Specifying the Operation Time
- •Specifying the Operation Concurrency
- •Specifying the Operation Preconditions
- •Specifying the Operation Postconditions
- •Specifying the Operation Semantics
- •Displaying Attributes and Operations on Class Diagrams
- •Showing Attributes
- •Showing Operations
- •Showing Visibility
- •Showing Stereotypes
- •Mapping Operations to Messages
- •Mapping an Operation to a Message on an Interaction Diagram
- •Exercise
- •Problem Statement
- •Add Attributes and Operations
- •Summary
- •Chapter 8: Relationships
- •Relationships
- •Types of Relationships
- •Finding Relationships
- •Associations
- •Using Web Association Stereotypes
- •Creating Associations
- •Deleting Associations
- •Dependencies
- •Creating Dependencies
- •Deleting Dependencies
- •Package Dependencies
- •Creating Package Dependencies
- •Deleting Package Dependencies
- •Aggregations
- •Creating Aggregations
- •Deleting Aggregations
- •Generalizations
- •Creating Generalizations
- •Deleting Generalizations
- •Working with Relationships
- •Setting Multiplicity
- •Using Relationship Names
- •Using Stereotypes
- •Using Roles
- •Setting Export Control
- •Using Static Relationships
- •Using Friend Relationships
- •Setting Containment
- •Using Qualifiers
- •Using Link Elements
- •Using Constraints
- •Exercise
- •Problem Statement
- •Adding Relationships
- •Summary
- •Chapter 9: Object Behavior
- •Statechart Diagrams
- •Creating a Statechart Diagram
- •Adding States
- •Adding State Details
- •Adding Transitions
- •Adding Transition Details
- •Adding Special States
- •Using Nested States and State History
- •Exercise
- •Problem Statement
- •Create a Statechart Diagram
- •Summary
- •Chapter 10: Component View
- •What Is a Component?
- •Types of Components
- •Component Diagrams
- •Creating Component Diagrams
- •Adding Components
- •Adding Component Details
- •Adding Component Dependencies
- •Exercise
- •Problem Statement
- •Summary
- •Chapter 11: Deployment View
- •Deployment Diagrams
- •Opening the Deployment Diagram
- •Adding Processors
- •Adding Processor Details
- •Adding Devices
- •Adding Device Details
- •Adding Connections
- •Adding Connection Details
- •Adding Processes
- •Exercise
- •Problem Statement
- •Create Deployment Diagram
- •Summary
- •Chapter 12: Introduction to Code Generation and Reverse Engineering Using Rational Rose
- •Preparing for Code Generation
- •Step One: Check the Model
- •Step Two: Create Components
- •Step Three: Map Classes to Components
- •Step Five: Select a Class, Component, or Package
- •Step Six: Generate Code
- •What Gets Generated?
- •Introduction to Reverse Engineering Using Rational Rose
- •Model Elements Created During Reverse Engineering
- •Summary
- •Chapter 13: ANSI C++ and Visual C++ Code Generation and Reverse Engineering
- •Generating Code in ANSI C++ and Visual C++
- •Converting a C++ Model to an ANSI C++ Model
- •Class Properties
- •Attribute Properties
- •Operation Properties
- •Package (Class Category) Properties
- •Component (Module Specification) Properties
- •Role Properties
- •Generalization Properties
- •Class Model Assistant
- •Component Properties
- •Project Properties
- •Visual C++ and ATL Objects
- •Generated Code
- •Code Generated for Classes
- •Code Generated for Attributes
- •Code Generated for Operations
- •Visual C++ Code Generation
- •Reverse Engineering ANSI C++
- •Reverse Engineering Visual C++
- •Summary
- •Overview
- •Introduction to Rose J
- •Beginning a Java Project
- •Selecting a Java Framework
- •Linking to IBM VisualAge for Java
- •Linking to Microsoft Visual J++
- •Project Properties
- •Class Properties
- •Attribute Properties
- •Operation Properties
- •Module Properties
- •Role Properties
- •Generating Code
- •Generated Code
- •Classes
- •Attributes
- •Operations
- •Bidirectional Associations
- •Unidirectional Associations
- •Associations with a Multiplicity of One to Many
- •Associations with a Multiplicity of Many to Many
- •Reflexive Associations
- •Aggregations
- •Dependency Relationships
- •Generalization Relationships
- •Interfaces
- •Java Beans
- •Support for J2EE
- •EJBs
- •Servlets
- •JAR and WAR Files
- •Automated J2EE Deployment
- •Reverse Engineering
- •Summary
- •Starting a Visual Basic Project
- •Class Properties
- •Attribute Properties
- •Operation Properties
- •Module Specification Properties
- •Role Properties
- •Generalization Properties
- •Generated Code
- •Classes
- •Attributes
- •Operations
- •Bidirectional Associations
- •Unidirectional Associations
- •Associations with a Multiplicity of One to Many
- •Associations with a Multiplicity of Many to Many
- •Reflexive Associations
- •Aggregations
- •Dependency Relationships
- •Generalization Relationships
- •Reverse Engineering
- •Summary
- •Overview
- •Introduction to XML DTD
- •Elements
- •Attributes
- •Entities and Notations
- •Project Properties
- •Class Properties
- •Attribute Properties
- •Role Properties
- •Component Properties
- •Generating Code
- •Generated Code
- •Classes
- •Attributes
- •Reverse Engineering DTD
- •Summary
- •Project Properties
- •Class Properties
- •Attribute Properties
- •Operation Properties
- •Module Properties
- •Association (Role) Properties
- •Dependency Properties
- •Generated Code
- •Classes
- •Attributes
- •Operations
- •Bidirectional Associations
- •Unidirectional Associations
- •Associations with a Multiplicity of One to Many
- •Associations with a Multiplicity of Many to Many
- •Associations with Bounded Multiplicity
- •Reflexive Associations
- •Aggregations
- •Dependency Relationships
- •Generalization Relationships
- •Reverse Engineering CORBA Source Code
- •Summary
- •Chapter 18: Rose Data Modeler
- •Object Models and Data Models
- •Creating a Data Model
- •Logic in a Data Model
- •Adding a Database
- •Adding Tablespaces
- •Adding a Schema
- •Creating a Data Model Diagram
- •Creating Domain Packages and Domains
- •Adding Tables
- •Adding Columns
- •Setting a Primary Key
- •Adding Constraints
- •Adding Triggers
- •Adding Indexes
- •Adding Stored Procedures
- •Adding Relationships
- •Adding Referential Integrity Rules
- •Working with Views
- •Generating an Object Model from a Data Model
- •Generating a Data Model from an Object Model
- •Generating a Database from a Data Model
- •Updating an Existing Database
- •Reverse Engineering a Database
- •Summary
- •Chapter 19: Web Modeling
- •Modeling a Web Application
- •Web Class Stereotypes
- •Relationships
- •Reverse Engineering a Web Application
- •Generating Code for a Web Application
- •Summary
- •Appendix: Getting Started with UML
- •Building a Business Use Case Diagram
- •Building a Workflow (Activity) Diagram
- •Building a Use Case Diagram
- •Building an Interaction Diagram
- •Building a Class Diagram
- •Web Modeling
- •Adding Class Relationships
- •Building a Statechart Diagram
- •Building a Component Diagram
- •Building a Deployment Diagram
Chapter 13: ANSI C++ and Visual C++ Code Generation and Reverse Engineering
C++ is one of the most widely used object−oriented languages in the industry. Rational Rose supports integration with C++ through its code−generation and reverse−engineering capabilities. In this chapter, we'll discuss how to generate C++ code from your Rational Rose model and how to reverse engineer C++ code into a Rose model.
There are three versions of C++ integration with Rational Rose. First is the C++ add−in that has been available in Rose since October 1994. It contains a great deal of functionality, but can prove difficult to use. The second is an add−in for Microsoft's Visual C++. This add−in is simpler to use, but will integrate only with Microsoft's Visual C++. Rational, therefore, has introduced the third add−in, ANSI C++, which is an easy−to−use C++ code−generation and reverse−engineering tool that will work with C++ tools other than Microsoft's Visual C++.
In this chapter, we will discuss the ANSI C++ and Visual C++ add−ins. The original C++ add−in is still supported, but will not be covered here. We'll discuss the code−generation properties that can be set, and take a close look at how each Rose model element is implemented in the code.
∙
Setting C++ code−generation properties
∙
Mapping Rose elements to C++ constructs
∙
Generating C++ code from your Rose model
∙
Reverse engineering C++ code into your Rose model
Generating Code in ANSI C++ and Visual C++
You will need to follow these steps to generate code in ANSI C++:
1.
|
Create components (see Chapter 10, "Component View"). |
2. |
|
|
Assign classes to components (see Chapter 10). |
3. |
|
|
Set the code−generation properties. |
4. |
|
|
Select a class or component to generate on a Class or Component diagram. |
5. |
Select Tools → ANSI C++ → Generate Code. |
|
|
6. |
417 |
Chapter 13: ANSI C++ and Visual C++ Code Generation and Reverse Engineering
Select Tools → ANSI C++ → Browse Header or Browse Body to view the generated code.
The first step in code generation is to create components for the classes. In ANSI C++, the file is located in the class file. The component has only the Root directory. Once components have been created and the classes mapped, the next step is to set the code−generation properties for your classes, components, operations, and other model elements. The code−generation properties control certain aspects of the code that is generated.
If you are generating code in Visual C++, you will use a wizard. To start the wizard, select Tools → Visual C++ → Update Code. The Visual C++ Code Update tool will start, and a welcome screen will be displayed. Click Next to continue. Rose will display the Select Components and Classes window. Before you can generate a class in Visual C++, the class must be assigned to a component. If you have not assigned the class to a component, select the Create a VC++ Component and Assign New Classes to It (Ctrl+R) option in the wizard window. Using this option, you can create as many components as you need before you generate the code. Then select the components and/or classes in your model for which you wish to generate code.
To change the code−generation properties for your Visual C++ components and classes, right−click the VC++ folder on this screen. You can then edit any of the code−generation properties, such as the container class, to support relationship multiplicity, to automatically generate a constructor and destructor, and to automatically generate Get and Set operations or other member functions. The code−generation properties are discussed in greater detail in the upcoming section, "Visual C++ Code−Generation Properties."
Once all classes have been assigned to components, you have selected the classes and/or components you wish to generate, and all code−generation properties have been set, click Next to continue. A summary page will be displayed to let you know which classes or components were generated and which errors were encountered during the code−generation process.
Rose will use a lot of information from the model to generate code. For example, it will look at the multiplicity, role names, containment, and other details of each relationship. It will look at the attributes, operations, visibility, and other details of each class. From all of the information you entered using the specification windows for the various model elements, Rose will gather what it needs to generate code.
Converting a C++ Model to an ANSI C++ Model
Previous versions of Rose contained a C++ add−in, but not an ANSI C++ add−in. As we discussed earlier, the ANSI C++ add−in is a more user−friendly version of the C++ code−generation and reverse−engineering tool. Although you can continue to use the C++ add−in, Rose provides a means of converting an older C++ model to an ANSI C++ model.
First, select Add Ins → Add In Manager, and be sure the ANSI Converter add−in is selected. Select Tools → ANSI C++ → Convert from Classic C++.
You can choose the following options:
∙
Convert selected classes, which will convert any classes that you selected on a Class diagram before starting the conversion wizard
∙
418
Chapter 13: ANSI C++ and Visual C++ Code Generation and Reverse Engineering
Convert all classes in selected packages, which will convert all classes within any package(s) that you selected on a Class diagram before starting the conversion wizard
∙
Convert all classes in selected package and its subpackages, which will convert all classes within the package that you selected on a Class diagram, as well as all classes in subpackages of the selected package
∙
Convert Entire Model, which will convert all classes in all packages
Warning This operation will make significant changes to your model, so it's a good idea to make a backup of the model before performing the conversion.
ANSI C++ Code−Generation Properties
C++ code generation using Rational Rose is extremely flexible. You have full control over what gets generated and many of the details of how the generated code will look. For example, for each class, you can decide if a constructor, copy constructor, and destructor will automatically be created. For each attribute, you control the visibility, name, and whether Get and Set operations should automatically be created. For each operation, you control the name, parameters, visibility, and return type.
In ANSI C++, you can manage these types of settings using the code−generation properties and the C++ class and component specification windows. The ANSI C++ add−in includes code−generation properties for classes, attributes, operations, operation parameters, packages, components, associations, and generalizations. You can see all of these properties by selecting Tools → Options, and then selecting the ANSI C++ tab.
Code−generation properties can be set for the entire model or for a specific model element. You can change the default code−generation properties for the entire model by selecting Tools → Options, then selecting the ANSI C++ tab. Code−generation properties can be set for a single class, attribute, operation, or other model element, which will override the default setting. To do so, open the specification window for the model
419
Chapter 13: ANSI C++ and Visual C++ Code Generation and Reverse Engineering
element, select the ANSI C++ tab, modify the property value, and press the Override button. In the following sections, we'll examine the code−generation properties for classes, attributes, operations, operation parameters, packages, components, associations, and generalizations.
Class Properties
Class properties are the ANSI C++ code−generation properties that apply specifically to classes. These properties will let you change the class name, decide whether or not the class should be generated or reverse engineered, set the header filename, and set other class−specific properties.
There are two places to set these properties. To set them for all classes, select Tools → Options, then click the ANSI C++ tab and select Class from the drop−down list box. To set them for only one class, select the ANSI C++ tab on the class specification window and edit the properties there.
Using stereotypes, you can control the generation of keywords such as "static" or "virtual." Rose generates the text of the class stereotype in front of the "class" keyword.
Table 13.1 lists the ANSI C++ class properties, their purposes, and their default values.
Table 13.1: Class Code−Generation Properties
Property |
Purpose |
Default |
Synchronize |
Controls whether the class will participate in code |
True |
|
generation and reverse engineering. |
|
CodeName |
The name of the class in the generated code. |
By default, Rose will use |
|
|
the class name in the |
|
|
model. |
ImplementationType |
Controls whether a class is generated using a class |
<blank> (generates class |
|
definition or elemental data type. |
definition) |
420