    Guidelines for Generating C++ Using With Class 1.6

These guidelines present the "how to" steps to
generate C++ code using the With Class CASE (computer aided
software engineering) tool. The current With Class Version 1.6 
generates either ANSI C++ compilable code,  Borland C++ Version 3.1 
with OWL 1.0 compilable code, Borland C++ 4.0 with OWL 2.0, or 
Visual C++ 1.5 with MFC 2.5 compilable code.  Guidelines will be 
presented.

    *** Generating ANSI C++ Using With Class ***

Using With Class, you first create a class diagram showing the
classes, attributes, operations, and relationships.   You fill in
specification forms (dialog boxes) to add additional information
about each class, attribute, operation, and relationship.   With
Class generates the following ANSI C++ compilable code from a
class diagram:
- #ifdefs,
- #includes,
- default constructor,
- constructor with arguments,
- copy constructor, 
- default destructor,
- operator= (assignment operator),
- operator== (equality operator),
- get and set functions for data members,
- pointer data member for 1 to 1 and 1 to many associations using
C array,
- data member for 1 to 1 and 1 to many aggregations using C
array,
- inheritance relationships.

With Class generates the following C++ for the C++ iostreams:
- operator<< insertion operator for cout statements, 
- operator>> extraction operator for cin statements.
These operators may be used in Borland C++ 3.1, Borland C++ 4.0
(EasyWin), and Visual C++ under the QuickWin project option.

With Class generates streamable classes for persistence for
both Borland C++ and Visual C++.

If specified by the user, With Class generates the following:
#include statements for external files (library files), initial
data member values in constructors, virtual functions, pure
virtual functions, static functions, and const functions.   A
user must manually insert the following keywords: static for data
members and friend for functions.   

General Steps to Generate C++ Code Using With Class

>> Run With Class from Windows
>> Select "File - Open", e.g., c:\car\car.omt
>> Select "Generate - Options" and select C++ code generation
options  
>> Select "Generate - Generate Code"
>> Select "File - Edit File" and select a ".h" or ".cpp" file for
review

Note - to ensure the generated .h and .cpp files are placed in
the correct directory you may need to select "File - Edit File"
and select the desired directory.

Key Points Generating ANSI C++ Using With Class 

To generate ANSI C++ using With Class do the following in the
"Generate - Options"
>> Select  "iostream << to display classes" - this uses
iostream.h,
>> Select "Many Relations Options - C Array"
>> Do not select "C++ Collection Template" since it uses a
Borland C++ or Visual C++ class library,
>> Do not select "Make All Classes Streamable" since it uses a
Borland C++ or Visual C++ class library.
>> Do not select CLASSDEF macro since it uses a Borland C++ macro

     ***Generating Borland C++ 3.1 Code Using With Class ***

Steps to Compile the C++ Source Files in Borland C++ 3.1

>> Run Borland C++ (BCW) from Windows
>> Select "Project - Open Project"
>> Enter a project file name, e.g., carproj.prj
>> Select "Project - Add Item"
>> In the Directories Box, change the directory where the C++
files are located, e.g., Car Directory
>> Enter *.cpp in the File Name Box
>> Select the .cpp files, e.g., main.cpp and car.cpp and click on
the "Add Button" to add each file to the project
>> Select "Done"
>> Select "Options - Directories" to update the Include
Directories List
>> In the Include Directories Box, add the directory where the
C++ files are located, e.g., c:\car
>> Select "OK"
>> Select "Compile - Compile" to compile the C++ source code
>> Select "Run - Run" to compile, link, and execute

Sample Settings for Borland C++ 3.1 Options for Generated C++
Code

>> In Borland C++ 3.1 select "Options" to set the following:
Application: Large Memory Model
Linker Link Libraries: Static for all libraries
Include Directories: c:\bc\include;
c:\bc\owl\include;c:\bc\classlib\include; 
Library Directories: c:\bc\lib; c:\bc\owl\lib;
c:\bc\classlib\lib;
Compiler - Code Generation - Defines    WIN31

Steps to Create a Main Function and Execute the Program in
Borland C++ 3.1

To execute the C++ source code with messages, you must create the
main function with an object declaration and messages to the 
object.  
>> Select "File - Open" 
>> Select the main function, e.g., c:\car\main.cpp
>> Enter the C++ statements for the main, e.g., statements shown
below
>> Select "File - Save" 
>> Select "Compile - Compile" to compile the main function
>> Select "Run - Run" to compile, link, and execute the program

#include "car.h"              //Added code to use generated C++
main ()
{
     Car car11;                              //object declaration
     car11.setGasQty (10.0);                 //function call
     car11.start ();                              //function call
     int aGasQty = car11.getGasQty ();            //function call
     return (0);
}
 

Steps to Create Windows Applications in Borland C++ 3.1 with OWL
1.0 and With Class

The following are the general steps to create a windows
application with OWL 1.0 classes.   These steps show a very
simple car program.  A car has a single attribute "int speed" and
a single operation "int getSpeed ()".   

>> In With Class, generate C++ for Borland C++ 3.1, e.g. Car.h
and Car.cpp in the desired directory as follows: select #ifdefs,
select Get Methods, select Set Methods, select Copy Constructor
and Assignment Operator, select Make All Classes Streamable,
select C++ Collection Template, select Borland 3.1.
Note: Do not select "ostream << to Display Classes" (uses
iostream.h)
>> In Borland C++ 3.1 , create a new application by selecting
"Project - Open" 
>> Run the Resource Workshop to create the car.rc resource file
with a menu item for Open, Save, and GetSpeed, e.g.
     CARMENU
     BEGIN
	  POPUP "Car"
	  BEGIN
	       MENUITEM "Open", 101
	       MENUITEM "Save", 102
	       MENUITEM "GetSpeed", 103
	  END
     END
>> In Borland C++ 3.1, create a CarWindow class declaration (.h
file) with an event handler function for "Open", "Save", and
"GetSpeed"; an #include "Car.h"; and an object declaration Car
car1, e.g.
     #include "Car.h"
     class CarWindow : public TWindow {
       Car car1;
     Public:
       virtual void getSpeed (RTMessage Msg) = [CM_FIRST + 103];
     }
>> Create the open, save, and getSpeed function definitions in
the CarWindow class.  These functions will invoke Car functions
>>, <<, and getSpeed.
>> Create the CarApp and WinMain functions as described in the
Borland C++ 3.1 "ObjectWindows for C++ User's Guide"
>> Compile, link, and execute the program

Key Points Concerning Borland C++ 3.1 and With Class

The following are key class library classes, a sample object
declaration, and their include files:
String class: String aString; #include <strng.h>
     Note: Example for cin: String string1; char tempString[80];
     cin >> tempString; string1 = tempString;
List class: BI_ListImp <Car> aList; #include<listimp.h>
Sorted list class: BI_SListImp<Car> aSortedList; 
     #include <listimp.h>
     Note: Car class must have operator< for comparison
     and the function int isSortable () {return 1;}.
Array class: BI_ArrayAsVector <Car> anArrayOfCars; 
     #include <arrays.h>
     Note: all constructors must set the array limit, e.g
     Garage () : anArrayOfCars (10) {..},
     Garage (int size) : anArrayOfCars (10) {..},
     Garage (const Garage& aGarage) : anArrayOfCars (10) {..} 
Sorted Array class: BI_SArrayAsVector <Car> aSortedArray;
     #include <arrays.h>
     Note: Car class must have operator< for comparison
     and the function int isSortable () {return 1;}.
     All constructors must set the array limit, e.g
     Garage () : aSortedArray (10) {..}, 
     Garage (int size) : aSortedArray (10) {..},
     Garage (const Garage& aGarage) : aSortedArray (10) {..} 
Stack class: BI_StackAsVector <Car> aStack; #include<stacks.h>
Bag class: BI_BagAsVector <Car> aBag; #include<bags.h>

In With Class select "Generate - Options" and "ostream << to
display classes" for all programs except Windows programs that
use WinMain function.   The following is a sample use of cin and
cout:  Car car1; cin >> car1; cout << car1;

    ***Generating Borland C++ 4.0 Code Using With Class ***

Steps to Compile the C++ Source Files in Borland C++ 4.0 with
EasyWin

>> Run Borland C++ 4.0 from Windows
>> Select "Project - New Project"
>> Enter a project path and file name, e.g., c:\car\carproj.prj
>> In the Project Window, select the (.EXE) file, hold down the
right mouse button, select "add node", and enter the .cpp files
(e.g. main.cpp and car.cpp)
>> If required, select "Options - Directories" to update the
Include Directories List
>> If required, in the Include Directories Box, add the directory
where the C++ files are located, e.g., c:\car
>> Select "Project - Compile" to compile the C++ source code
>> Select "Project - Build All" to create a .EXE file
>> Select "Debug - Run" to execute the .EXE file

Steps to Create Applications in Borland C++ 4.0 with OWL 2.0
Document/View Architecture (AppExpert and ClassExpert)

The following are the general steps to create a windows
application with the OWL 2.0 document/view architecture.   These
steps show a very simple car program.  A car has a single
attribute "int speed" and a single operation "int getSpeed ()".  

>> In With Class, generate C++ for Borland C++ 4.0, e.g. Car.h
and Car.cpp in the desired directory as follows: select #ifdefs,
select Get Methods, select Set Methods, select Copy Constructor
and Assignment Operator, select Make All Classes Streamable,
select C++ Collection Template, select Visual C++.
Note: Do not select  "ostream << to Display Classes" (uses
iostream.h)
>> In Borland C++, create a new application by selecting "Project
- AppExpert" and generate the starter classes (CarApp), resource
file (CarApp.rc) and the .def file
>> Run the Resource Workshop to update the CarApp.rc resource
file with a menu item for getSpeed
>> In Borland C++ with ClassExpert, create the CarDoc and CarView
classes, create an event handler for the getSpeed event, update
the open and save event handlers to invoke the Car functions <<
and >>.
>> Compile, link, and run the program.

Key Points Concerning Borland C++ 4.0 and With Class

The following are key class library classes, a sample object
declaration, and their include files:
String class: string aString; #include <cstring.h>
List class: TList<Car> aList; #include<classlib\listimp.h>
Sorted list class: TSListImp<Car> aSortedList; 
     #include <classlib\listimp.h>
     Note: Car class must have operator< for comparison
     and the function int isSortable () {return 1;}.
Array class: TArray<Car> anArrayOfCars (10); 
     #include <classlib\arrays.h>
     Note: all constructors must set the array limit, e.g
     Garage () : anArrayOfCars (10) {..},
     Garage (int size) : anArrayOfCars (10) {..},
     Garage (const Garage& aGarage) : anArrayOfCars (10) {..} 
Sorted Array class: TSArray <Car> aSortedArray (10); 
     #include <classlib\arrays.h>
     Note: Car class must have operator< for comparison
     and the function int isSortable () {return 1;}.
     All constructors must set the array limit, e.g
     Garage () : aSortedArray (10) {..}, 
     Garage (int size) : aSortedArray (10) {..},
     Garage (const Garage& aGarage) : aSortedArray (10) {..} 
Stack class: TStack <Car> aStack; #include<classlib\stacks.h>
Bag class: TBag <Car> aBag; #include<classlib\bags.h>

The following are several ways to create projects in Borland C++
4.0.
EasyWin:  Simplest type of project.  Use main function.  In BC4
select "Project - Standard Library - Class Library".   In With
Class "Generate Options" select "ostream << to display classes"
to use << and >> for cin and cout statements.
Application (.EXE): Use OwlMain function.  In With Class do not
select "Generate Options" select "ostream << to display classes".
You cannot use << and >> for cin and cout statements.  For
streamable classes, select "Generate Options" and select "make
classes streamable".  With Class generates C++ based upon the
C:\BC4\EXAMPLES\CLASSLIB\PSTREAM. PSTREAM2.CPP example.
Windows Application (.EXE) with Document View architecture:
This uses the AppExpert and ClassExpert as presented above.

    ***Generating Microsoft Visual C++ 1.5 Code Using With Class ***

Steps to Compile the C++ Source Files in Microsoft Visual C++ 1.5
with QuickWin

>> Run Visual C++ from Windows
>> Select "Project - New Project"
>> Enter a project file name, e.g., carproj.prj
>> Select the Project Type - QuickWin Application (.EXE)
>> Select "Use Microsoft Foundation Classes"
>> Select "Project - Edit" to add all .cpp files to the project
(e.g. main.cpp and car.cpp)
>> Select "Options - Project - Link - Miscellaneous" and enter
/NOE
>> Select "Options - Project - Link - Window Library" and select
COMMDLG and SHELL
>> Copy stdafx.h and stdafx.cpp into the directory for QuickWin
>> #include "stdafx.h" in your main.cpp file
>> Select "Project - Compile" to compile the C++ source code
>> Select "Project - Build All" to create the .EXE file
>> Select "Project - Run" to execute the .EXE file

Sample STDAFX files for use in QuickWin

// stdafx.h : include file for standard system include files,
//  or project specific include files that are used frequently, but
//              are changed infrequently
//
#include <afxwin.h>             // MFC core and standard components
#include <afxext.h>             // MFC extensions (including VB)

// stdafx.cpp : source file that includes just the standard includes
//      stdafx.pch will be the pre-compiled header
//      stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"

Key Points Concerning Microsoft Visual C++ 1.5 With Class
The following are key class library classes, a sample object
declaration, and their include files:
String class: CString aString; #include "stdafx.h" or "afx.h"
List class: CObList aList; #include "stdafx.h"
     or #include <afxcoll.h>
Array class: CObArray anArray; #include "stdafx.h" 
     or #include <afxcoll.h>
Stack class: CObList aStack; #include "stdafx.h" 
     or #include <afxcoll.h>
     Note: add and remove items from head
Queue class: CObList aQueue; #include "stdafx.h" 
     or #include <afxcoll.h>
     Note: add to tail and remove from head
Map or Dictionary: CMapStringToOb aMap; #include "stdafx.h" or
#include <afxcoll.h>  Note add items, e.g. aMap [bill] =
&aPerson;

The following are several ways to create projects in Microsoft
Visual C++ 1.5:
QuickWin:  Simplest type of project.  Use main function.  In
Visual C++ select Options - Project - Link - Miscellaneous" and
enter /NOE.  In Visual C++ select "Options - Project - Link -
Window Library" and select COMMDLG and SHELL.   In With Class
"Generate Options" select "ostream << to display classes" to use
<< and >> for cin and cout statements.
Application (.EXE): Use WinMain function.  In With Class do not
select "Generate -Options - ostream << to display classes".   You
cannot use << and >> for cin and cout statements.  For streamable
classes, select "Generate Options" and select "make classes
streamable".   With Class generates C++ for the serialize
function in each class.
Windows Application (.EXE) with Document View architecture:
This uses the AppWizard and ClassWizard as presented below.  

Steps to Create Applications in Microsoft Visual C++ 1.5 with MFC
2.5 Document/View Architecture (AppWizard and ClassWizard)

The following are the general steps to create an application with
the MFC 2.5 document/view architecture.   These steps show a very
simple car program.  A car has a single attribute "int speed" and
a single operation "int getSpeed ()".   

>> In With Class, generate C++ for Visual C++, e.g. CCar.h and
CCar.cpp in the desired directory as follows: select #ifdefs,
select Get Methods, select Set Methods, select Copy Constructor
and Assignment Operator, select Make All Classes Streamable,
select C++ Collection Template, select Visual C++.
Note: Do not select CLASSDEF Macro (Borland only) or ostream <<
to Display Classes (uses iostream.h)
>> In Visual C++, create a new application by selecting "Project
- AppWizard" and generate the starter classes, e.g. CCarApp,
CCarDoc, CCarView, and CMainFrame and generate the resource file,
e.g. Car.rc
>> Select "Project - Edit" to add the With Class generated
classes, e.g. Car.cpp
>> Update the CCarDoc.h file as follows:
     - #include at least one With Class generated .h files, e.g.
       #include "CCar.h"
     - declare at least one object, e.g. Car car1;
     - declare a function to invoke user defined functions, e.g.
     int getSpeed ();
>> Update the CCarDoc.cpp file as follows:
     - update the constructors, e.g. CCarDoc () : car1 () {..}
     - create the function body for user defined functions, e.g.
	  int CCarDoc::getSpeed () { return car1.getSpeed (); }
     - update the Serialize function, e.g.
	  void CCarDoc::Serialize (CArchive& ar)
	  {  if (ar.IsStoring() ) {ar << &car1; }
	      else {CObject *pObject = &car1; ar >> pObject; }
	  }
>> Select "Tools - AppStudio" to add a menu command, e.g.
GetSpeed and update the Car.rc resource file
>> Select "Browse - ClassWizard" to create a command handler
function, e.g. OnEditGetSpeed () in the CCarView class
>> Update the command handler function to invoke the Car
function, e.g.
	  void CCarView::OnEditGetSpeed ()
	  { CCarDoc* pDoc = GetDocument ();
	     int aSpeed = pDoc->getSpeed ();
	     char tempString[80];
	     itoa (aSpeed, tempString, 10);
	     AfxMessageBox (tempString); }
>> Select "Project - Execute" to compile, link, and execute the
program.   

   ***Modeling Persistent Objects Using With Class***

A persistent object retains its values when the program is not
running, e.g., the system is not active.  The three primary ways
to create persistent objects are with flat file storage,
relational data base management system storage, or object
oriented data base storage.   With Class generates C++ streamable
classes for persistent objects with the following steps: 

>>  Select "Make All Classes Streamable", "Get Methods", and Set
Methods" from the Options Menu.

>>  Select "Generate Code" from the Generate Menu.

>>  Update the generated code as follows:

     Create a stream object, e.g. inputStream or outputStream.

     Open the stream object, e.g. inputStream.open ("CAR.STM").

     Read from or write to the stream object, e.g.
     inputStream >> car1 or outputStream << car1.

     Close the stream object, e.g. inputStream.close ().

As an example, a class diagram was created with a single class
Car with the data member "float gasQuantity".   With Class
automatically generated the get and set functions:
"getGasQuantity" and "setGasQuantity".  The following main
function shows how to create, open, read from,  write to, and
close a C++ a file stream.   In this example, the car1 object was
written to and read from a C++ file stream for persistent storage
for Borland C++ 3.1.

#include "car.h"         //Added code to use generated C++
#include <iostream.h>

int main ()
{
     Car car1;                     
     car1.setGasQuantity (20.0);
     ofpstream outputStream;            //Creates file stream
     outputStream.open ("CAR.STM");
				   //Opens file stream
     if (outputStream.bad () )
	  cout << "Could not open file/n";
     outputStream << car1;              //Writes to file stream
     outputStream.close ();             //Closes file stream
     Car car2;
     ifpstream inputStream;             //Creates file stream
     inputStream.open ("CAR.STM");      //Opens file stream
     if (inputStream.bad())
	  cout << "Could not open file/n";
     inputStream >> car2;               //Reads from file stream
     cout << car1.getGasQuantity ();
     cout << car2.getGasQuantity ();
     inputStream.close();                    //Closes file stream
     return 0;
}

For Borland C++ 4.0 streamable classes derived from
TStreamableBase are generated.  See the example in
C:\BC4\EXAMPLES\CLASSLIB\PSTREAM.PSTREAM2.CPP. The
following is a code fragment to read and write a
streamable car object. Suggestions on how to effectively  
use Borland C++ 4.0 streamable objects are solicited.

---code fragment to read and write an object in BC4------
#include <iostream.h>
#include <classlib\objstrm.h>
#include "car.h"

void writeToFile (Car& aCar)
{
  ofpstream outputStream;
  outputStream.open ("test.dat");
  if (outputStream.bad () )
	 { cout << "Error - could not open file." << "\n" ;
		exit (0);
	 }
  outputStream << &aCar;
  outputStream.close();
}
void readFromFile (Car* pCar)
{
  ifpstream inputStream;
  inputStream.open ("test.dat");
  if (inputStream.bad () )
	 { cout << "Error - could not open file." << "\n";
		exit (0);
	 }
  inputStream >> pCar;
  inputStream.close();
}       
int main ()
{
  Car car1;
  writeToFile (car1);
  Car* pCar = 0;
  readFromFile (pCar);
}

For Microsoft Visual C++ 1.5, serialized classes derived from CObject
are generated.  See examples in Chapter 14  "Files and
Serialization" of the Class Library User's Guide in Microsoft
Visual C++ "Programmer's Guides".   As shown in the code fragment
below, With Class provides the some of the necessary casts, e.g.
(WORD &) anInt and (BYTE &) aChar.  You must manually cast BOOL,
short, and enumerated types.

-----------------------------car.h code fragment------------------
class  Car : public Vehicle
{
	Motor *aMotor;
	int gasQty;
	float aFloat;
	char aChar;
	double aDouble;
	CString aString;
	long aLong;
	BOOL aBoolean;
	short aShort;
public:
       //functions
};
---------------------------car.cpp code fragment-------------------
#include "stdafx.h"
#include "Car.h"
IMPLEMENT_SERIAL(Car, CObject, 1)

void Car::Serialize(CArchive& ar)
 {      if (ar.IsLoading())
	 {
	  Vehicle::Serialize(ar);

	  ar >> (WORD &)gasQty;
	  ar >> aFloat;
	  ar >> (BYTE &)aChar;
	  ar >> aDouble;
	  ar >> aString;
	  ar >> (LONG &)aLong;
	  ar >> (WORD &)aBoolean;            //Cast added
	  ar >> (WORD &)aShort;              //Cast added
	 }
	else
	 {
	  Vehicle::Serialize(ar);
	  ar << (WORD)gasQty;
	  ar << aFloat;
	  ar << (BYTE)aChar;
	  ar << aDouble;
	  ar << aString;
	  ar << (LONG)aLong;
	  ar << (WORD)aBoolean;                 //Cast added
	  ar << (WORD)aShort;                   //Cast added
	 }
 };

   *** Miscellaneous Guidelines ***

Guidelines for Selecting Generate Options

1.  Select defaults for new users.  Turn off defaults to see the
minimum C++ code to be generated by With Class.

2.  Select #ifdefs for projects with shared files.  With Class
generates the compiler directives #ifndef, #define, #include, and
#endif to avoid "multiple declaration errors".  

3.  Select Get Method and Set Method to generate get and set
accessor functions for attributes (data members), e.g.
setGasQuantity (15.0).  Accessor functions are used in place of
assignment statements, e.g. gasQuantity = 15.0.  Note: accessor
functions also allow you to access
aggregation and association related attributes.

4.  Select "Copy Constructor and Assignment Operator" to generate
the following:
- copy constructor to create an object with a copy of another
object, e.g. Car car1 (car2).
- operator= assignment operator to assign one object with another object,
e.g. car1 = car2.
- operator== is equal operator to compare two objects, e.g. if (car1 ==
car2) .

5.  Select "Make All Classes Streamable" to generate streamable
C++ classes for persistent storage with C++ file streams.

Guidelines for C++ Compiler Directives

With Class automatically generates the following C++ compiler
directives from the class diagram and class specification:
#ifndef, #define, #include, #endif.  These avoid "multiple
declaration errors".  If you add files to your C++ project after
code generation you must enter the compiler directives in the
source code.  The following is an example of the added compiler
directives for a types.h file that was added in the Borland C++
3.1 environment.

The types.h file appears as follows:

#ifndef __TYPES_H
#define __TYPES_H
#endif

The following compiler directives were added to each header file
that required access to the types. h file:

#ifndef __TYPES_H
#include "types.h"
#endif

Known Problems:
1.  Prefix T Option:  If you use the "Insert the
prefix T" option you must manually update your code.   With Class
changes the file name, constructor name, and destructor name.  You
must manually update the class name that appear in your code.  If 
you desire the have a prefix, e.g. T or C, then you should enter
the prefix directly on the class diagram.

2.  Abstract Base Classes:  If you create abstract base 
classes (a common base class - superclass) in multiple inheritance,
you must remove any duplicate declarations.  An abstract base
class appears at the top of a diamond of classes.

3.  Borland C++ 4.0 Streamable Classes - Testing in progress.
Recommendations and sample test programs are solicited.

With Class Info - With Class is available in a
shareware and professional versions from MicroGold Software 696
Birch Hill Drive, Bridgewater, NJ, 08807 telephone 908-722-6438 -
CompuServe 71543,1172.   On CompuServe, you may find With Class in 
the Borland Forum - Borland C++ for Windows - Non Tech Cust Service
with the file name wclass16.zip.   On the Internet, With Class is
available at oak.oakland.edu in the pub\msdos\windows3 directory
with the file name wclass16.zip. 

Guidelines provided by Richard Felsinger, RCF Associates, 960
Scottland Dr, Mt Pleasant, SC 29464  803-881-3648 (voice & fax)
E-mail 71162.755@compuserve.com  8/31/94.  RCF Associates
provides consulting and training services in object-oriented
analysis, design, and programming in C++, Eiffel, and other
languages.  Comments and suggestions on these guidelines are solicited.
