4. IDL模块
4.1
接口简介
OA&D工具定义了下列接口模块：
粗纹（Coarse-Grained）接口：
OAD_Stream
OAD_CoarseGrainFacility
细纹（Fine-Grained）接口：
Behavior_Elements
Core_Concepts
OA&D_Facility
Structural_Elements
View_Elements
这些接口对应于UML元模型中的包。
4.2 粗纹接口
4.2.1 OAD_Stream模块
module OAD_Stream {
interface OAD_Stream : CosExternalization::Stream {}
interface OAD_StreamFactory : CosExternalization::StreamFactory {}
interface OAD_StreamFileFactory : CosExternalization::StreamFileFactory {}
interface OAD_Streamable : CosStream::Streamable {}
interface OAD_StreamableFactory : CosStream::StreamableFactory {}
interface OAD_StreamIO : CosStream::StreamIO {}
};
4.2.2 OAD_CoarseGrainFacility
模块
module OAD_CoarseGrainFacility {
typedef string Name; // should this be IString?
typedef Collection ModelCollection;
typedef Collection PackageCollection;
typedef Collection DiagramCollection;
interface System;
interface Model;
interface Package;
interface Diagram;
interface System : OAD_Streamable
{
attribute Name name;
attribute ModelCollection models;
Model add_Model();
void remove_Model(in Model theObject);
};
interface SystemFactory {
System create();
System create(in Name theName);
}
interface Model : OAD_Streamable
{
attribute Name name;
attribute PackageCollection packages;
attribute DiagramCollection diagrams;
Package add_Package();
void remove_Package(in Package theObject);
Diagram add_Diagram();
void remove_Diagram(in Diagram theObject);
};
interface ModelFactory {
Model create();
Model create(in Name theName);
}
interface Package : OAD_Streamable
{
attribute Name name;
attribute Model model;
attribute DiagramCollection diagrams;
Diagram add_Diagram();
void remove_Diagram(in Diagram theObject);
};
interface PackageFactory {
Package create();
Package create(in Name theName);
}
interface Diagram : OAD_Streamable
{
attribute Name name;
};
interface DiagramFactory {
Diagram create();
Diagram create(in Name theName);
}
};
4.3
细纹接口
4.3.1 Behavioral_Elements
模块
#include <CosLifeCycle.idl>
#include <Core_Concepts.idl>
// =======================================================
module Behavioral_Elements {
interface ActualArgument;
interface CompositeState;
interface Vertex;
interface Connector;
interface Interaction;
interface Action;
interface Transition;
interface Event;
interface Link;
interface LinkRole;
interface ActionExpression;
interface StateMachine;
interface TimeExpression;
interface Behavior;
interface Message;
interface ActionState;
interface BooleanExpression;
interface State;
typedef Collection ActualArgumentCollection;
typedef Collection CompositeStateCollection;
typedef Collection VertexCollection;
typedef Collection ConnectorCollection;
typedef Collection InteractionCollection;
typedef Collection ActionCollection;
typedef Collection TransitionCollection;
typedef Collection EventCollection;
typedef Collection LinkCollection;
typedef Collection LinkRoleCollection;
typedef Collection ActionExpressionCollection;
typedef Collection StateMachineCollection;
typedef Collection TimeExpressionCollection;
typedef Collection BehaviorCollection;
typedef Collection MessageCollection;
typedef Collection ActionStateCollection;
typedef Collection BooleanExpressionCollection;
typedef Collection StateCollection;
enum ConnectorKind {
initial, final, history
};
interface ActualArgument: CosLifeCycle::LifeCycleObject {
attribute {target,_parameter,_participant} value;
attribute Action Action_reference;
attribute Instance Instance_reference;
};
interface ActualArgumentFactory {
ActualArgument create();
};
interface CompositeState: State {
attribute Core_Concepts::Boolean isConcurrent;
attribute Core_Concepts::Boolean hasHistory;
attribute VertexCollection substate;
Vertex add_Vertex();
void remove_Vertex(in Vertex theObject);
};
interface CompositeStateFactory {
CompositeState create();
};
interface Vertex: Core_Concepts::ModelElement {
attribute StateMachine vertices;
attribute CompositeState substate;
attribute TransitionCollection source;
attribute TransitionCollection target;
};
interface VertexFactory {
Vertex create();
};
interface Connector: Vertex {
attribute ConnectorKind kind;
};
interface ConnectorFactory {
Connector create();
};
interface Interaction: Behavior {
attribute LinkCollection links;
attribute Structural_Elements::InstanceCollection instances;
Link add_Link();
void remove_Link(in Link theObject);
Instance add_Instance();
void remove_Instance(in Instance theObject);
};
interface InteractionFactory {
Interaction create();
};
interface Action: Core_Concepts::ModelElement {
attribute Message action;
attribute Structural_Elements::Activity activity;
Activity add_Activity();
void remove_Activity(in Activity theObject);
ActualArgumentCollection get_actual_argument();
Instance add_Instance();
void remove_Instance(in Instance theObject);
};
interface ActionFactory {
Action create();
};
interface Transition: Core_Concepts::Relationship {
attribute BooleanExpression guard;
attribute StateMachine transitions;
attribute Event trigger;
attribute ActionExpression effect;
attribute VertexCollection source;
attribute VertexCollection target;
attribute State internal_transition;
Core_Concepts::Name label;
Event add_Event();
void remove_Event(in Event theObject);
ActionExpression add_ActionExpression();
void remove_ActionExpression(in ActionExpression theObject);
Name add_Name();
void remove_Name(in Name theObject);
};
interface TransitionFactory {
Transition create();
};
interface Event: CosLifeCycle::LifeCycleObject {
attribute TransitionCollection trigger;
};
interface EventFactory {
Event create();
};
interface Link: Core_Concepts::Relationship {
attribute Core_Concepts::Boolean isCreated;
attribute Core_Concepts::Boolean isDestroyed;
attribute Interaction links;
attribute sequence<LinkRole,2> link_roles;
attribute Structural_Elements::Association link_instance;
LinkRole add_LinkRole();
void remove_LinkRole(in LinkRole theObject);
};
interface LinkFactory {
Link create();
};
interface LinkRole: Core_Concepts::ModelElement {
attribute Link link_roles;
attribute Structural_Elements::ValueCollection qualification;
attribute Structural_Elements::AssociationRole role_instance;
attribute MessageCollection messages;
attribute Structural_Elements::Instance player;
Value add_Value();
void remove_Value(in Value theObject);
Message add_Message();
void remove_Message(in Message theObject);
};
interface LinkRoleFactory {
LinkRole create();
};
interface ActionExpression: Core_Concepts::Expression {
attribute Transition effect;
ActionCollection referencedActions();
};
interface ActionExpressionFactory {
ActionExpression create();
};
interface StateMachine: Behavior {
attribute TransitionCollection transitions;
attribute VertexCollection vertices;
Transition add_Transition();
void remove_Transition(in Transition theObject);
Vertex add_Vertex();
void remove_Vertex(in Vertex theObject);
};
interface StateMachineFactory {
StateMachine create();
};
interface TimeExpression: Event, Core_Concepts::Expression {
};
interface TimeExpressionFactory {
TimeExpression create();
};
interface Behavior: Core_Concepts::ModelElement {
attribute Structural_Elements::Pattern behaviors;
attribute Structural_Elements::InstanceCollection actions;
};
interface BehaviorFactory {
Behavior create();
};
interface Message: Core_Concepts::ModelElement {
attribute BooleanExpression guard;
attribute Core_Concepts::String sequence;
attribute Core_Concepts::Boolean isAsynchronous;
attribute {activation,_return} direction;
attribute Core_Concepts::Uninterpreted script;
attribute LinkRole messages;
attribute Structural_Elements::Instance thread;
attribute Action action;
Core_Concepts::Name label;
Instance add_Instance();
void remove_Instance(in Instance theObject);
Action add_Action();
void remove_Action(in Action theObject);
Name add_Name();
void remove_Name(in Name theObject);
};
interface MessageFactory {
Message create();
};
interface ActionState: State {
};
interface ActionStateFactory {
ActionState create();
};
interface BooleanExpression: Core_Concepts::Expression {
};
interface BooleanExpressionFactory {
BooleanExpression create();
};
interface State: Vertex {
attribute Structural_Elements::AttributeCollection state_variable;
attribute TransitionCollection internal_transition;
attribute Structural_Elements::InstanceCollection state_instance;
Attribute add_Attribute();
void remove_Attribute(in Attribute theObject);
Transition add_Transition();
void remove_Transition(in Transition theObject);
};
interface StateFactory {
State create();
};
};
4.3.2 Core_Concepts
模块
#include <CosLifeCycle.idl>
#include <CosStream.idl>
#include <Structural_Elements.idl>
// =========================================================
module Core_Concepts {
interface Note;
interface TaggedValue;
interface ViewElement;
interface Model;
interface Element;
interface ModelElement;
interface References;
interface Owns;
interface Package;
interface Time;
interface System;
interface Stereotype;
interface Relationship;
interface Constraint;
interface Dependency;
typedef Collection PointCollection;
typedef Collection NoteCollection;
typedef Collection TaggedValueCollection;
typedef Collection ViewElementCollection;
typedef Collection ModelCollection;
typedef Collection ElementCollection;
typedef Collection ModelElementCollection;
typedef Collection ReferencesCollection;
typedef Collection OwnsCollection;
typedef Collection PackageCollection;
typedef Collection TimeCollection;
typedef Collection SystemCollection;
typedef Collection StereotypeCollection;
typedef Collection RelationshipCollection;
typedef Collection ConstraintCollection;
typedef Collection DependencyCollection;
typedef string String;
typedef boolean Boolean;
typedef unsigned_longUML_blob;
typedef string Multiplicity;
typedef string Name;
typedef string Expression;
typedefUML_blob Uninterpreted;
enum Visibility {
public, protected, private, implementation
};
struct Point {
unsigned_long x;
unsigned_long y;
unsigned_long z;
};
interface Note: ModelElement {
attribute Uninterpreted value;
attribute Structural_Elements::PatternCollection notes;
};
interface NoteFactory {
Note create();
};
interface TaggedValue: ModelElement {
attribute Uninterpreted value;
attribute String name;
attribute Element characteristic;
attribute TaggedValueCollection tagset;
TaggedValue find_by_name(in Name name);
TaggedValue add_TaggedValue();
void remove_TaggedValue(in TaggedValue theObject);
};
interface TaggedValueFactory {
TaggedValue create();
};
interface ViewElement: Element {
ProjectionCollection get_projection();
ModelElement add_ModelElement();
void remove_ModelElement(in ModelElement theObject);
};
interface ViewElementFactory {
ViewElement create();
};
interface Model: CosStream::Streamable {
attribute Name name;
attribute PackageCollection represents;
attribute System abstraction;
ElementCollection contents();
};
interface ModelFactory {
Model create();
};
interface Element: CosLifeCycle::LifeCycleObject {
attribute TaggedValueCollection characteristic;
attribute Stereotype classification;
Name name;
OwnsCollection get_owns();
ReferencesCollection get_references();
DependencyCollection get_dependency();
TaggedValue find_by_name(in Name name);
TaggedValue add_TaggedValue();
void remove_TaggedValue(in TaggedValue theObject);
Stereotype add_Stereotype();
void remove_Stereotype(in Stereotype theObject);
Name add_Name();
void remove_Name(in Name theObject);
};
interface ElementFactory {
Element create();
};
interface ModelElement: Element {
attribute Structural_Elements::ComponentCollection implements;
ProjectionCollection get_projection();
};
interface ModelElementFactory {
ModelElement create();
};
interface References: CosLifeCycle::LifeCycleObject {
attribute Name alias;
attribute Visibility visibility;
attribute Package Package_reference;
attribute Element Element_reference;
};
interface ReferencesFactory {
References create();
};
interface Owns: CosLifeCycle::LifeCycleObject {
attribute Visibility visibility;
attribute Package Package_reference;
attribute Element Element_reference;
};
interface OwnsFactory {
Owns create();
};
interface Package: ModelElement, Structural_Elements::GeneralizableElement,
CosStream::Streamable {
attribute Model represents;
OwnsCollection get_owns();
Element add_Element();
void remove_Element(in Element theObject);
ReferencesCollection get_references();
Element add_Element();
void remove_Element(in Element theObject);
};
interface PackageFactory {
Package create();
};
interface Time: CosLifeCycle::LifeCycleObject {
};
interface TimeFactory {
Time create();
};
interface System: CosStream::Streamable {
attribute Name name;
attribute ModelCollection abstraction;
attribute DependencyCollection trace;
attribute StereotypeCollection define;
Model add_Model();
void remove_Model(in Model theObject);
Dependency add_Dependency();
void remove_Dependency(in Dependency theObject);
Stereotype add_Stereotype();
void remove_Stereotype(in Stereotype theObject);
};
interface SystemFactory {
System create();
};
interface Stereotype: ModelElement, Structural_Elements::GeneralizableElement {
attribute Uninterpreted value;
attribute ElementCollection classification;
attribute System define;
};
interface StereotypeFactory {
Stereotype create();
};
interface Relationship: ModelElement {
attribute Structural_Elements::Class relationship_class;
attribute Structural_Elements::PatternCollection relationships;
};
interface RelationshipFactory {
Relationship create();
};
interface Constraint: ModelElement {
attribute Uninterpreted value;
attribute Structural_Elements::PatternCollection constraints;
};
interface ConstraintFactory {
Constraint create();
};
interface Dependency: Relationship {
attribute System trace;
attribute source source_reference;
attribute target target_reference;
};
interface DependencyFactory {
Dependency create();
};
};
4.3.3 OAD_Facility
模块
module OAD_Facility {
#include "Core_Concepts.idl"
#include "Structural_Elements.idl"
#include "Behavioral_Elements.idl"
#include "View_Elements.idl"
};
4.3.4 Structural_Elements
模块
#include <CosLifeCycle.idl>
#include <Core_Concepts.idl>
#include <Behavioral_Elements.idl>
// =========================================================
module Structural_Elements {
interface AssociationRole;
interface Node;
interface FormalParameter;
interface Method;
interface ActiveClass;
interface Activity;
interface Pattern;
interface Component;
interface Class;
interface Nested;
interface Signal;
interface Parameter;
interface Operation;
interface Instance;
interface Member;
interface Type;
interface UseCase;
interface Attribute;
interface Responsibility;
interface Value;
interface Association;
interface Generalization;
interface Members;
interface GeneralizableElement;
interface PrimitiveType;
interface TypeExpression;
interface Signals;
typedef Collection AssociationRoleCollection;
typedef Collection NodeCollection;
typedef Collection FormalParameterCollection;
typedef Collection MethodCollection;
typedef Collection ActiveClassCollection;
typedef Collection ActivityCollection;
typedef Collection PatternCollection;
typedef Collection ComponentCollection;
typedef Collection ClassCollection;
typedef Collection NestedCollection;
typedef Collection SignalCollection;
typedef Collection ParameterCollection;
typedef Collection OperationCollection;
typedef Collection InstanceCollection;
typedef Collection MemberCollection;
typedef Collection TypeCollection;
typedef Collection UseCaseCollection;
typedef Collection AttributeCollection;
typedef Collection ResponsibilityCollection;
typedef Collection ValueCollection;
typedef Collection AssociationCollection;
typedef Collection GeneralizationCollection;
typedef Collection MembersCollection;
typedef Collection GeneralizableElementCollection;
typedef Collection PrimitiveTypeCollection;
typedef Collection TypeExpressionCollection;
typedef Collection SignalsCollection;
enum Concurrency {
sequential, guarded, synchronous
};
enum Direction {
catch, throw
};
interface AssociationRole: Core_Concepts::ModelElement {
attribute Core_Concepts::Multiplicity multiplicity;
attribute Core_Concepts::Boolean isNavigable;
attribute Core_Concepts::Boolean isAggregate;
attribute Core_Concepts::Boolean isOrdered;
attribute Core_Concepts::Boolean isChangeable;
attribute Type participates;
attribute Association association_roles;
attribute AttributeCollection qualifier;
attribute Type role;
attribute Behavioral_Elements::LinkRoleCollection role_instance;
Attribute add_Attribute();
void remove_Attribute(in Attribute theObject);
Type add_Type();
void remove_Type(in Type theObject);
};
interface AssociationRoleFactory {
AssociationRole create();
};
interface Node: Class {
attribute ComponentCollection deploys;
Component add_Component();
void remove_Component(in Component theObject);
};
interface NodeFactory {
Node create();
};
interface FormalParameter: CosLifeCycle::LifeCycleObject {
attribute {in,_inout,_out,_return} kind;
attribute Operation Operation_reference;
attribute Parameter Parameter_reference;
};
interface FormalParameterFactory {
FormalParameter create();
};
interface Method: Operation {
attribute Core_Concepts::Uninterpreted body;
};
interface MethodFactory {
Method create();
};
interface ActiveClass: Class {
};
interface ActiveClassFactory {
ActiveClass create();
};
interface Activity: Behavioral_Elements::Event {
attribute Behavioral_Elements::ActionCollection activity;
};
interface ActivityFactory {
Activity create();
};
interface Pattern: Core_Concepts::ModelElement {
attribute Core_Concepts::Boolean isTemplate;
attribute Core_Concepts::ConstraintCollection constraints;
attribute Core_Concepts::NoteCollection notes;
attribute Core_Concepts::RelationshipCollection relationships;
attribute TypeCollection types;
attribute Behavioral_Elements::BehaviorCollection behaviors;
attribute ValueCollection pattern_argument;
attribute ParameterCollection pattern_parameter;
attribute Type represents;
attribute Operation represents;
Constraint add_Constraint();
void remove_Constraint(in Constraint theObject);
Note add_Note();
void remove_Note(in Note theObject);
Relationship add_Relationship();
void remove_Relationship(in Relationship theObject);
Type add_Type();
void remove_Type(in Type theObject);
Behavior add_Behavior();
void remove_Behavior(in Behavior theObject);
Value add_Value();
void remove_Value(in Value theObject);
Parameter add_Parameter();
void remove_Parameter(in Parameter theObject);
};
interface PatternFactory {
Pattern create();
};
interface Component: Class {
attribute NodeCollection deploys;
attribute Core_Concepts::ModelElementCollection implements;
ModelElement add_ModelElement();
void remove_ModelElement(in ModelElement theObject);
};
interface ComponentFactory {
Component create();
};
interface Class: Type {
attribute Core_Concepts::Relationship relationship_class;
};
interface ClassFactory {
Class create();
};
interface Nested: CosLifeCycle::LifeCycleObject {
attribute Core_Concepts::Visibility visibility;
attribute Type Type_reference;
};
interface NestedFactory {
Nested create();
};
interface Signal: Class, Activity {
SignalsCollection get_signals();
};
interface SignalFactory {
Signal create();
};
interface Parameter: Core_Concepts::ModelElement {
attribute TypeExpression type;
attribute Core_Concepts::Uninterpreted defaultValue;
attribute Type template_parameter;
attribute Pattern pattern_parameter;
FormalParameterCollection get_formal_parameter();
};
interface ParameterFactory {
Parameter create();
};
interface Operation: Member, Activity {
attribute Core_Concepts::Boolean isPolymorphic;
attribute Concurrency concurrency;
attribute Core_Concepts::Boolean isQuery;
attribute Core_Concepts::Boolean isAbstract;
attribute PatternCollection represents;
FormalParameterCollection get_formal_parameter();
Parameter add_Parameter();
void remove_Parameter(in Parameter theObject);
};
interface OperationFactory {
Operation create();
};
interface Instance: Core_Concepts::ModelElement {
attribute Core_Concepts::Boolean isCreated;
attribute Core_Concepts::Boolean isDestroyed;
attribute Type instance_of;
attribute ValueCollection values;
attribute Behavioral_Elements::State state_instance;
attribute TypeCollection roles;
attribute Behavioral_Elements::Behavior actions;
attribute Behavioral_Elements::Interaction instances;
attribute Behavioral_Elements::Message thread;
attribute Behavioral_Elements::LinkRoleCollection player;
Value add_Value();
void remove_Value(in Value theObject);
State add_State();
void remove_State(in State theObject);
Type add_Type();
void remove_Type(in Type theObject);
Behavior add_Behavior();
void remove_Behavior(in Behavior theObject);
ActualArgumentCollection get_actual_argument();
};
interface InstanceFactory {
Instance create();
};
interface Member: Core_Concepts::ModelElement {
MembersCollection get_members();
};
interface MemberFactory {
Member create();
};
interface Type: Core_Concepts::ModelElement, GeneralizableElement {
attribute Core_Concepts::Boolean isTemplate;
attribute Core_Concepts::Multiplicity multiplicity;
attribute InstanceCollection instance_of;
attribute TypeExpressionCollection references;
attribute AssociationRoleCollection participates;
attribute Generalization powertype;
attribute AssociationRoleCollection role;
attribute ValueCollection template_argument;
attribute ParameterCollection template_parameter;
attribute InstanceCollection roles;
attribute PatternCollection types;
attribute PatternCollection represents;
MembersCollection get_members();
Member add_Member();
void remove_Member(in Member theObject);
SignalsCollection get_signals();
Signal add_Signal();
void remove_Signal(in Signal theObject);
NestedCollection get_nested();
Value add_Value();
void remove_Value(in Value theObject);
Parameter add_Parameter();
void remove_Parameter(in Parameter theObject);
};
interface TypeFactory {
Type create();
};
interface UseCase: Type {
};
interface UseCaseFactory {
UseCase create();
};
interface Attribute: Member {
attribute TypeExpression type;
attribute Core_Concepts::Uninterpreted initialValue;
attribute AssociationRole qualifier;
attribute Behavioral_Elements::State state_variable;
};
interface AttributeFactory {
Attribute create();
};
interface Responsibility: Core_Concepts::TaggedValue {
};
interface ResponsibilityFactory {
Responsibility create();
};
interface Value: Core_Concepts::ModelElement {
attribute Core_Concepts::Uninterpreted value;
attribute Instance values;
attribute Type template_argument;
attribute Pattern pattern_argument;
attribute Behavioral_Elements::LinkRole qualification;
};
interface ValueFactory {
Value create();
};
interface Association: Core_Concepts::Relationship {
attribute sequence<AssociationRole,2> association_roles;
attribute Behavioral_Elements::LinkCollection link_instance;
AssociationRole add_AssociationRole();
void remove_AssociationRole(in AssociationRole theObject);
};
interface AssociationFactory {
Association create();
};
interface Generalization: Core_Concepts::Relationship {
attribute Type powertype;
attribute supertype supertype_reference;
attribute subtype subtype_reference;
Type add_Type();
void remove_Type(in Type theObject);
};
interface GeneralizationFactory {
Generalization create();
};
interface Members: CosLifeCycle::LifeCycleObject {
attribute Core_Concepts::Boolean isTypeScope;
attribute Core_Concepts::Visibility visibility;
attribute {provide,_require} direction;
attribute Type Type_reference;
attribute Member Member_reference;
};
interface MembersFactory {
Members create();
};
interface GeneralizableElement: CosLifeCycle::LifeCycleObject {
attribute Core_Concepts::Boolean isRoot;
attribute Core_Concepts::Boolean isLeaf;
attribute Core_Concepts::Boolean isAbstract;
GeneralizationCollection get_generalization();
};
interface GeneralizableElementFactory {
GeneralizableElement create();
};
interface PrimitiveType: Type {
attribute Core_Concepts::Uninterpreted details;
};
interface PrimitiveTypeFactory {
PrimitiveType create();
};
interface TypeExpression: Core_Concepts::Expression {
attribute TypeCollection references;
TypeCollection referencedTypes();
};
interface TypeExpressionFactory {
TypeExpression create();
};
interface Signals: CosLifeCycle::LifeCycleObject {
attribute Direction direction;
attribute Type Type_reference;
attribute Signal Signal_reference;
};
interface SignalsFactory {
Signals create();
};
};
4.3.5 View_Elements
模块
#include <CosLifeCycle.idl>
#include <CosStream.idl>
#include <Core_Concepts.idl>
// =========================================================
module View_Elements {
interface SequenceDiagram;
interface StateDiagram;
interface Projection;
interface DeploymentDiagram;
interface Diagram;
interface CollaborationDiagram;
interface ComponentDiagram;
interface ClassDiagram;
interface ActivityDiagram;
interface UseCaseDiagram;
typedef Collection SequenceDiagramCollection;
typedef Collection StateDiagramCollection;
typedef Collection ProjectionCollection;
typedef Collection DeploymentDiagramCollection;
typedef Collection DiagramCollection;
typedef Collection CollaborationDiagramCollection;
typedef Collection ComponentDiagramCollection;
typedef Collection ClassDiagramCollection;
typedef Collection ActivityDiagramCollection;
typedef Collection UseCaseDiagramCollection;
interface SequenceDiagram: Diagram {
};
interface SequenceDiagramFactory {
SequenceDiagram create();
};
interface StateDiagram: Diagram {
};
interface StateDiagramFactory {
StateDiagram create();
};
interface Projection: CosLifeCycle::LifeCycleObject {
attribute PointCollection placement;
attribute Core_Concepts::Uninterpreted style;
attribute ViewElement ViewElement_reference;
attribute ModelElement ModelElement_reference;
};
interface ProjectionFactory {
Projection create();
};
interface DeploymentDiagram: Diagram {
};
interface DeploymentDiagramFactory {
DeploymentDiagram create();
};
interface Diagram: Core_Concepts::ViewElement, CosStream::Streamable {
};
interface DiagramFactory {
Diagram create();
};
interface CollaborationDiagram: Diagram {
};
interface CollaborationDiagramFactory {
CollaborationDiagram create();
};
interface ComponentDiagram: Diagram {
};
interface ComponentDiagramFactory {
ComponentDiagram create();
};
interface ClassDiagram: Diagram {
};
interface ClassDiagramFactory {
ClassDiagram create();
};
interface ActivityDiagram: Diagram {
};
interface ActivityDiagramFactory {
ActivityDiagram create();
};
interface UseCaseDiagram: Diagram {
};
interface UseCaseDiagramFactory {
UseCaseDiagram create();
};
};
2800 San Tomas Expressway
Santa Clara, CA 95051-0951
http://www.Rational.com
