Overview

The ROSE C++ library provides core data services for applications built around STEP product models, Industry Foundation Classes (IFC), Cimsteel (CIS/2), or other EXPRESS-based standards. It uses these EXPRESS schemas to create and manage data objects as C++ classes or by EXPRESS data dictionary. The library can read and write the objects as STEP physical files, and has advanced search and traversal features such as USEDIN.

On top of this are built our libraries for CAD math, STEP, IFC, and Digital Twin applications

C++ Class Overview

The ROSE library provides data classes that hold an EXPRESS-defined object in memory. The library defines the base classes for these, and an EXPRESS compiler can generate subclasses for each definition in the STEP, IFC, or other EXPRESS schema.

For example, you would manipulate an EXPRESS Point ENTITY using a C++ class Point. The full range of EXPRESS definitions are supported. Applications can be written with generated C++ classes or by using EXPRESS data dictionary calls. The RoseDesign class holds all of the data objects in a STEP physical file.

The EXPRESS Data Object classes are as follows. These are the superclasses used by generated C++ classes:

• RoseObject
  • RoseStructure (for ENTITY defs)
    • RoseAttribute
    • RoseDesign
    • RoseDictionary
    • RoseDomain
    • RoseReference
  • RoseUnion (for SELECT defs)
  • RoseAggregate (for LIST, SET, BAG defs)
    • RoseList
    • RoseBag
    • RoseSet
    • RoseArray

The ROSE library also provides support classes to traverse, manipulate, and manage the data objects. For example, RoseInterface is a singleton that collects support library state functions into one place, and RoseCursor finds all of the objects of a given type in a file.

The ROSE Support Classes are as follows:

• RoseInterface

• RoseBackptrCursor
• RoseBackptrs
• RoseBinaryObject
• RoseCursor
  • RoseTypesCursor
• RoseDesignSection
• RoseErrorContext
• RoseErrorReporter
• RoseErrorStats
• RoseManager
• RoseP21Lex
• RoseP21Parser
• RoseP21Writer
• RoseRefUsage
• RoseServer
• RoseType

Font Conventions

Within the body of a paragraph, functions, keywords, and filenames are shown in bold, such as librose.a or /usr/local/bin. Function names are shown with trailing parenthesis, such as findDomain() or name(). When referring to a C++ member function in another class, the C++ scope notation is used, such as RoseDesign::save() or RoseObject::domain().

Function prototypes are listed with each parameter on a separate line and the function name set off in bold as shown below. Optional parameters are listed in standard C++ notation showing the default value.

RoseAggregate * findObjects(
	RoseAggregate * list_to_fill,
	RoseDesign* design = <Current>
	);

Occasionally, functions must be described in a parameterized manner, with angle brackets indicating the parameterized portion of the function definition. For example, the following prototype is used for the RoseObject getInteger(), getString(), getObject(), etc. functions:

<type_ref> get<name>(
	RoseAttribute * att
	);

Finally, programming examples are shown in a separate paragraph, in a typewriter-style font:

/* Create a point using the default constructor
 *  and use the update functions to set its values.
 */
RoseDesign * d;
Point * point1 = pnewIn(d) Point;
point1->x (1.0);
point1->y (0.0);

/* Create points using a different constructor,
 *  that fills in the values in one step. */
Point * point2 = pnewIn(d) Point (2.5, 4.0);
Point * point3 = pnewIn(d) Point (5.0, 0.0);