The IDL specification for a class of objects must contain a declaration
of the interface these objects will support. Because, in SOM, objects
are implemented using classes, the interface name is always used as a class
name as well. Therefore, an interface declaration can be understood to specify
a class name, and its parent (direct base) class names. This is the approach
used in the following description of an interface declaration. In addition
to the class name and its parents names, an interface indicates new methods
(operations), and any constants, type definitions, and exception structures
that the interface exports. An interface declaration has the following syntax:
interface class-name [: parent-class1, parent-class2, ...]
{
constant declarations (optional)
type declarations (optional)
exception declarations (optional)
attribute declarations (optional)
method declarations (optional)
implementation statement (optional)
};
Many class implementers distinguish a "class-name" by using an initial capital letter, but that is optional. The "parent-class" (or base-class) names specify the interfaces from which the interface of "class-name" instances is derived. Parent-class names are required only for the immediate parent(s). Each parent class must have its own IDL specification (which must be #included in the subclass's .idl file). A parent class cannot be named more than once in the interface statement header.
Note: In general, an "interface class-name" header must precede any subsequent implementation that references "class-name." For more discussion of multiple interface statements, refer to the later topic "Module declarations to define multiple interfaces in an .idl file."
The following topics describe the various declarations/statements that can be specified within the body of an interface declaration. The order in which these declarations are specified is usually optional, and declarations of different kinds can be intermixed. Although all of the declarations/statements are listed above as "optional," in some cases using one of them may mandate another. For example, if a method raises an exception, the exception structure must be defined beforehand. In general, types, constants, and exceptions, as well as interface declarations, must be defined before they are referenced, as in C/C++.