The purpose of this section is to present a series of C++ code
generation scripts. Each script consists of script statements. The objective of each set
of script statements is to generate 100% compilable code with no compilation errors. Each
set of script statements generates compilable C++ statements. Each C++ statement consists
of C++ keywords, operators, and identifiers. For example, one set of script statements
generates the C++ function definitions. Another set of script statements generates a C++
copy constructor. These scripts show you the potential for automatically generating a
great deal of compilable C++ source code. However, as a developer you do not need to
generate a maximum amount of code for every class. You should only generate the amount of
code that you actually need. For example, you do not need to generate a constructor with
arguments for every class. You should decide what C++ features that you need and create or
modify the C++ code generation scripts to generate exactly what you want and no more. In
practice, we use a minimum code generation script, e.g. CPPHDMIN.SCT for header files and
CPPFUMIN.SCT for source code files (.cpp) for each project and then selectively use a
maximum code generation script for some classes, e.g. CPPHDMAX.SCT and CPPFUMAX.SCT. In
this section we are presenting portions of CPPHDMAX.SCT and CPPFUMAX.CPP for maximum ANSI
C++ code generation including the use of exceptions.
To generate compilable code you must have a correct script, a correct
model consisting of the diagram and specifications, and an adequate CASE tool scripting
language (operators and variables). The basic process is shown below. First we create a
class diagram as shown on the next page. In particular we enter the class names, attribute
names, operation names, and relationship traversal path names, e.g. currentCellularPhone.
Next we fill in the specification forms. We enter specific C++ information such as the
attribute type int and the operation return type void. In scripting terms we are ensuring
correct script variable values. For example, an incorrect script variable value would be
the attribute type of INTEGER which is not a legal C++ data type. Next we examine the C++
code generation script to ensure that correct C++ keywords and operators are entered as
script literals and that applicable script variables are used such as ATTRIBUTE_TYPE. Next
we run the script to generate the C++ code. We do a visual check to look for any obvious
compilation errors. Next we bring the C++ code files into a C++ environment and compile.
If there are any compilation errors, then we correct the model information and/or the
script to generate compilable C++.
Scripts are presented in the order of simple to complex:
- Generating the C++ Class Declaration in the Header File,
- Generating C++ Function Definitions in the Source Code File,
- Generating C++ Compiler Directives,
- Generating C++ Base and Derived Class Declarations,
- Generating C++ Symbolic const, typedef, and enum Declarations,
- Generating C++ Data Members and Accessor Functions,
- Generating One to One Aggregation Data Members and Accessor Functions,
- Generating One to One Association Data Members and Accessor Functions,
- Generating One to Many Aggregation Data Members and Accessor Functions,
- Generating One to Many Association Data Members and Accessor Functions,
- Generating Default Constructor and Destructor,
- Generating Constructor with Arguments,
- Generating the Copy Constructor,
- Generating the Assignment operator=,
- Generating the Equality operator==
- Generating Input Insertion operator>>,
- Generating Output Extraction operator<<,
The class diagram below shows the Car class with a generalization
relationship (inheritance), one to one aggregation relationship, one to one association
relationship, one to many aggregation relationship, and one to many association
relationship.
There is a single script to generate the class declaration for each class on this diagram, e.g. CPPHDMAX.SCT. There is a single script to generate the function definitions for each class on this diagram, e.g. CPPFUMAX.SCT. In this section we will show sets of script statements and the generated C++ code for the Car class. The class diagram below with specification information is the basis for the generated C++ code in the following sections.
Figure Class Diagram Used for C++ Code Generation
After the class diagram is completed, we generate C++ using a C++ header
file code generation script and a C++ function definition script. Then we compile the
generated code, update the generated code as required, create a main function and then
compile, link, and execute the project.
At this point we are ready to reverse the project to create a reversed
class diagram as shown below. This reversed class diagram shows all original data members
and function members plus the new generated data members and function members. For
example, nullCellularPhone is a new generated data member. A new generated function member
is setSpeed. This reversed diagram shows a single constructor per class. Actually, there
are three overloaded constructors in each class, e.g. default constructor, constructor
with arguments, and the copy constructor. The diagram show several overloaded operations
with a trailing $, e.g. existsPassenger$. This indicates that there are multiple functions
with the same name but different arguments. For example, there is an existsPassenger
function with no arguments and an existsPassenger function with a pointer argument.
Figure Reversed Class Diagram from Generated C++
The main function used this example is listed below. This is a basic
test case.
#include "car.h"
#include <iostream.h>
#include <cstring.h>
int main ()
{
Car car1; //Invokes default constructor
cin >> car1; //Invokes input function >>
cout << car1; //Invokes output function <<
int aSpeed, aNumber; //Create int variables
long aTotal; //Create long variable
car1.setspeed (55); //Invokes set accessor function
aSpeed = car1.getspeed(); //Invokes get accessor function
aSpeed = 65;
Car::settotalCarsBuilt (9999);//Invokes set accessor function for static data member
aTotal = Car::gettotalCarsBuilt(); //Invokes get accessor function for static data member
Car car2 (car1); //Invokes copy constructor
Car car3 (55, 0, 0); //Invokes constructor with arguments
car1 = car2; //Invokes assignment operator
//Invokes equality operator
if (car1 == car3) cout << "Cars are equal." << "\n";
else cout << "Cars are not equal." <<
"\n";
try {
car1.start(); } //Invokes redefined virtual function
catch (string startError) { cout << "Start Error"; }
catch (...) { cout << "Unknown Error" << endl;
}
try {
car1.operate(55); } //Invokes a function
catch (string operateError) { cout << "Operate Error"; }
catch (...) { cout << "Unknown Error" << endl;
}
try {
car1.stop(); } //Invokes a function
catch (string stopError) { cout << "Stop Error"; }
catch (...) { cout << "Unknown Error" << endl; }
Motor motor1; //Create motor objects
car1.setMotor(motor1); //Invokes set accessor function to set aggregation part
const Motor motor2 = car1.getMotor(); //Invokes get accessor
function to get aggregation part
CellularPhone phone1; //Create phone objects
car1.setCellularPhone (&phone1); //Invokes set accessor function
for association object
try {
car1.makePhoneCall(55555); } //Invokes traversal function to access association object
catch (string makePhoneCallError) { cout << "Make Phone Call Error"; }
catch (...) { cout << "Unknown Error" << endl;
}
try {
car1.receivePhoneCall(); } //Invokes traversal function to access association object
catch (string receivePhoneCallError) { cout << "Make Phone Call Error"; }
catch (...) { cout << "Unknown Error" << endl;
}
const CellularPhone phone2 = *car1.getCellularPhone ();//Invokes get accessor function to
//get association object
int phoneStatus = car1.existsCellularPhone (); //Invokes exists function for association object
phoneStatus = car1.existsCellularPhone (&phone1);//Invokes
exists function for association object
try {
car1.removeCellularPhone();} //Invokes remove function for association object
catch (string noCellularPhone) { cout << "No Cellular Phone"; }
catch (...) { cout << "Unknown Error" << endl; }
Tire tireArray[4]; //Creates array of tire objects
Tire* pTireArray = tireArray; //Creates pointer to the array of tire objects
pTireArray = (Tire*)car1.getTireCollection();//Invokes get accessor function
//for collection of aggregation objects
car1.setTireCollection (pTireArray);//Invokes set accessor function for
//collection of aggregation objects
const Tire tire1; //Creates tire objects
tire1 = car1.getFirstTire(); //Invokes get accessor function for 1:M aggregation object
int tireStatus = car1.existsTire (tire1);//Invokes exists function
for 1:M aggregation object
Passenger passengerArray[4]; //Creates array of passengers
Passenger* pPassengerArray = passengerArray; //Creates pointer to array of passenger objects
pPassengerArray = (Passenger*)car1.getPassengerCollection(); //Invokes get accessor function
//for collection of association objects
car1.setPassengerCollection (pPassengerArray); //Invokes set accessor function
//for collection of association objects
Passenger passenger1, passenger2, passenger3, passenger4; //Create
passenger objects
try {
car1.addPassenger(&passenger1); } //Invokes add function for 1:M association object
catch (string PassengerCollectionFull) { cout << "Passenger Collection Full" << endl;}
catch (...) { cout << "Unknown Error" << endl; }
try {
car1.addPassenger(&passenger2); } //Invokes add function for 1:M association object
catch (string PassengerCollectionFull) { cout << "Passenger Collection Full" << endl;}
catch (...) { cout << "Unknown Error" << endl; }
try {
car1.addPassenger(&passenger3); } //Invokes add function for 1:M association object
catch (string PassengerCollectionFull) { cout << "Passenger Collection Full" << endl;}
catch (...) { cout << "Unknown Error" << endl; }
try {
car1.addPassenger(&passenger4); } //Invokes add function for 1:M association object
catch (string PassengerCollectionFull) { cout << "Passenger Collection Full" << endl;}
catch (...) { cout << "Unknown Error" << endl; }
int passengerStatus;
passengerStatus = car1.existsPassenger (); //Invokes exists function for association object
passengerStatus = car1.existsPassenger (&passenger1); //Invokes exists function
//for association object
cin >> car1; //Invokes the >> operator to input text information
cout << car1; //Invokes the << operator to output text
information
try {
car1.removeLastPassenger (); } //Invokes removeLast function for 1:M association object
catch (string noPassengerError) { cout << "No Passenger Error" << endl; }
catch (...) { cout << "Unknown Error" << endl; }
try {
car1.removeAllPassengers(); } //Invokes removeAll function for 1:M association object
catch (string noPassengerError) { cout << "No Passenger Error" << endl; }
catch (...) { cout << "Unknown Error" << endl;
}
return 0; //Default destructor is invoked
}
Sample output of running the program is shown below.
Figure Screen Shot of the
Car Simulation Program Execution
C++ code generation scripts use a number of specific C++ script variables in the CASE tool. The specific C++ script variables are required to generate specific C++ keywords. In addition to the script variables previously presented, the following specific C++ script variables are used:
BASE_CLASS Prints superclass name for a class
INCLUDE_FILE Prints name of include file
CLASS_LIBRARY_BASE_CLASS Prints name of a library base class, e.g. CObject
CPP_ATTRIBUTE_CONSTANT Prints const if the attribute is checked as a const attribute
CPP_ATTRIBUTE_STATIC Prints static if the attribute is checked as a static attribute
CPP_OPERATIONS Prints all operations for a class in C++ format
CPP_OPERATION_VIRTUAL Prints virtual if operation is checked as a virtual function
CPP_OPERATION_CONSTANT Prints const if operation is checked as a const function
CPP_OPERATION_STATIC Prints static if operation is checked as a static function
CPP_OPERATION_PURE_VIRTUAL Prints = 0 if operation is checked as a pure virtual function
CPP_OPERATION_PARAMETERS Prints operation parameters in C++ format, e.g.
Class/Type Name Parameter Name - int aNumber
OPERATION_CPP_VIRTUAL_BASE_CLASS Prints virtual if a virtual function appears in the class
These scripts make extensive use of operators for concatenation, repeat,
and symbol deletion. These operators are required to generate compilable code. The
following are the CASE tool script operators used in C++ code generation scripts:
Concatenation Operator $ - the symbol $ means to connect a
literal and a variable. For example, Get$ATTRIBUTE_NAME
connects the literal Get and the variable ATTRIBUTE_NAME.
When executed, the result is Getspeed.
Repeat Operator [] - the symbol [] causes the variable or literal
to be repeated. For example, [ATTRIBUTE_NAME] causes a list
of attributes to be placed into the output file. Anything placed in between the brackets
will be repeated for every variable.
DELETE_LAST_SYMBOL operator removes the trailing punctuation
marks. This is useful in code generation. Example is class CLASS_NAME
[:BASE_CLASS ,DELETE_LAST_SYMBOL].
TRUNCATE_EIGHT operator truncates a class name to eight
characters using a vowel stripping algorithm. TRUNCATE_EIGHT_CHOP operator
truncates a class name to eight characters by removing all characters after the eighth
character. Example is #include "TRUNCATE_EIGHT$CLASS_NAME$_H". This is useful to create legal MS/DOS file names.
NO_REPEAT operator prints a literal or punctuation symbol once
without repeating it. Example is class CLASS_NAME [NO_REPEAT: public
BASE_CLASS].
LITERAL_SYMBOL operator treats a bracket [ as a literal. This is
used for arrays. Example is LITERAL_SYMBOL[ 10 LITERAL_SYMBOL].
NO_RETURN operator keeps all information on a single line without
a return. Example is class CLASS_NAME [NO_RETURN : public BASE_CLASS].
SCRIPT_NOREPEAT_HEADER_BEGIN and SCRIPT_NOREPEAT_HEADER_END operator
prints the literals and script variables with these operators. Example is SCRIPT_NOREPEAT_HEADER_BEGIN Beginning of the Class Report SCRIPT_NOREPEAT_HEADER_END.
SCRIPT_NOREPEAT_FOOTER_BEGIN and SCRIPT_NOREPEAT_FOOTER_END operator
prints the literals and script variables with these operators, (e.g. SCRIPT_NOREPEAT_FOOTER_BEGIN Ending of the Class Report SCRIPT_NOREPEAT_FOOTER_END). Do not place any script variables within these statements.
SELECT_WHEN, LOGICAL_NOT, ==, !=, ATTRIBUTE_IS_CONSTANT, ATTRIBUTE_IS_STATIC, ATTRIBUTE_IS_INDEX and ATTRIBUTE_IS_NORMAL operators provide the capability to print the literals and script variables the follow the SELECT_WHEN if the condition is true, (e.g.
SELECT_WHEN ATTRIBUTE_IS_CONSTANT [ATTRIBUTE_NAME],
SELECT_WHEN ATTRIBUTE_IS_STATIC [ATTRIBUTE_NAME],
SELECT_WHEN ATTRIBUTE_IS_NORMAL [ATTRIBUTE_NAME],
SELECT_WHEN ATTRIBUTE_IS_INDEX [ATTRIBUTE_NAME],
SELECT_WHEN ATTRIBUTE_ACCESS == private [ATTRIBUTE_NAME],
SELECT_WHEN OPERATION_ACCESS == public [ATTRIBUTE_NAME],
SELECT_WHEN OPERATION_ACCESS != public [ATTRIBUTE_NAME],
SELECT_WHEN OPERATION_IS_PROCEDURE [OPERATION_NAME],
SELECT_WHEN OPERATION_IS_FUNCTION [OPERATION_NAME]
SELECT_WHEN LOGICAL_NOT ATTRIBUTE_IS_STATIC [ATTRIBUTE_NAME])
NO_OUTPUT_BEGIN and NO_OUTPUT_END operators provide the
capability to place comments in scripts that do not print out in the script output. e.g. NO_OUTPUT_BEGIN. This script generates a text report listing class information NO_OUTPUT_END. Warning - do not place an script variables inside these operators. Place
only literals inside these operators.
CAPITALIZE_ALL capitalizes all letters for include file names,
e.g. #ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS$_H.
STRIP_TO_CAPITAL strips lower case letters prior to a capital
letter in class names, e.g. #ifndef __$STRIP_TO_CAPITAL$TRUNCATE_EIGHT$CLASS$_H.
These operators are required to generate compilable C++. Unfortunately, these operators make the scripts difficult to read. To understand each script you should follow these steps:
1 - Identify the literals that are generally upper and lower case, e.g. Class:
2 - Identify the script variables that are upper case, e.g. CLASS_NAME,
3 - Identify the repeat operator [] to see where multiple entries will be generated,
4 - Identify the other operators, e.g. DELETE_LAST_SYMBOL,
5 - Compare each script statement with the generated output, e.g. Class:
CLASS_NAME generates Class: Car,
Once you understand the script, then you can add, modify or delete script statements to generate exactly what you need.
The purpose of this introductory script is to generate an ANSI C++ class declaration in a header file. These script statements are part of the CPPHDMAX.SCT code generation script. The class declaration consists of C++ data member declarations and C++ function member definitions. From the class diagram, attributes become C++ data members. Operations become C++ function members. The sample code generation script, class diagram, and generated C++ code are shown below. To understand the script it is best to compare the script statements and the generated output. This script generates the following:
- #ifndef, #define, and #endif statement,
- class declaration, e.g. class Car { },
- data member declarations, e.g. int speed;
- function member declarations, e.g. void operate (int
aSpeed);
As shown below this script interpreter reads in a script statement of
literals, operators, and script variables. It inputs values for each script variable and
outputs C++ statements for the class declaration. For example, the interpreters reads in
the script statement #define __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS_NAME$_H. It then inputs the value of the script variable CLASS_NAME, e.g. Car. It inserts the value and outputs the C++ statement. The generated output is #define __CAR_H.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ data and function members. This information class
diagram shows the major script variables used in the C++ code generation script to create
the class declaration. It shows the CLASS_NAME, ATTRIBUTE_NAME, and OPERATION_NAME script variables. It shows
the #define statement. The class diagram on the right shows sample values of the script
variables, e.g. the define statement, class name Car, the attribute name speed, and the
operation name operate. These values appear in the generated C++ statements.
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and
Script Variable Values
Script to Generate C++ Class Declarations
// Class: CLASS_NAME //ANSI C++
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS_NAME$_H //Required for CLASS_NAME class
#define __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS_NAME$_H
class CLASS_NAME[NO_RETURN NO_REPEAT: NO_REPEAT public BASE_CLASS ,DELETE_LAST_SYMBOL] CLASS_LIBRARY_BASE_CLASS
{ SELECT_WHEN ATTRIBUTE_ACCESS == private [ATTRIBUTE_TYPE ATTRIBUTE_NAME$;]
SELECT_WHEN OPERATION_ACCESS == private
[ CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE OPERATION_NAME
(CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT CPP_OPERATION_PURE_VIRTUAL;
]
protected:
SELECT_WHEN ATTRIBUTE_ACCESS == protected [ATTRIBUTE_TYPE ATTRIBUTE_NAME$;]
SELECT_WHEN OPERATION_ACCESSS == protected
[ CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE OPERATION_NAME
(CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT CPP_OPERATION_PURE_VIRTUAL;
]
public:
SELECT_WHEN ATTRIBUTE_ACCESS == public [ATTRIBUTE_TYPE ATTRIBUTE_NAME$;]
SELECT_WHEN OPERATION_ACCESSS == public
[ CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE OPERATION_NAME
(CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT CPP_OPERATION_PURE_VIRTUAL;
]
};
#endif
Generated C++ Class Declaration in the Header File for
Car Class
// Class: Car //ANSI C++
#ifndef __CAR_H //Required for current class
#define __CAR_H
class Car : public Vehicle
{
int speed;
protected:
public:
void operate (int aSpeed);
};
#endif
The purpose of this script is to generate function definitions in a source code file (.cpp file). These script statements are part of the CPPFUMAX.SCT code generation script. The script generates the function definitions of functions declared in the class declaration. The function definition consists of the following: return type, function name, function arguments, and function code statements. This script generates the following:
- #include statement to include the header file, e.g. #include "Car.h"
- function comments, e.g. Purpose:
- function declaration, e.g. int Car::operate(int aSpeed),
- function code if code has been entered in the function specification.
Script to Generate C++ Function Definitions - Source
Code File
// Class: CLASS_NAME
//////////////////////////.cpp file/////////////////////////////////////////////////////
#include "$TRUNCATE_EIGHT$CLASS_NAME$.h"
// Functions for class CLASS_NAME
[
// Function: OPERATION_NAME
// Purpose: OPERATION_COMMENT1
// Parameters: CPP_OPERATION_PARAMETERS
// Comments: OPERATION_COMMENT2
OPERATION_RETURN_TYPE CLASS_NAME::OPERATION_NAME(CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT
{
OPERATION_CODE
}
]
Generated C++ Function Definitions - Source Code File
for Car Class
//////////////////////////.cpp file/////////////////////////////////////////////////////
#include "Car.h"
// Class: Car
// Functions for class Car
// Function: operate
// Purpose: To place the car at an operating speed
// Parameters: int aSpeed
// Comments:
void Car::operate(int aSpeed)
{
}
The purpose of these script statements is to generate the C++ compiler
directives. These script statements are part of the CPPHDMAX.SCT code generation script.
In the C++ header file, you must have include compiler directive statements for include
files. The script generates include statements for the following files: iostream.h for cin and cout use, base class header file if the class
is a derived class, any header files entered in the class specification form, one to one
association class header files such as ClllrPhn.h, one to one aggregation part class
header files such as Motor.h, one to many aggregation part header files such as Tire.h,
and one to one association header files such as Passenge.h. The script operator TRUNCATE_EIGHT is used to reduce long class names to eight characters for the MS/DOS file
system. For compilable code, the first eight characters of all class names should be
unique.
Script to Generate C++ Include Statements
// Class: CLASS_NAME //ANSI C++
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS_NAME$_H //Required for CLASS_NAME class
#define __$CAPITALIZE_ALL$TRUNCATE_EIGHT$CLASS_NAME$_H
#ifndef __IOSTREAM_H //Required for cin and cout
#include <iostream.h>
#endif
#ifndef __CSTRING_H //Required for CString class
#include <CString.h>
#endif
[
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$BASE_CLASS$_H //Required for BASE_CLASS class
#include "TRUNCATE_EIGHT$BASE_CLASS$.h"
#endif
]
[#include <INCLUDE_FILE> //Required for include files ]
[ //Required for 1:1 association classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$ASSOCIATION_ONE_CLASS$_H //ASSOCIATION_ONE_CLASS
#include "TRUNCATE_EIGHT$ASSOCIATION_ONE_CLASS.h"
#endif ]
[ //Required for 1:1 aggregation (part) classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$AGGREGATION_ONE_CLASS$_H //AGGREGATION_ONE_CLASS
#include "TRUNCATE_EIGHT$AGGREGATION_ONE_CLASS$.h"
#endif ]
[ //Required for 1:M association classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$ASSOCIATION_MANY_CLASS$_H //ASSOCIATION_MANY_CLASS
#include "TRUNCATE_EIGHT$ASSOCIATION_MANY_CLASS$.h"
#endif ]
[ //Required for 1:M aggregation (part) classes
#ifndef __$CAPITALIZE_ALL$TRUNCATE_EIGHT$AGGREGATION_MANY_CLASS$_H //AGGREGATION_MANY_CLASS
#include "TRUNCATE_EIGHT$AGGREGATION_MANY_CLASS$.h"
#endif ]
#endif
Generated C++ #include Statements in the Header File for
Car Class
// Class: Car //ANSI C++
#ifndef __CAR_H //Required for Car class
#define __CAR_H
#ifndef __IOSTREAM_H //Required for cin and cout
#include <iostream.h>
#endif
#ifndef __CSTRING_H //Required for CString class
#include <CString.h>
#endif
#ifndef __VEHICLE_H //Required for Vehicle class
#include "Vehicle.h"
#endif
//Required for 1:1 association classes
#ifndef __CLLLRPHN_H //CellularPhone
#include "ClllrPhn.h"
#endif
//Required for 1:1 aggregation (part) classes
#ifndef __MOTOR_H //Motor
#include "Motor.h"
#endif
//Required for 1:M association classes
#ifndef __PASSENGR_H //Passenger
#include "Passengr.h"
#endif
//Required for 1:M aggregation (part) classes
#ifndef __TIRE_H //Tire
#include "Tire.h"
#endif
#endif
The purpose of these script statements is to generate symbolic const,
typedef and enum declaration statements in the C++ header file. These script statements
are part of the CPPHDMAX.SCT code generation script. In using arrays it is useful to
declare a symbolic const variable for the array limit. The script below generates a const
variable maxNumberOf$AGGREGATION_MANY_CLASS and maxNumberOf$ASSOCIATION_MANY_CLASS to set the array limits for arrays which hold one to many aggregation objects
and one to many association objects. The default value of 4 is assigned as the initial
value of the const variables. This default value must be updated in the generated code to
reflect the actual default value of the const variables. You must update the CLASS_USER1 and CLASS_USER2 input fields in the CASE tool
class specification input form. Alternatively, create an constant attribute and generate
the const declaration as discussed in the next section.
Script to Generate C++ const Declarations
NO_OUTPUT_BEGIN Use the CLASS_USER fields for typedef, enum, const declarations, e.g.
const int maxNumberOfTires = 4; NO_OUTPUT_END
CLASS_USER1
CLASS_USER2
Generated C++ Code - const Declarations for Car Class
const int maxNumberOfTires = 4; const int maxNumberOfPassengers = 4;
The purpose of this script is to generate C++ class declarations for base and derived classes. These script statements are part of the CPPHDMAX.SCT code generation script. On the class declaration, we show the generalization specialization relationship between a superclass and a subclass. In C++ terms, we show the inheritance relationship between a base class, e.g. Vehicle and a derived class, e.g. Car. The base class has a virtual functions, a pure virtual function, and a virtual destructor. This script generates the following:
- the base class declaration, e.g. class Vehicle
- the base class virtual functions, pure virtual function, and virtual destructor declarations, e.g. virtual void start(), virtual void operate (int aSpeed) = 0, and virtual ~Vehicle();
- the derived class declaration, e.g. class Car : public Vehicle
- data member declarations, e.g. int speed;
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ data and function members. This information class
diagram shows a class with script variables. It shows the major script variables and
statements used in the C++ code generation script to declare base and derived classes. It
shows the CLASS_NAME, ATTRIBUTE_NAME, and OPERATION_NAME. It shows the script
variables CPP_OPERATION_VIRTUAL and CPP_OPERATION_PURE_VIRTUAL. If an operation is checked as being virtual or pure virtual in the operation
specification, then these variables provide for the correct function declaration. For the
sample virtual function, the script generates virtual void start (); For the sample pure virtual function the script generates virtual
void operate() = 0; The script generates a virtual destructor, e.g. virtual
~Vehicle. As stated in the Microsoft Visual C++ Programmer's Guide
"... declare the base class's destructor as virtual. This causes the destructors of
all derived classes to be virtual... Then if delete is applied to a base class pointer,
the appropriate destructor is called, no matter what type of object the pointer is
pointing to." [Microsoft - 93]. This script generates the data members for 1 to 1
aggregation, 1 to 1 association, 1 to many aggregation, and 1 to many association.
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and
Script Variable Values
Script to Generate C++ Class Declaration - .h File
class CLASS_NAME[NO_RETURN NO_REPEAT: NO_REPEAT public BASE_CLASS ,DELETE_LAST_SYMBOL] CLASS_LIBRARY_BASE_CLASS
{ SELECT_WHEN ATTRIBUTE_ACCESS == private
[CPP_ATTRIBUTE_STATIC CPP_ATTRIBUTE_CONSTANT ATTRIBUTE_TYPE
ATTRIBUTE_NAME$; //Attribute data member]
[AGGREGATION_ONE_CLASS AGGREGATION_ONE_NAME$; //1:1 aggregation part
data member]
[ASSOCIATION_ONE_CLASS$* ASSOCIATION_ONE_NAME$; //1:1 association
object data member]
[ASSOCIATION_ONE_CLASS null$ASSOCIATION_ONE_CLASS;// Null
association object for association object]
[int AGGREGATION_MANY_NAME$Index; //Index for array of 1:M
aggregation part objects]
[ //1:M aggregation part data member
//Change C array to C++ collection class with iterator
AGGREGATION_MANY_CLASS AGGREGATION_MANY_NAME
LITERAL_SYMBOL[maxNumberOf$AGGREGATION_MANY_CLASS$s LITERAL_SYMBOL];]
[int ASSOCIATION_MANY_NAME$Index; //Index for array of 1:M
association objects]
[ //1:M association object data member
//Change C array to C++ collection class with iterator
ASSOCIATION_MANY_CLASS$* ASSOCIATION_MANY_NAME
LITERAL_SYMBOL[maxNumberOf$ASSOCIATION_MANY_CLASS$s LITERAL_SYMBOL];]
[ // Null association object for initialization of association object data member
ASSOCIATION_MANY_CLASS$ null$ASSOCIATION_MANY_CLASS;]
SELECT_WHEN OPERATION_ACCESS == private
[ CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE
OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT
CPP_OPERATION_PURE_VIRTUAL ; ]
protected:
SELECT_WHEN OPERATION_ACCESS == protected
[ CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE
OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT
CPP_OPERATION_PURE_VIRTUAL ; ]
SELECT_WHEN ATTRIBUTE_ACCESS == protected
[CPP_ATTRIBUTE_STATIC CPP_ATTRIBUTE_CONSTANT ATTRIBUTE_TYPE
ATTRIBUTE_NAME$;]
public:
SELECT_WHEN ATTRIBUTE_ACCESS == public
[CPP_ATTRIBUTE_STATIC CPP_ATTRIBUTE_CONSTANT ATTRIBUTE_TYPE
ATTRIBUTE_NAME$;]
SELECT_WHEN OPERATION_ACCESS == public
[CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE
OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT
CPP_OPERATION_PURE_VIRTUAL ; ]
OPERATION_CPP_VIRTUAL_BASE_CLASS ~ CLASS_NAME ( ) { }
//Destructor - Delete any pointer data members that used new in constructors
//Destructor should be virtual if and only if class contains at least one virtual function
//Objects destroyed in the reverse order of the construction order
};
Script to Generate C++ Function Definitions - .cpp File
#include "$TRUNCATE_EIGHT$CLASS_NAME$.h"
[
OPERATION_RETURN_TYPE CLASS_NAME::OPERATION_NAME(CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT
{ OPERATION_CODE
} ]
The following is the reversed class diagram from the generated C++ code.
Figure Reversed Class Diagram Showing Data and
Function Members
Generated C++ Class Declaration for Vehicle Class - .h
File
class Vehicle
{
protected:
float weight;
public:
virtual void start () ;
virtual void operate (int aSpeed) = 0 ;
virtual void stop () ;
virtual ~ Vehicle ( ) { }//Destructor - Delete any pointer data members that used new in constructors
//Destructor should be virtual if and only if class contains at least one virtual function
//Objects destroyed in the reverse order of the construction order
};
Generated C++ Function Definitions for Vehicle Class -
.cpp File
//////////////////////////.cpp file/////////////////////////////////////////////////////
#include "Vehicle.h"
void Vehicle::start() {
}
void Vehicle::operate(int aSpeed) {
}
void Vehicle::stop(){
}
Generated C++ Class Declaration for Car Class - .h File
class Car : public Vehicle
{
int speed; //Attribute data member
static int totalCarsBuilt; //Attribute data member
float gasQuantity; //Attribute data member
const float minimumGasQuantity; //Attribute data member
Motor currentMotor; //1:1 aggregation part data member
CellularPhone* currentCellularPhone; //1:1 association object data
member
CellularPhone nullCellularPhone;// Null association object for
association object
int currentTiresIndex; //Index for array of 1:M aggregation part
objects
//1:M aggregation part data member
//Change C array to C++ collection class with iterator
Tire currentTires [maxNumberOfTires ];
int currentPassengersIndex; //Index for array of 1:M association
objects
//1:M association object data member
//Change C array to C++ collection class with iterator
Passenger* currentPassengers [maxNumberOfPassengers ];
// Null association object for initialization of association object data member
Passenger nullPassenger;
public:
void start () ;
void operate (int aSpeed) ;
void stop () ;
void makePhoneCall (long aNumber) ;
void receivePhoneCall () ;
void addPassenger (Passenger aPassenger) ;
void removePassenger (Passenger aPassenger) ;
~ Car ( ) { } //Destructor - Delete any pointer data members that used new in constructors
//Destructor should be virtual if and only if class contains at least one virtual function
//Objects destroyed in the reverse order of the construction order
};
Generated C++ Function Definitions for Car Class- .cpp
File
#include "Car.h"
int Car::totalCarsBuilt = 0; //Static data member initialization
void Car::start() {
}
void Car::operate(int aSpeed) {
}
void Car::stop() {
}
void Car::makePhoneCall(long aNumber) {
}
void Car::receivePhoneCall() {
}
void Car::addPassenger(Passenger aPassenger) {
}
void Car::removePassenger(Passenger aPassenger) {
}
A C++ data member can represent an attribute, 1 to 1 aggregation traversal path, 1 to 1 association traversal path, 1 to many aggregation traversal path, and 1 to many association traversal path. You may create various accessor functions to get or set data member values.
An attribute may be a normal data member, a static data member or a
const data member. This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ data members and accessor functions. This
information class diagram shows a class with script variables. It shows the major script
variables used in the C++ code generation script to declare data members and accessor
functions. It shows the CLASS_NAME and ATTRIBUTE_NAME script variables. It shows the get$ATTRIBUTE_NAME
and set$ATTRIBUTE_NAME script statements. The class diagram
on the right shows sample values of the script variables and script statements, e.g. class
name Car, the attribute name speed, the get accessor function getspeed, and the set
accessor function setspeed. As shown below a static data
member is initialized outside the class declaration.
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and Script Variable Values
The purpose of these script statements is to generate C++ accessor
function members to implement one to one aggregation relationships. These script
statements are part of the CPPHDMAX.SCT code generation script. On the class declaration,
we show a one to one aggregation relationship by connecting an aggregation assembly class,
e.g. Car with an aggregation part class, e.g. motor. We show a relationship traversal
name, e.g. currentMotor. In the aggregation assembly class, the script generates a
non-static data member for each aggregation part class. In the Car class, the script
generates a data member, e.g. Motor currentMotor. In the
aggregation assembly class, the script generates get and set accessor functions for the
aggregation part data member. In the Car class, the script generates the getMotor and setMotor accessor functions. The get accessor
function returns a reference to the aggregation part data member, e.g.
Motor& getMotor (). The set accessor function takes a reference
argument, e.g. void setMotor (Motor& aMotor). You
desire to have very strict encapsulation with no access to private data members. If so,
then do not use these script statements.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ data and function members. This information class
diagram shows a class with script variables. It shows the major script variables used in
the C++ code generation script to declare one to one aggregation data members and accessor
functions. It shows the CLASS_NAME and AGGREGATION_ONE_NAME script variables. It shows the get$AGGREGATION_ONE_CLASS and set$AGGREGATION_ONE_CLASS script statements.
The class diagram on the right shows sample values of the script variables and script
statements, e.g. class name Car, the traversal one to one
aggregation data member currentMotor, the get accessor
function getMotor, and the set accessor function setMotor.
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and Script Variable Values
The purpose of these script statements is to generate C++ accessor
function members to data members that implement one to one association relationships.
These script statements are part of the CPPHDMAX.SCT code generation script. On the class
declaration, we show a one to one association relationship by connecting a class, e.g. Car with an association class, e.g. CellularPhone. We
show a relationship traversal name, e.g. currentCellularPhone. In the first class, the script generates a private non-static data member for
each association. For example, in the Car class, the script generates a pointer data
member, e.g. CellualarPhone* currentCellularPhone. In the
Car class the script generates several accessor functions for the association data member.
These are the get, set, remove, exists, and exists for a specific association object.
These accessor functions either take a pointer argument or return a pointer. You may
desire to have very strict encapsulation with no access to private data members. If so,
then do not use these script statements.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ data and function members. This information class
diagram shows a class with script variables. It shows the major script variables used in
the C++ code generation script to declare one to one association data members and accessor
functions. It shows the CLASS_NAME and ASSOCIATION_ONE_NAME script variables. It shows the get$ASSOCIATION_ONE_CLASS, set$ASSOCIATION_ONE_CLASS, remove$ASSOCIATION_ONE_CLASS, exists$ASSOCIATION_ONE_CLASS, and
exists$ASSOCIATION_ONE_CLASS (ASSOCIATION_ONE_CLASS$*) script
statements. The class diagram on the right shows sample values of the script variables and
script statements, e.g. class name Car, the traversal one
to one association data member *currentCellularPhone, the
get accessor function getCellularPhone, the set accessor
function setCellularPhone, the remove function removeCellularPhone, the exists function existsCellularPhone, and the
exists function existsCellularPhone (CellularPhone*).
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram
Showing Script Variables and Script Variable Values
The purpose of these script statements is to generate C++ and accessor
function members to data members that implement one to many aggregation relationships.
These script statements are part of the CPPHDMAX.SCT code generation script. On the class
declaration, we show a one to many aggregation relationship by connecting an aggregation
assembly class, e.g. Car with an aggregation part class,
e.g. Tire. We show a relationship traversal name, e.g. currentTires. In the aggregation assembly class, the script generates a private non-static
array data member for each aggregation part class. In the Car class, the script generates
an array data member, e.g. Tire currentTires[maxNumberOfTires]. In the aggregation assembly class, the script generates getCollection and setCollection accessor functions for the aggregation part data
member. The script generates the removeFirst and exists accessor functions. The
getCollection accessor function returns a pointer to the first element of the array. The
setCollection accessor function takes a pointer to the first element of the passed array.
You may desire to have very strict encapsulation with no access to private data members.
If so, then do not use these script statements.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ data and function members. This information class
diagram shows a class with script variables. It shows the major script variables used in
the C++ code generation script to declare one to many aggregation data members and
accessor functions. It shows the CLASS_NAME and AGGREGATION_MANY_NAME script variables. It shows the get$AGGREGATION_MANY_CLASS$Collection, get$AGGREGATION_MANY_CLASS$Collection, getFirst$AGGREGATION_MANY_CLASS, and exits$AGGREGATION_MANY_CLASS script
statements. The class diagram on the right shows sample values of the script variables and
script statements, e.g. class name Car, the traversal one
to many aggregation data member currentTires[maxNumberOfTires], the get accessor function getTireCollection, the
set accessor function setTireCollection, the getFirstTire function, and the exists function existsTire.
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and Script Variable Values
The purpose of these script statements is to generate C++ and accessor
function members to data members that implement one to many association relationships.
These script statements are part of the CPPHDMAX.SCT code generation script. On the class
declaration, we show a one to many association relationship by connecting a class, e.g.
Car with an association class, e.g. Passenger. We show a relationship traversal name, e.g.
currentPassenger. In the first class, the script generates
a private non-static array data member for each association class. For example, in the Car
class, the script generates an array data member, e.g. Passenger
currentPassengers[maxNumberOfPassengers]. In the first class, the
script generates getCollection and setCollection accessor functions for the association
data member. The script generates the add, getFirst, removeFirst, removeAll, exists, and
exists for a specific object functions. The getCollection accessor function returns a
pointer to the first element of the array. The setCollection accessor function takes a
pointer to the first element of the passed array. You may desire to have very strict
encapsulation with no access to private data members. If so, then do not use the
getCollection and setCollection script statements.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ data and function members. This information class
diagram shows a class with script variables. It shows the major script variables used in
the C++ code generation script to declare one to many association data members and
accessor functions. It shows the CLASS_NAME and ASSOCIATION_MANY_NAME script variables. It shows the get$ASSOCIATION_MANY_CLASS$Collection, set$ASSOCIATION_MANY_CLASS$Collection, getFirst$ASSOCIATION_MANY_CLASS, removeLast$ASSOCIATION_MANY_CLASS, exists$ASSOCIATION_MANY_CLASS, and exists$ASSOCIATION_MANY_CLASS (ASSOCIATION_MANY_CLASS$*) script statements. The class diagram on the right shows sample values of the
script variables and script statements, e.g. class name Car,
the traversal one to many association data member currentPassengers[maxNumberOfPassengers], the get accessor function getPassengerCollection,
the set accessor function setPassengerCollection, the add
function addPassenger, the getFirst function getFirstPassenger, the removeLast function removeLastPassenger, the
remove All function removeAllPassengers, the exists
function existsPassenger, and the exists function
existsPassenger (Passenger*).
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram
Showing Script Variables and Script Variable Values
Script to Generate C++ Accessor Functions for Data
Members in the Header File
SELECT_WHEN ATTRIBUTE_IS_NORMAL
[ //Get accessor function for non-static attribute data member
ATTRIBUTE_TYPE get$ATTRIBUTE_NAME$() const
{ return ATTRIBUTE_NAME$;
} ]
SELECT_WHEN ATTRIBUTE_IS_NORMAL
[ //Set accessor function for non-static attribute data member
void set$ATTRIBUTE_NAME (const ATTRIBUTE_TYPE a$ATTRIBUTE_NAME$)
{ ATTRIBUTE_NAME = a$ATTRIBUTE_NAME$;
} ]
SELECT_WHEN ATTRIBUTE_IS_STATIC
[ //Get accessor function for static attribute data member
static ATTRIBUTE_TYPE get$ATTRIBUTE_NAME$()
{ return ATTRIBUTE_NAME$; } ]
SELECT_WHEN ATTRIBUTE_IS_STATIC
[ //Set accessor function for static attribute data member
static void set$ATTRIBUTE_NAME ( const ATTRIBUTE_TYPE a$ATTRIBUTE_NAME$)
{ ATTRIBUTE_NAME = a$ATTRIBUTE_NAME$;
} ]
SELECT_WHEN ATTRIBUTE_IS_CONSTANT
[ //Get accessor function for constant attribute data member
ATTRIBUTE_TYPE get$ATTRIBUTE_NAME$()
{ return ATTRIBUTE_NAME$;
} ]
[ //Get accessor function for 1:1 aggregation part data member
const AGGREGATION_ONE_CLASS$& get$AGGREGATION_ONE_CLASS$() const
{ return AGGREGATION_ONE_NAME$;
} ]
[ //Set accessor function for 1:1 aggregation part data member
void set$AGGREGATION_ONE_CLASS (const AGGREGATION_ONE_CLASS$& a$AGGREGATION_ONE_NAME$)
{ AGGREGATION_ONE_NAME = a$AGGREGATION_ONE_NAME$;
} ]
[ //Get accessor function for 1:1 association object data member
const ASSOCIATION_ONE_CLASS$* get$ASSOCIATION_ONE_CLASS$() const
{ return ASSOCIATION_ONE_NAME$;
} ]
[ //Set accessor function for 1:1 association object data member
void set$ASSOCIATION_ONE_CLASS ($ASSOCIATION_ONE_CLASS$* const a$ASSOCIATION_ONE_NAME$)
{ ASSOCIATION_ONE_NAME = a$ASSOCIATION_ONE_NAME$;
} ]
[ //Remove function for 1:1 association object data member
//Warning delete ASSOCIATION_ONE_NAME object if dynamic object
void remove$ASSOCIATION_ONE_CLASS$(); //throw (string) ]
[ //Exists function for 1:1 association object data member
int exists$ASSOCIATION_ONE_CLASS$() const; ]
[ //Exists function with argument for 1:1 association object data member
int exists$ASSOCIATION_ONE_CLASS ($ASSOCIATION_ONE_CLASS$* const
a$ASSOCIATION_ONE_NAME$) const; ]
[ //Get accessor function for 1:M aggregation collection NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Returns pointer to the 1st element of the C array NO_OUTPUT_END
const AGGREGATION_MANY_CLASS$* get$AGGREGATION_MANY_CLASS$Collection
() const ; ]
[ //Set accessor function for 1:M aggregation collection NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Parameter is pointer to the first element of the C array NO_OUTPUT_END
void set$AGGREGATION_MANY_CLASS$Collection
($AGGREGATION_MANY_CLASS$* const a$AGGREGATION_MANY_NAME$Collection); ]
[ //Get accessor function for 1:M aggregation part data member NO_OUTPUT_BEGIN
//Returns the first 1:M aggregation part in the array
//Change C array to C++ collection class with iterator NO_OUTPUT_END
const AGGREGATION_MANY_CLASS$&
getFirst$AGGREGATION_MANY_CLASS$() const ; ]
[ //Exists function for 1:M aggregation part data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
int exists$AGGREGATION_MANY_CLASS (const
AGGREGATION_MANY_CLASS$& a$AGGREGATION_MANY_CLASS$) const ; ]
[ //Get accessor function for 1:M association collection NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Returns pointer to 1st element of the C array NO_OUTPUT_END
const ASSOCIATION_MANY_CLASS$*
get$ASSOCIATION_MANY_CLASS$Collection() const ; ]
[ //Set accessor function for 1:M association collection NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Parameter is pointer to 1st element of the C array NO_OUTPUT_END
void set$ASSOCIATION_MANY_CLASS$Collection
($ASSOCIATION_MANY_CLASS$* const a$ASSOCIATION_MANY_CLASS$Collection); ]
[ //Add function for 1:M association object data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
void add$ASSOCIATION_MANY_CLASS ($ASSOCIATION_MANY_CLASS$* const
a$ASSOCIATION_MANY_CLASS$); //throw (string) ]
[ //Remove function for 1:M association object data member
//Warning delete ASSOCIATION_MANY_NAME object if dynamic object NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
void removeLast$ASSOCIATION_MANY_CLASS ( ) ;//throw (string) ]
[ //Remove all function for 1:M association object data member
//Warning delete ASSOCIATION_MANY_NAME object if dynamic object NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
void removeAll$ASSOCIATION_MANY_CLASS$s ( ) ;//throw (string) ]
[ //Get accessor function for 1:M association object data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Returns the first 1:M association object pointer in the array NO_OUTPUT_END
const ASSOCIATION_MANY_CLASS$* getFirst$ASSOCIATION_MANY_CLASS$()
const ;//throw (string) ]
[ //Exists function for 1:M association object data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
int exists$ASSOCIATION_MANY_CLASS$() const ; ]
[ //Exists function for 1:M association object data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
int exists$ASSOCIATION_MANY_CLASS ($ASSOCIATION_MANY_CLASS$* const a$ASSOCIATION_MANY_CLASS$) const ; ]
SELECT_WHEN OPERATION_ACCESS == public
[CPP_OPERATION_VIRTUAL CPP_OPERATION_STATIC OPERATION_RETURN_TYPE
OPERATION_NAME (CPP_OPERATION_PARAMETERS) CPP_OPERATION_CONSTANT
CPP_OPERATION_PURE_VIRTUAL ; ]
Reversed Class Diagram Showing All Accessor Functions to
Data Members
Figure Reversed Class Diagram Showing Accessor
Functions
Generated C++ Accessor Functions for Data Members in Car
Class Header File (.h File)
//Get accessor function for non-static attribute data member
int getspeed() const
{ return speed;
}
//Get accessor function for non-static attribute data member
float getgasQuantity() const
{ return gasQuantity;
}
//Set accessor function for non-static attribute data member
void setspeed (const int aspeed)
{ speed = aspeed;
}
//Set accessor function for non-static attribute data member
void setgasQuantity (const float agasQuantity)
{ gasQuantity = agasQuantity;
}
//Get accessor function for static attribute data member
static int gettotalCarsBuilt()
{ return totalCarsBuilt;
}
//Set accessor function for static attribute data member
static void settotalCarsBuilt ( const int atotalCarsBuilt)
{ totalCarsBuilt = atotalCarsBuilt;
}
//Get accessor function for constant attribute data member
float getminimumGasQuantity()
{ return minimumGasQuantity;
}
//Get accessor function for 1:1 aggregation part data member
const Motor& getMotor() const
{ return currentMotor;
}
//Set accessor function for 1:1 aggregation part data member
void setMotor (const Motor& acurrentMotor)
{ currentMotor = acurrentMotor;
}
//Get accessor function for 1:1 association object data member
const CellularPhone* getCellularPhone() const
{ return currentCellularPhone;
}
//Set accessor function for 1:1 association object data member
void setCellularPhone (CellularPhone* const acurrentCellularPhone)
{ currentCellularPhone = acurrentCellularPhone;
}
//Remove function for 1:1 association object data member
//Warning delete currentCellularPhone object if dynamic object
void removeCellularPhone(); //throw (string)
//Exists function for 1:1 association object data member
int existsCellularPhone() const;
//Exists function with argument for 1:1 association object data member
int existsCellularPhone (CellularPhone* const acurrentCellularPhone)
const;
//Get accessor function for 1:M aggregation collection
const Tire* getTireCollection () const ;
//Set accessor function for 1:M aggregation collection
void setTireCollection (Tire* const acurrentTiresCollection);
//Get accessor function for 1:M aggregation part data member
const Tire& getFirstTire() const ;
//Exists function for 1:M aggregation part data member
int existsTire (const Tire& aTire) const ;
//Get accessor function for 1:M association collection
const Passenger* getPassengerCollection() const ;
//Set accessor function for 1:M association collection
void setPassengerCollection (Passenger* const aPassengerCollection);
//Add function for 1:M association object data member
void addPassenger (Passenger* const aPassenger); //throw (string)
//Remove function for 1:M association object data member
//Warning delete currentPassengers object if dynamic object
void removeLastPassenger ( ) ;//throw (string)
//Remove all function for 1:M association object data member
//Warning delete currentPassengers object if dynamic object
void removeAllPassengers ( ) ;//throw (string)
//Get accessor function for 1:M association object data member
const Passenger* getFirstPassenger() const ;//throw (string)
//Exists function for 1:M association object data member
int existsPassenger() const ;
//Exists function for 1:M association object data member
int existsPassenger (Passenger* const aPassenger) const ;
Script to Generate C++ Accessor Functions for Data
Members in Souce Code File (.cpp file)
[ //Remove function for 1:1 association object data member
//Warning delete ASSOCIATION_ONE_NAME object if dynamic object
void CLASS_NAME::remove$ASSOCIATION_ONE_CLASS$() //throw (string)
{ string no$ASSOCIATION_ONE_CLASS$;
if ( ASSOCIATION_ONE_NAME == &null$ASSOCIATION_ONE_CLASS ) throw no$ASSOCIATION_ONE_CLASS$;
else ASSOCIATION_ONE_NAME = &null$ASSOCIATION_ONE_CLASS;
} ]
[ //Get accessor function for 1:M association object data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Returns the first 1:M association object pointer in the array NO_OUTPUT_END
const ASSOCIATION_MANY_CLASS$* CLASS_NAME::getFirst$ASSOCIATION_MANY_CLASS$() const //throw (string)
{ string ASSOCIATION_MANY_CLASS$CollectionEmpty;
if ( ASSOCIATION_MANY_NAME$Index == 0 ) throw ASSOCIATION_MANY_CLASS$CollectionEmpty;
else return ASSOCIATION_MANY_NAME LITERAL_SYMBOL[ASSOCIATION_MANY_NAME$Index LITERAL_SYMBOL];
} ]
[ //Exists function for 1:1 association object data member
int CLASS_NAME::exists$ASSOCIATION_ONE_CLASS$() const
{ if ( ASSOCIATION_ONE_NAME == &null$ASSOCIATION_ONE_CLASS ) return 0; else return 1;
} ]
[ //Exists function with argument for 1:1 association object data member
int CLASS_NAME::exists$ASSOCIATION_ONE_CLASS ($ASSOCIATION_ONE_CLASS$* const a$ASSOCIATION_ONE_CLASS$) const
{ if ( ASSOCIATION_ONE_NAME == &null$ASSOCIATION_ONE_CLASS ) return 0;
else if ( *$ASSOCIATION_ONE_NAME == *a$ASSOCIATION_ONE_CLASS ) return 1;
else return 0;
} ]
[ //Get accessor function for 1:M aggregation collection NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Returns pointer to the 1st element of the C array NO_OUTPUT_END
const AGGREGATION_MANY_CLASS$* CLASS_NAME::get$AGGREGATION_MANY_CLASS$Collection () const
{ return AGGREGATION_MANY_NAME ;
} ]
[ //Set accessor function for 1:M aggregation collection NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Parameter is pointer to the first element of the C array NO_OUTPUT_END
void CLASS_NAME::set$AGGREGATION_MANY_CLASS$Collection ($AGGREGATION_MANY_CLASS$* const a$AGGREGATION_MANY_CLASS$Collection)
{ for (int i = 0; i < maxNumberOf$AGGREGATION_MANY_CLASS$s; i++) AGGREGATION_MANY_NAME LITERAL_SYMBOL[ i LITERAL_SYMBOL] = a$AGGREGATION_MANY_CLASS$Collection LITERAL_SYMBOL[ i LITERAL_SYMBOL];
} ]
[ //Exists function for 1:M aggregation part data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
int CLASS_NAME::exists$AGGREGATION_MANY_CLASS (const AGGREGATION_MANY_CLASS$& a$AGGREGATION_MANY_CLASS$) const
{ for (int i = 0; i < maxNumberOf$AGGREGATION_MANY_CLASS$s; i++)
{ if ( AGGREGATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] == a$AGGREGATION_MANY_CLASS ) return 1;
}
return 0;
} ]
[ //Get accessor function for 1:M aggregation part data member NO_OUTPUT_BEGIN
//Returns the first 1:M aggregation part in the array
//Change C array to C++ collection class with iterator NO_OUTPUT_END
const AGGREGATION_MANY_CLASS$& CLASS_NAME::getFirst$AGGREGATION_MANY_CLASS$() const
{ return AGGREGATION_MANY_NAME LITERAL_SYMBOL[ 0 LITERAL_SYMBOL] ;
} ]
[ //Get accessor function for 1:M association collection NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Returns pointer to 1st element of the C array NO_OUTPUT_END
const ASSOCIATION_MANY_CLASS$* CLASS_NAME::get$ASSOCIATION_MANY_CLASS$Collection() const
{ return *$ASSOCIATION_MANY_NAME;
} ]
[ //Set accessor function for 1:M association collection NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator
//Parameter is pointer to 1st element of the C array NO_OUTPUT_END
void CLASS_NAME::set$ASSOCIATION_MANY_CLASS$Collection ($ASSOCIATION_MANY_CLASS$* const a$ASSOCIATION_MANY_CLASS$Collection)
{ int i = 0;
for ( i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[ i LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS ;
for ( i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[ i LITERAL_SYMBOL] = &a$ASSOCIATION_MANY_CLASS$Collection LITERAL_SYMBOL[ i LITERAL_SYMBOL];
} ]
[ //Add function for 1:M association object data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
void CLASS_NAME::add$ASSOCIATION_MANY_CLASS ($ASSOCIATION_MANY_CLASS$* const a$ASSOCIATION_MANY_CLASS$) //throw (string)
{ string ASSOCIATION_MANY_CLASS$CollectionFull;
if ( ASSOCIATION_MANY_NAME$Index == maxNumberOf$ASSOCIATION_MANY_CLASS$s) throw ASSOCIATION_MANY_CLASS$CollectionFull;
else
{ ASSOCIATION_MANY_NAME LITERAL_SYMBOL[ ASSOCIATION_MANY_NAME$Index LITERAL_SYMBOL] = a$ASSOCIATION_MANY_CLASS ;
ASSOCIATION_MANY_NAME$Index++;
}
} ]
[ //Remove function for 1:M association object data member
//Warning delete ASSOCIATION_MANY_NAME object if dynamic object NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
void CLASS_NAME::removeLast$ASSOCIATION_MANY_CLASS ( ) //throw (string)
{ string ASSOCIATION_MANY_CLASS$CollectionEmpty;
if ( ASSOCIATION_MANY_NAME$Index == 0 ) throw ASSOCIATION_MANY_CLASS$CollectionEmpty;
else
{ ASSOCIATION_MANY_NAME$Index--;
ASSOCIATION_MANY_NAME LITERAL_SYMBOL[ASSOCIATION_MANY_NAME$Index LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS ;
}
} ]
[ //Remove all function for 1:M association object data member
//Warning delete ASSOCIATION_MANY_NAME object if dynamic object NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
void CLASS_NAME::removeAll$ASSOCIATION_MANY_CLASS$s ( ) //throw (string)
{ string ASSOCIATION_MANY_CLASS$CollectionEmpty;
if ( ASSOCIATION_MANY_NAME$Index == 0 ) throw ASSOCIATION_MANY_CLASS$CollectionEmpty;
for (int i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS;
} ]
[ //Exists function for 1:M association object data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
int CLASS_NAME::exists$ASSOCIATION_MANY_CLASS$() const
{ if ( ASSOCIATION_MANY_NAME LITERAL_SYMBOL[0 LITERAL_SYMBOL] == &null$ASSOCIATION_MANY_CLASS ) return 0; else return 1;
} ]
[ //Exists function for 1:M association object data member NO_OUTPUT_BEGIN
//Change C array to C++ collection class with iterator NO_OUTPUT_END
int CLASS_NAME::exists$ASSOCIATION_MANY_CLASS ($ASSOCIATION_MANY_CLASS$* const a$ASSOCIATION_MANY_CLASS$) const
{if (ASSOCIATION_MANY_NAME LITERAL_SYMBOL[ 0 LITERAL_SYMBOL] == &null$ASSOCIATION_MANY_CLASS) return 0;
for (int i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++)
{if ( ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] == a$ASSOCIATION_MANY_CLASS) return 1;
}
return 0; } ]
Generated C++ Accessor Functions for Data Members in
Souce Code File (.cpp file) for Car Class
//Remove function for 1:1 association object data member
//Warning delete currentCellularPhone object if dynamic object
void Car::removeCellularPhone() //throw (string)
{ string noCellularPhone;
if ( currentCellularPhone == &nullCellularPhone ) throw noCellularPhone;
else currentCellularPhone = &nullCellularPhone;
}
//Get accessor function for 1:M association object data member
const Passenger* Car::getFirstPassenger() const //throw (string)
{ string PassengerCollectionEmpty;
if ( currentPassengersIndex == 0 ) throw PassengerCollectionEmpty;
else return currentPassengers [currentPassengersIndex ];
}
//Exists function for 1:1 association object data member
int Car::existsCellularPhone() const
{ if ( currentCellularPhone == &nullCellularPhone ) return 0; else return 1;
}
//Exists function with argument for 1:1 association object data member
int Car::existsCellularPhone (CellularPhone* const aCellularPhone) const
{ if ( currentCellularPhone == &nullCellularPhone ) return 0;
else if ( *currentCellularPhone == *aCellularPhone ) return 1;
else return 0;
}
//Get accessor function for 1:M aggregation collection
const Tire* Car::getTireCollection () const
{ return currentTires ;
}
//Set accessor function for 1:M aggregation collection
void Car::setTireCollection (Tire* const aTireCollection)
{ for (int i = 0; i < maxNumberOfTires; i++) currentTires [ i ] = aTireCollection [ i ];
}
//Exists function for 1:M aggregation part data member
int Car::existsTire (const Tire& aTire) const
{ for (int i = 0; i < maxNumberOfTires; i++)
{ if ( currentTires [i ] == aTire ) return 1;
}
return 0;
}
//Get accessor function for 1:M aggregation part data member
const Tire& Car::getFirstTire() const
{ return currentTires [ 0 ] ;
}
//Get accessor function for 1:M association collection
const Passenger* Car::getPassengerCollection() const
{ return *currentPassengers;
}
//Set accessor function for 1:M association collection
void Car::setPassengerCollection (Passenger* const aPassengerCollection)
{ int i = 0;
for ( i = 0; i < maxNumberOfPassengers; i++) currentPassengers [ i ] = &nullPassenger ;
for ( i = 0; i < maxNumberOfPassengers; i++) currentPassengers [ i ] = &aPassengerCollection [ i ];
}
//Add function for 1:M association object data member
void Car::addPassenger (Passenger* const aPassenger) //throw (string)
{ string PassengerCollectionFull;
if ( currentPassengersIndex == maxNumberOfPassengers) throw PassengerCollectionFull;
else
{ currentPassengers [ currentPassengersIndex ] = aPassenger ;
currentPassengersIndex++;
}
}
//Remove function for 1:M association object data member
//Warning delete currentPassengers object if dynamic object
void Car::removeLastPassenger ( ) //throw (string)
{ string PassengerCollectionEmpty;
if ( currentPassengersIndex == 0 ) throw PassengerCollectionEmpty;
else
{ currentPassengersIndex--;
currentPassengers [currentPassengersIndex ] = &nullPassenger ;
}
}
//Remove all function for 1:M association object data member
//Warning delete currentPassengers object if dynamic object
void Car::removeAllPassengers ( ) //throw (string)
{ string PassengerCollectionEmpty;
if ( currentPassengersIndex == 0 ) throw PassengerCollectionEmpty;
for (int i = 0; i < maxNumberOfPassengers; i++) currentPassengers [i ] = &nullPassenger;
}
//Exists function for 1:M association object data member
int Car::existsPassenger() const
{ if ( currentPassengers [0 ] == &nullPassenger ) return 0; else return 1;
}
//Exists function for 1:M association object data member
int Car::existsPassenger (Passenger* const aPassenger) const
{ if ( currentPassengers [ 0 ] == &nullPassenger ) return 0;
for (int i = 0; i < maxNumberOfPassengers; i++)
{ if ( currentPassengers [i ] == aPassenger ) return 1;
}
return 0;
}
The purpose of these script statements is to generate the C++ default
constructor in the class declaration. These script statements are part of the CPPHDMAX.SCT
code generation script. The default constructor initializes each data member. It
initializes each attribute data member with the initial value in the attribute
specification. It initializes each association data member to a nullAssociation object.
Alternatively you may initialize each association data member pointer to zero. It
initializes array indexes to zero. It initializes each association data member in the
array of association objects to nullAssociation object. Alternatively you may initialize
each pointer in the array of association objects to zero.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ default constructor. This information class
diagram shows a class with script variables. It shows the major script variables used in
the C++ code generation script to define the default constructor. It shows the CLASS_NAME, ATTRIBUTE_NAME, AGGREGATION_ONE_NAME,
ASSOCIATION_ONE_NAME, AGGREGATION_MANY_NAME, and ASSOCIATION_MANY_NAME. The class diagram on the left shows actual values of the script variables and
script statements, e.g. class name Car, the attribute names speed, gasQuantity,
minimumGasQuantity, currentCellularPhone, currentTires[maxNumberOfTires], and currentPassengers[maxNumberOfPassengers]. It
is not necessary to explicitly put the one to one aggregation name in the default
constructor. As stated in the Microsoft Visual C++ Programmer's Guide,
"the compiler implicitly calls the default constructor for the member object before
constructing the containing object." [Microsoft - 93]. Notice that the implementation
uses the initializer list. As stated in the Microsoft Visual C++ Programmer's Guide
"When you declare an object of a derived class, the compiler executes the constructor
for the base class first and then executes the constructor for the derived class. ...You
may omit the base initializer if the base class has a default constructor. As with member
objects, however, you should use the base initializer syntax rather than perform redundant
initialization. If you're defining a derived class that also has member objects, you can
specify both a member initializer list and a base initializer list. However, you cannot
define member initializers for member objects defined in the base class, because that
would permit multiple initializations." [Microsoft - 93]
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and
Script Variable Values
Script to Generate C++ Default Constructor in Class
Declaration in the Header File
//Default constructor alternative to compiler provided default constructor
//Ensure correct initial values
//Initialization list has members in the order declared
//Association object data member pointers initialized to null association object
CLASS_NAME ();
Script to Generate C++ Default Constructor in Source
Code File (.cpp file)
//Default constructor alternative to compiler provided default constructor
//Association object data member pointers initialized to null association object NO_OUTPUT_BEGIN
//Ensure correct initial values are entered in the Attribute Specification NO_OUTPUT_END
CLASS_NAME::CLASS_NAME ()
SELECT_WHEN LOGICAL_NOT ATTRIBUTE_IS_STATIC [NO_RETURN NO_REPEAT: ATTRIBUTE_NAME(ATTRIBUTE_INITIAL_VALUE),DELETE_LAST_SYMBOL]
{ [ASSOCIATION_ONE_NAME = &null$ASSOCIATION_ONE_CLASS; //Initialization to null association object ]
[AGGREGATION_MANY_NAME$Index = 0; //Index for array of 1:M aggregation part objects ]
[ASSOCIATION_MANY_NAME$Index = 0; //Index for array of 1:M association objects ]
//Initialization of array of 1:M association objects to null association objects
[for ( int i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS; ]
}
Generated C++ Default Constructor in Class Declaration
in the Header File for Car Class
//Default constructor alternative to compiler provided default constructor
//Ensure correct initial values
//Initialization list has members in the order declared
//Association object data member pointers initialized to null association object
Car ();
Generated C++ Default Constructor in Souce Code File
(.cpp file)
//Default constructor alternative to compiler provided default constructor
//Association object data member pointers initialized to null association object
Car::Car ()
: speed(0), gasQuantity(0), minimumGasQuantity(0)
{ currentCellularPhone = &nullCellularPhone; //Initialization to null association object
currentTiresIndex = 0; //Index for array of 1:M aggregation part objects
currentPassengersIndex = 0; //Index for array of 1:M association objects
//Initialization of array of 1:M association objects to null association objects
for ( int i = 0; i < maxNumberOfPassengers; i++) currentPassengers [i ] = &nullPassenger;
}
The purpose of these script statements is to generate the C++
constructor with arguments. These script statements are part of the CPPHDMAX.SCT code
generation script. The constructor with arguments initializes each attribute data member
with the passed argument value. It also initializes the base class attribute data members.
Optionally, the constructor with arguments initializes the association data member, the
one to many aggregation data member collection, and the one to many association data
member collection. This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ constructor with arguments. This class diagram
shows a class with script variables. It shows the major script variables used in the C++
code generation script to define the constructor with arguments. It shows the CLASS_NAME,
ATTRIBUTE_NAME, AGGREGATION_ONE_NAME, ASSOCIATION_ONE_NAME, AGGREGATION_MANY_NAME, and ASSOCIATION_MANY_NAME. The class diagram on
the right shows actual values of the script variables and script statements, e.g. class
name Car, the attribute names speed, gasQuantity, minimumGasQuantity, currentCellularPhone, currentTires[maxNumberOfTires], and currentPassengers[maxNumberOfPassengers].
Notice that the implementation invokes the base class default constructor, e.g. : Vehicle
(). Alternatively you could provide an argument list to provide
specific data member values for base class data members. An alternate could be Car
( int aspeed, float agasQuantity, float aminimumGasQuantity , int aweight ) :
speed(aspeed) , gasQuantity (agasQuantity), minimumGasQuantity (aminimumGasQuantity),
Vehicle(aweight){...}. The const data member minimumGasQuantity must be initialized in the initializer list. David Papurt provides a description
of the use of const data members in Inside the Object Model - The Sensible Use of C++
[Papurt - 95].
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and
Script Variable Values
Script to Generate C++ Constructor with Arguments in
Class Declaration
//Constructor with arguments
//Update to argument list to initialize base class data members,
//e.g. (int aNumber) : BaseClass (aNumber)
CLASS_NAME ( SELECT_WHEN LOGICAL_NOT ATTRIBUTE_IS_STATIC [NO_RETURN
ATTRIBUTE_TYPE a$ATTRIBUTE_NAME,DELETE_LAST_SYMBOL] ) ;
Generated C++ Constructor with Arguments in Class
Declaration in the Header File for Car Class
//Constructor with arguments
//Update to argument list to initialize base class data members and const data members
//e.g. (int aNumber) : BaseClass (aNumber) , constMinimumValue (aMinimumValue)
CLASS_NAME::CLASS_NAME ( SELECT_WHEN LOGICAL_NOT ATTRIBUTE_IS_STATIC [NO_RETURN ATTRIBUTE_TYPE a$ATTRIBUTE_NAME,DELETE_LAST_SYMBOL] )
[NO_RETURN NO_REPEAT: BASE_CLASS$() ,DELETE_LAST_SYMBOL]
SELECT_WHEN ATTRIBUTE_IS_CONSTANT [//NO_RETURN NO_REPEAT: ATTRIBUTE_NAME (a$ATTRIBUTE_NAME),DELETE_LAST_SYMBOL]
{ SELECT_WHEN ATTRIBUTE_IS_NORMAL [ATTRIBUTE_NAME = a$ATTRIBUTE_NAME; //Initialization of attributes ]
[AGGREGATION_MANY_NAME$Index = 0; //Index for array of 1:M aggregation part objects ]
[ASSOCIATION_MANY_NAME$Index = 0; //Index for array of 1:M association objects ]
[ASSOCIATION_ONE_NAME = &null$ASSOCIATION_ONE_CLASS; //Initialization to null association object ]
//Initialization of array of 1:M association objects to null association objects
[for ( int i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS; ]
}
Generated C++ Default Constructor in Class Declaration
(.h file)
//Constructor with arguments
//Update to argument list to initialize base class data members,
//e.g. (int aNumber) : BaseClass (aNumber)
Car ( int aspeed, float agasQuantity, float aminimumGasQuantity ) ;
Generated C++ Default Constructor in Souce Code File
(.cpp file)
//Constructor with arguments
//Update to argument list to initialize base class data members and const data members
//e.g. (int aNumber) : BaseClass (aNumber) , constMinimumValue (aMinimumValue)
Car::Car ( int aspeed, float agasQuantity, float aminimumGasQuantity )
: Vehicle() , minimumGasQuantity (aminimumGasQuantity)
{ speed = aspeed; //Initialization of attributes
gasQuantity = agasQuantity; //Initialization of attributes
currentTiresIndex = 0; //Index for array of 1:M aggregation part objects
currentPassengersIndex = 0; //Index for array of 1:M association objects
currentCellularPhone = &nullCellularPhone; //Initialization to null association object
//Initialization of array of 1:M association objects to null association objects
for ( int i = 0; i < maxNumberOfPassengers; i++) currentPassengers [i ] = &nullPassenger;
}
These script statements are part of the CPPHDMAX.SCT code generation
script. These script statements are part of the CPPHDMAX.SCT code generation script. The
copy constructor initializes the new object with the value of the copy object. For
example, we could initialize the new car2 object with the value of the already constructed
car1 object.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ copy constructor. This class diagram shows a class
with script variables. It shows the major script variables used in the C++ code generation
script to define the copy constructor. It shows the CLASS_NAME, ATTRIBUTE_NAME, AGGREGATION_ONE_NAME, ASSOCIATION_ONE_NAME, AGGREGATION_MANY_NAME, and ASSOCIATION_MANY_NAME. The class diagram on
the right shows actual values of the script variables and script statements, e.g. class
name Car, the attribute names speed, currentMotor, currentCellularPhone, currentTires[maxNumberOfTires], and currentPassengers[maxNumberOfPassengers]. The const data member is initialized in the initializer list -
minimumGasQuantity (aCar.minimumGasQuantity). The base class copy
constructor is invoked in the initializer list - : Vehicle (aCar). This copy constructor provides a "member by member" copy from the
source object to the new object but does not copy pointers for association objects. As
discussed by Grady Booch, there are many copy alternatives such as shallow and deep copy
[Booch-94].
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and
Script Variable Values
Script to Generate C++ Copy Constructor in Class
Declaration in the Header File
//Copy Constructor NO_OUTPUT_BEGIN
//Copy constructor alternative to compiler provided default copy constructor
//Copy alternatives for association objects:
//(1) initialize association object to nullAssociation Object
//(2) Shallow copy to copy pointers of association objects
//(3) Deep copy to create new association objects and copy values of association objects
//Commented out code assigns 1:1 and 1:M association object data member pointers for shallow copy
//Remove // if you desire to assign pointers NO_OUTPUT_END
CLASS_NAME (const CLASS_NAME$& a$CLASS_NAME );
Script to Generate C++ Copy Constructor in Source Code
File (.cpp file)
//Copy constructor alternative to compiler provided default copy constructor NO_OUTPUT_BEGIN
//Update initializer list for const data members, e.g. : constMinimumValue (aCar.minimumValue)
//Copy alternatives for association objects:
//(1) initialize association object to nullAssociation Object
//(2) Shallow copy to copy pointers of association objects
//(3) Deep copy to create new association objects and copy values of association objects
//Commented out code assigns 1:1 and 1:M association object data member pointers for shallow copy
//Remove // if you desire to assign pointers NO_OUTPUT_END
CLASS_NAME::CLASS_NAME (const CLASS_NAME$& a$CLASS_NAME )
[NO_RETURN NO_REPEAT: BASE_CLASS (a$CLASS_NAME),DELETE_LAST_SYMBOL]
SELECT_WHEN ATTRIBUTE_IS_CONSTANT [//NO_RETURN NO_REPEAT: ATTRIBUTE_NAME (a$CLASS_NAME$.$ATTRIBUTE_NAME),DELETE_LAST_SYMBOL]
{int i = 0;
[ AGGREGATION_MANY_NAME$Index = 0; //Index for array of 1:M aggregation part objects ]
[ ASSOCIATION_MANY_NAME$Index = 0; //Index for array of 1:M association objects ]
SELECT_WHEN ATTRIBUTE_IS_NORMAL [ATTRIBUTE_NAME = a$CLASS_NAME$.$ATTRIBUTE_NAME;]
[ AGGREGATION_ONE_NAME = a$CLASS_NAME$.$AGGREGATION_ONE_NAME;]
[ ASSOCIATION_ONE_NAME = &null$ASSOCIATION_ONE_CLASS; //Initialization to null association object ]
[ //ASSOCIATION_ONE_NAME = a$CLASS_NAME$.$ASSOCIATION_ONE_NAME; //Commented out shallow copy]
[ for ( i = 0; i < maxNumberOf$AGGREGATION_MANY_CLASS$s; i++) AGGREGATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = a$CLASS_NAME$.$AGGREGATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] ; ]
[ for ( i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS; //Initialization of pointers to null association object ]
[ //Commented out shallow copy
[ //for ( i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] ; ]
}
Generated C++ Copy Constructor in Class Declaration for
Car Class the Header File
//Copy Constructor
Car (const Car& aCar );
Generated C++ Copy Constructor in Source Code File (.cpp
file) for Car Class
//Copy constructor alternative to compiler provided default copy constructor
Car::Car (const Car& aCar )
: Vehicle (aCar), : minimumGasQuantity (aCar.minimumGasQuantity)
{int i = 0;
currentTiresIndex = 0; //Index for array of 1:M aggregation part objects
currentPassengersIndex = 0; //Index for array of 1:M association objects
speed = aCar.speed;
gasQuantity = aCar.gasQuantity;
currentMotor = aCar.currentMotor;
currentCellularPhone = &nullCellularPhone; //Initialization to null association object
//currentCellularPhone = aCar.currentCellularPhone; //Commented out shallow copy
for ( i = 0; i < maxNumberOfTires; i++) currentTires [i ] = aCar.currentTires [i ] ;
for ( i = 0; i < maxNumberOfPassengers; i++) currentPassengers [i ] = &nullPassenger;
//Initialization of pointers to null association object
//Commented out shallow copy
//for ( i = 0; i < maxNumberOfPassengers; i++) currentPassengers [i ] = aCar.currentPassengers [i ] ;
}
The purpose of these script statements is to generate the operator=
assignment operator. These script statements are part of the CPPHDMAX.SCT code generation
script. The operator= sets the value of the data members of an object with the value of
data members of another object. For example, the statement car1 = car2 would set car1 data
members with the value of car2 data members. This script uses the script variables
graphically shown on the class diagram on the left to generate the C++ operator=. This
class diagram shows a class with script variables. It shows the major script variables
used in the C++ code generation script to define the operator= operator. It shows the CLASS_NAME,
ATTRIBUTE_NAME, AGGREGATION_ONE_NAME, ASSOCIATION_ONE_NAME, AGGREGATION_MANY_NAME, and ASSOCIATION_MANY_NAME. The class diagram on
the right shows sample values of the script variables and script statements, e.g. class
name Car, the attribute names speed, currentMotor, currentCellularPhone,
currentTires[maxNumberOfTires], and currentPassengers[maxNumberOfPassengers].
This assignment operator provides a "member by member" copy
from the source object to the new object but does not copy pointers for association
objects. As discussed by Grady Booch, there are many assignment alternatives such as
shallow and deep copy [Booch-94].
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and
Script Variable Values
Script to Generate C++ operator= Assignment Operator in
Class Declaration in the Header File
//Operator= Assignment Operator
CLASS_NAME& operator= (const CLASS_NAME$& a$CLASS_NAME);
Script to Generate C++ operator= Assignment Operator in
Source File
//Operator= Assignment Operator alternative to compiler provided operator= NO_OUTPUT_BEGIN
//Assignment alternatives for association objects:
//(1) initialize association object to nullAssociation Object
//(2) Shallow copy to copy pointers to association objects
//(3) Deep copy to copy value of association objects
//Commented out code copies pointers for 1:1 and 1:M association object data members for
//shallow copy Remove // if you desire to assign association object pointers for shallow copy NO_OUTPUT_END
CLASS_NAME& CLASS_NAME::operator= (const CLASS_NAME$& a$CLASS_NAME)
{ if (this == &a$CLASS_NAME) return *this;
int i = 0;
[ BASE_CLASS$::operator= (a$CLASS_NAME);]
SELECT_WHEN ATTRIBUTE_IS_NORMAL [ ATTRIBUTE_NAME = a$CLASS_NAME$.$ATTRIBUTE_NAME;]
[ AGGREGATION_ONE_NAME = a$CLASS_NAME$.$AGGREGATION_ONE_NAME;]
[ ASSOCIATION_ONE_NAME = &null$ASSOCIATION_ONE_CLASS; //Initialization to null association object ]
[ // ASSOCIATION_ONE_NAME = a$CLASS_NAME$.$ASSOCIATION_ONE_NAME;//Commented out shallow copy]
[ for (i = 0; i < maxNumberOf$AGGREGATION_MANY_CLASS$s; i++) AGGREGATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = a$CLASS_NAME$.$AGGREGATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] ; ]
[ for (i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = &null$ASSOCIATION_MANY_CLASS ; //Initialization of pointers to null association object ]
[ //for (i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++) ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] = a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] ; ]
return *this;
Generated C++ operator= Assignment Operator in Car Class
Declaration in the Header File
//Operator= Assignment Operator
Car& operator= (const Car& aCar);
Generated C++ operator= Assignment Operator in Car Class
Source Code File
//Operator= Assignment Operator alternative to compiler provided operator=
Car& Car::operator= (const Car& aCar)
{ if (this == &aCar) return *this;
int i = 0;
Vehicle::operator= (aCar);
speed = aCar.speed;
gasQuantity = aCar.gasQuantity;
currentMotor = aCar.currentMotor;
currentCellularPhone = &nullCellularPhone; //Initialization to null association object
// currentCellularPhone = aCar.currentCellularPhone;//Commented out shallow copy
for (i = 0; i < maxNumberOfTires; i++) currentTires [i ] = aCar.currentTires [i ] ;
for (i = 0; i < maxNumberOfPassengers; i++) currentPassengers [i ] = &nullPassenger ;
//Initialization of pointers to null association object
//for (i = 0; i < maxNumberOfPassengers; i++) currentPassengers [i ] = aCar.currentPassengers [i ] ;
return *this;
}
The purpose of these script statements is to generate the C++ operator==
equality operator. These script statements are part of the CPPHDMAX.SCT and CPPFUMAX.SCT
code generation scripts. The operator== compares the value of the attribute data members
and aggregation data members of one object with another object. If the values are equal,
then the operator== returns 1. If the values are not equal, then the operator== returns 0.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ data and function members. This class diagram
shows a class with script variables. It shows the major script variables used in the C++
code generation script to define the operator==. It shows the CLASS_NAME,
ATTRIBUTE_NAME, AGGREGATION_ONE_NAME, ASSOCIATION_ONE_NAME, AGGREGATION_MANY_NAME, and ASSOCIATION_MANY_NAME. The class diagram on
the right shows actual values of the script variables and script statements, e.g. class
name Car, the attribute names speed,
gasQuantity, currentMotor, and
currentTires[maxNumberOfTires]. This equality operator provides a
"member by member" comparison from one object to another object but does not
compare pointers for association objects. As discussed by Grady Booch, there are many
comparison based upon shallow and deep copy [Booch-94].
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and
Script Variable Values
Script to Generate C++ operator== Equality Operator in
for Car Class Declaration in the Header File
//Operator== Equality Operator
int operator== (const CLASS_NAME$& a$CLASS_NAME) const;
Script to Generate C++ operator== Equality Operator in
Car Class Source File
//Operator== Equality Operator NO_OUTPUT_BEGIN
//No compiler generated operator== generated
//Update to access 1:1 association object data members
//Function does not compare 1:1 and 1:M association object data member pointers
//Comparison alternatives for association objects: (1) Do not compare association objects,
//(2) Do a shallow comparison
//to compare pointers of association objects
//(3) Do a deep comparison to compare the values of association objects
//Update for 1:M association object data members
//Change C array to C++ collection for 1:M data members NO_OUTPUT_END
int CLASS_NAME::operator== (const CLASS_NAME$& a$CLASS_NAME) const
{ return (
[ (BASE_CLASS$::operator== (a$CLASS_NAME)) &&]
[ //Equality check for 1:1 association data members for shallow comparison
//( ASSOCIATION_ONE_NAME == a$CLASS_NAME$.$ASSOCIATION_ONE_NAME) &&]
//Equality check for 1:1 aggregation part data members
[ ( AGGREGATION_ONE_NAME == a$CLASS_NAME$.$AGGREGATION_ONE_NAME) &&]
//Equality check for 1:M aggregation parts
//Update for the correct number of aggregation part objects
[ ( AGGREGATION_MANY_NAME LITERAL_SYMBOL[0 LITERAL_SYMBOL] == a$CLASS_NAME$.$AGGREGATION_MANY_NAME LITERAL_SYMBOL[0 LITERAL_SYMBOL])&&
( AGGREGATION_MANY_NAME LITERAL_SYMBOL[1 LITERAL_SYMBOL] == a$CLASS_NAME$.$AGGREGATION_MANY_NAME LITERAL_SYMBOL[1 LITERAL_SYMBOL])&&
( AGGREGATION_MANY_NAME LITERAL_SYMBOL[2 LITERAL_SYMBOL] == a$CLASS_NAME$.$AGGREGATION_MANY_NAME LITERAL_SYMBOL[2 LITERAL_SYMBOL])&&
( AGGREGATION_MANY_NAME LITERAL_SYMBOL[3 LITERAL_SYMBOL] == a$CLASS_NAME$.$AGGREGATION_MANY_NAME LITERAL_SYMBOL[3 LITERAL_SYMBOL])&&
]
//Equality check for 1:M association objects for shallow compare
//Update for the correct number of associated objects
[//( ASSOCIATION_MANY_NAME LITERAL_SYMBOL[0 LITERAL_SYMBOL] == a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[0 LITERAL_SYMBOL])&&
//( ASSOCIATION_MANY_NAME LITERAL_SYMBOL[1 LITERAL_SYMBOL] == a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[1 LITERAL_SYMBOL])&&
//( ASSOCIATION_MANY_NAME LITERAL_SYMBOL[2 LITERAL_SYMBOL] == a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[2 LITERAL_SYMBOL])&&
//( ASSOCIATION_MANY_NAME LITERAL_SYMBOL[3 LITERAL_SYMBOL] == a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[3 LITERAL_SYMBOL])&&
]
//Equality check for attribute data members
SELECT_WHEN ATTRIBUTE_IS_NORMAL [(ATTRIBUTE_NAME == a$CLASS_NAME$.$ATTRIBUTE_NAME) &DELETE_LAST_SYMBOL&DELETE_LAST_SYMBOL]
);
}
Generated C++ operator== Equality Operator in Class
Declaration in the Header File
//Operator== Equality Operator
int operator== (const Car& aCar) const;
Generated C++ operator== Equality Operator in Source
Code File
//Operator== Equality Operator
int Car::operator== (const Car& aCar) const
{ return (
(Vehicle::operator== (aCar)) &&
//Equality check for 1:1 association data members for shallow comparison
//( currentCellularPhone == aCar.currentCellularPhone) &&
//Equality check for 1:1 aggregation part data members
( currentMotor == aCar.currentMotor) &&
//Equality check for 1:M aggregation parts
//Update for the correct number of aggregation part objects
( currentTires [0 ] == aCar.currentTires [0 ])&&
( currentTires [1 ] == aCar.currentTires [1 ])&&
( currentTires [2 ] == aCar.currentTires [2 ])&&
( currentTires [3 ] == aCar.currentTires [3 ])&&
//Equality check for 1:M association objects for shallow compare
//Update for the correct number of associated objects
//( currentPassengers [0 ] == aCar.currentPassengers [0 ])&&
//( currentPassengers [1 ] == aCar.currentPassengers [1 ])&&
//( currentPassengers [2 ] == aCar.currentPassengers [2 ])&&
//( currentPassengers [3 ] == aCar.currentPassengers [3 ])&&
//Equality check for attribute data members
(speed == aCar.speed) &&
(gasQuantity == aCar.gasQuantity)
);
}
The purpose of these script statements is to generate the C++
operator>> - insertion operator for cin. These script statements are part of the
CPPHDMAX.SCT and CPPFUMAX.SCT code generation scripts. The operator>> is used for
text input. The operator>> sets each data member with the value of the user text
input. For example, cin >> car1 sets the value of the
car1 data members to the value of the user text input.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ operator>>. This class diagram shows a class
with script variables. It shows the major script variables used in the C++ code generation
script to define the operator>> - insertion operator for cin. It shows the CLASS_NAME,
ATTRIBUTE_NAME, AGGREGATION_ONE_NAME, ASSOCIATION_ONE_NAME, AGGREGATION_MANY_NAME, and ASSOCIATION_MANY_NAME. The class diagram on
the right shows actual values of the script variables and script statements, e.g. class
name Car, the attribute names speed,
currentMotor, currentCellularPhone, currentTires[maxNumberOfTires],
and currentPassengers[maxNumberOfPassengers]. This
insertion operator does not assign const data members or static data members.
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and
Script Variable Values
Script to Generate C++ operator>> - Insertion
Operator for cin in the Car Class Declaration in the Header File
//Operator>> for cin
friend istream& operator>> (istream& is, CLASS_NAME$& a$CLASS_NAME);
OPERATION_CPP_VIRTUAL_BASE_CLASS ~ CLASS_NAME ( ) { } //Destructor - Delete any pointer data members
// that used new in constructors
Script to Generate C++ operator>> - Insertion
Operator for cin in Source Code File
//Operator>> insertion for cin NO_OUTPUT_BEGIN
//Change C array to C++ collection for 1:M data members NO_OUTPUT_END
istream& operator>> (istream& is, CLASS_NAME$& a$CLASS_NAME)
{ int i = 0;
[ is >> (BASE_CLASS &) a$CLASS_NAME;]
cout << "\nEnter Object Attribute Values or 0 - Class CLASS_NAME";
SELECT_WHEN ATTRIBUTE_IS_NORMAL [ cout << "\nEnter ATTRIBUTE_NAME : " << endl;
is >> a$CLASS_NAME$.$ATTRIBUTE_NAME;]
[ is >> a$CLASS_NAME$.$AGGREGATION_ONE_NAME;]
[ if (a$CLASS_NAME$.$ASSOCIATION_ONE_NAME != &a$CLASS_NAME$.null$ASSOCIATION_ONE_CLASS) is >> *$a$CLASS_NAME$.$ASSOCIATION_ONE_NAME ; ]
[ for (i = 0; i < maxNumberOf$AGGREGATION_MANY_CLASS$s; i++) is >> a$CLASS_NAME$.$AGGREGATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] ; ]
[ for (i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++)
{ if ( a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL]!= &a$CLASS_NAME$.null$ASSOCIATION_MANY_CLASS) is >> *a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] ;
} ]
return is;
}
Generated C++ operator>> - Insertion Operator for
cin in the Car Class Declaration in the Header File
//Operator>> for cin
friend istream& operator>> (istream& is, Car&
aCar);
Generated C++ operator>> - Insertion Operator for
cin in Source Code File for Car Class
//Operator>> insertion for cin
istream& operator>> (istream& is, Car& aCar)
{ int i = 0;
is >> (Vehicle &) aCar;
cout << "\nEnter Object Attribute Values or 0 - Class Car";
cout << "\nEnter speed : " << endl;
is >> aCar.speed;
cout << "\nEnter gasQuantity : " << endl;
is >> aCar.gasQuantity;
is >> aCar.currentMotor;
if (aCar.currentCellularPhone != &aCar.nullCellularPhone) is >> *aCar.currentCellularPhone ;
for (i = 0; i < maxNumberOfTires; i++) is >> aCar.currentTires [i ] ;
for (i = 0; i < maxNumberOfPassengers; i++)
{ if ( aCar.currentPassengers [i ]!= &aCar.nullPassenger) is >> *aCar.currentPassengers [i ] ;
}
return is;
}
The purpose of these script statements is to generate the C++
operator<< - extraction operator for cout. These script statements are part of the
CPPHDMAX.SCT and CPPFUMAX.SCT code generation scripts. The operator<< is used for
text output. The operator<< sets each data member with the value of the user text
input. For example, cout << car1 outputs the value of
the car1 data members.
This script uses the script variables graphically shown on the class
diagram on the left to generate the C++ operator<<. This information class diagram
shows a class with script variables. It shows the major script variables used in the C++
code generation script to define the operator<< - extraction operator for cout. It
shows the CLASS_NAME, ATTRIBUTE_NAME, AGGREGATION_ONE_NAME,
ASSOCIATION_ONE_NAME, AGGREGATION_MANY_NAME, and ASSOCIATION_MANY_NAME. The class diagram on the right shows actual values of the script variables and
script statements, e.g. class name Car, the attribute names speed, gasQuantity,
minimumGasQuantity, currentMotor, currentCellularPhone, currentTires[maxNumberOfTires], and currentPassengers[maxNumberOfPassengers].
Major Script Variables for C++ Sample Values of Major Script Variables
Data and Function Members in C++ Data and Function Members
Figure Class Diagram Showing Script Variables and
Script Variable Values
Script to Generate C++ operator<< - Extraction
Operator for cout in the Class Declaration in the Header File
//Operator<< for cout
friend ostream& operator<< (ostream& os, const
Car& aCar);
Script to Generate C++ operator<< - Extraction
Operator for cout in Source Code File
//Operator<< extraction for cout NO_OUTPUT_BEGIN
//Change C array to C++ collection for 1:M data members NO_OUTPUT_END
ostream& operator<< (ostream& os, const CLASS_NAME$& a$CLASS_NAME)
{ int i = 0;
[ os << (BASE_CLASS &) a$CLASS_NAME;]
os << "Object Attribute Values - Class CLASS_NAME" << endl;
SELECT_WHEN ATTRIBUTE_IS_NORMAL [ os << "ATTRIBUTE_NAME: " << a$CLASS_NAME$.$ATTRIBUTE_NAME << endl;]
SELECT_WHEN ATTRIBUTE_IS_CONSTANT [ os << "ATTRIBUTE_NAME: " << a$CLASS_NAME$.$ATTRIBUTE_NAME << endl;]
SELECT_WHEN ATTRIBUTE_IS_STATIC [ os << "ATTRIBUTE_NAME: " << a$CLASS_NAME$.$ATTRIBUTE_NAME << endl;]
[ os << " AGGREGATION_ONE_NAME$: " << a$CLASS_NAME$.$AGGREGATION_ONE_NAME << endl;]
[ if (a$CLASS_NAME$.$ASSOCIATION_ONE_NAME != &a$CLASS_NAME$.null$ASSOCIATION_ONE_CLASS) os << " ASSOCIATION_ONE_NAME$: " << *$a$CLASS_NAME$.$ASSOCIATION_ONE_NAME << endl;
[ for (i = 0; i < maxNumberOf$AGGREGATION_MANY_CLASS$s; i++) os << " AGGREGATION_MANY_NAME$: " << a$CLASS_NAME$.$AGGREGATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] << endl; ]
[ for (i = 0; i < maxNumberOf$ASSOCIATION_MANY_CLASS$s; i++)
{ if ( a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] != &a$CLASS_NAME$.null$ASSOCIATION_MANY_CLASS) os << " ASSOCIATION_MANY_NAME$: " << *a$CLASS_NAME$.$ASSOCIATION_MANY_NAME LITERAL_SYMBOL[i LITERAL_SYMBOL] << endl;
} ]
return os;
}
Generated C++ operator<< - Extraction Operator for
cout in Car Class Declaration in the Header File for Car Class
//Operator<< for cout
friend ostream& operator<< (ostream& os, const
CLASS_NAME$& a$CLASS_NAME);
Generated C++ operator<< - Extraction Operator for
cout in Source Code File
//Operator<< extraction for cout
ostream& operator<< (ostream& os, const Car& aCar)
{ int i = 0;
os << (Vehicle &) aCar;
os << "Object Attribute Values - Class Car" << endl;
os << "speed: " << aCar.speed << endl;
os << "gasQuantity: " << aCar.gasQuantity << endl;
os << "minimumGasQuantity: " << aCar.minimumGasQuantity << endl;
os << "totalCarsBuilt: " << aCar.totalCarsBuilt << endl;
os << " currentMotor: " << aCar.currentMotor << endl;
if (aCar.currentCellularPhone != &aCar.nullCellularPhone) os << " currentCellularPhone: " << *aCar.currentCellularPhone << endl;
for (i = 0; i < maxNumberOfTires; i++) os << " currentTires: " << aCar.currentTires [i ] << endl;
for (i = 0; i < maxNumberOfPassengers; i++)
{ if ( aCar.currentPassengers [i ] != &aCar.nullPassenger) os << " currentPassengers: " << *aCar.currentPassengers [i ] << endl;
}
return os;
}
The purpose of this chapter was to present how to create scripts for C++ code generation from class diagrams.