Table of Contents
List of Figures
- 1. metamodel Package Diagram
- 2. Shlaer-Mellor Metamodel Component Diagram
- 3. Data Package Diagram
- 4. Domain Package Diagram
- 5. Dynamics Package Diagram
- 6. Object Package Diagram
- 7. Object Subsystem Tests Package Diagram
- 8. Process Package Diagram
- 9. Relationship Package Diagram
- 10. Type Package Diagram
- 11. Type Typed Operator Class State Machine
- 12. Type Time Instance State Machine
- 13. Type Symbolic Instance State Machine
- 14. Type Relationship Instance Reference Instance State Machine
- 15. Type Ordinal Instance State Machine
- 16. Type Numeric Instance State Machine
- 17. Type Instance Reference Instance State Machine
- 18. Type Enumeration Instance State Machine
- 19. Type Duration Instance State Machine
- 20. Type Domain Instance State Machine
- 21. Type Composite Instance State Machine
- 22. Type Boolean Instance State Machine
- 23. Type Arbitrary Instance State Machine
- 24. Type Accessor Reference Instance State Machine
- 25. Outgoing Bridges Package Diagram
- 26. Incoming Bridges Package Diagram
- 27. Process Model Bridges Package Diagram
- 28. Object Model Bridges Package Diagram
- 29. Dynamic Model Bridges Package Diagram
- 30. Data Bridges Package Diagram
- 31. DataTypes Package Diagram
- 32. EE Package Diagram
List of Tables
- 1. Classes
- 2. Data
- 3. Classes
- 4. Domain
- 5. Classes
- 6. Dynamics
- 7. Datatypes
- 8. Classes
- 9. Object
- 10. Classes
- 11. Classes
- 12. Process
- 13. Classes
- 14. Relationship
- 15. Classes
- 16. Type
- 17. Type
- 18. Process Model Bridges
- 19. Object Model Bridges
- 20. Dynamic Model Bridges
- 21. Data Bridges
- 22. Shlaer-Mellor Metamodel Interface Messages
- 23. Datatypes
- 24. EE
Please find below generated documentation for the system named shlaer-mellor-metamodel.
A metamodel is a model of a model. The metamodel provides the rules and
constraints of modeling using a particular paradigm.
The metamodel provides no guidance outside of its subject matter. e.g., the
Shlaer-Mellor metamodel provides rules and constraints for modeling using the
Shlaer-Mellor method, but it doesn''t provides rules and constraints concerning
the representation of the modeling elements.
This allows the modeling to be done using any notation (graphical or text)
that can unambiguously represent the elements used in the modeling.
It also means that the metamodel also doesn''t say how the model is to be
used. i.e., how it is transformed to machine language, or how it might be run
in simulation.
Metamodel for Shlaer-Mellor modeling.
A metamodel is used to describe the rules for constructing a model. It
specifies the construction elements and the constraints on the construction
elements. It is the modeled depiction of the modeling method, often done using
the modeling method.
The metamodel for Shlaer-Mellor modeling has the perspective of a single
domain model. All other domains are viewed only as outgoing bridges requiring
outside servicing. All accesses to the domain are viewed as incoming bridges
that evoke actions within the domain model. Therefore, an instance of metamodel
should only be used for verifying a single domain model at a time.
In any descriptions the following annotations are used for quoted material:
[OOSA:MWD]Object-Oriented Systems Analysis: Modeling the World in Data by
Sally Shlaer and Stephen Mellor
[OL:MWS]Object Lifecycles: Modeling the World in States by Sally Shlaer and
Stephen Mellor.
[OOAData] Data Types in OOA by Sally Shlaer and Stephen Mellor
[miUML] www.miuml.org - miUML open source executable uml - Leon Starr and
Andrew Mangogna
[xtUML] Executable UML: A Foundation for Model-driven Architecture by
Stephen J. Mellor and Marc J. Balcer
[Worm] Bridges and Wormholes by Sally Shlaer and Stephen J. Mellor.
Rendered here are the contained package diagrams.
The subsystem of the model concerned with data usage.
Table 1. Classes
The empty set value is defined for all types, as all types define a set of values. e.g., 6 is a member of the set defined by the numeric type. The only legal operations performed on an empty set are population and comparison to the empty set. A variable is a subset of a type set, whether the variable contains one value or many. When a variable is created without value assignment, it is an empty subset, and it can be thought of as uninitialized, containing no value, or null/none in common software language terms.
Variables are typed, modifiable instances of data used to hold values for further processing. Variables are the only allowed targets of assignment operations.
A relationship instance is the instantiation of an instance relationship. Just as object instantiations need to be tracked and handled, so do relationships. This is limited to instance relationships, as associative relationships are handled as object instances. The relationship represents a table containing a row for every instance of the relationship, and a column for each object participating in the relationship. When looking at the object model, the relationship represent the empty table. In the process model, the rows of the table are populated. The rows of the table, then represent relationship instance values.
The externally specialized value is the standard representation of a value that belongs to a set defined by commonly known types (e.g., the set of numerics). As the actual value isn''t that interesting to the metamodel, the attribute, value_name, is used to allow process model construction within the constraints the metamodel. This symbolic representation of the value is akin to the use of defines in C to represent "magic numbers".
An expression is a statement containing two operands and an operator. Expression evaluation in the metamodel is done using Reverse Polish Notation (RPN). The order of construction involves adding the left-hand operand, the the right-hand operand, and then the operator. This allows the metamodel to evaluate the expression and produce an outcome.
An accessor instance is instantiated in a process model to represent the acccessor at that point of access. An instantiation is needed so the accessor can be represented with different parameter data sets at different places in the process model or within different process models in the domain.
Here are listings of all of the activies in the class and its state machine(s).
select one out related by self->OUT[R618];
if (not empty out)
unrelate self from out across R618;
end if;
select one lho related by self->LHO[R615];
if (not empty lho)
unrelate self from lho across R615;
select one exp related by lho->EXP[R616];
unrelate lho from exp across R616;
delete object instance lho;
select one equ related by exp->EQU[R622];
equ.delete();
else
select one rho related by self->RHO[R615];
if (not empty rho)
unrelate self from rho across R615;
select one exp related by rho->EXP[R617];
unrelate rho from exp across R617;
delete object instance rho;
select one equ related by exp->EQU[R622];
equ.delete();
end if;
end if;
Here are listings of all of the activies in the class and its state machine(s).
Delete the transient data instance.
select one var related by self->VAR[R626]; select one val related by var->VAL[R635]; unrelate var from val across R635; unrelate self from var across R626; select one dus related by var->DUS[R624]; unrelate var from dus across R624; delete object instance var; dus.delete(); delete object instance dus;
Here are listings of all of the activies in the class and its state machine(s).
select one rref related by self->RREF[R421]; unrelate self from rref across R421; select one irl related by self->IRL[R638]; unrelate self from irl across R638; select one rins related by self->INS[R120.'''']; select one lins related by self->INS[R120.''is related to'']; if (not empty rins and not empty lins) unrelate lins from rins across R120.''is related to'' using self; end if; select one val related by self->VAL[R629]; unrelate self from val across R629; select one dus related by val->DUS[R624]; unrelate val from dus across R624; delete object instance val; dus.delete(); delete object instance dus;
Here are listings of all of the activies in the class and its state machine(s).
select one prm related by self->PRM[R645]; unrelate self from prm across R645; select one ain related by self->AIN[R647]; if (not empty ain) unrelate self from ain across R647; end if; select one var related by self->VAR[R626]; unrelate self from var across R626; select one val related by var->VAL[R635]; unrelate var from val across R635; select one dus related by var->DUS[R624]; unrelate var from dus across R624; delete object instance var; dus.delete(); delete object instance dus;
select any pro from instances of PRO where ( selected.action_id == param.actionId ) and ( selected.ordinal_position == param.ordinalPosition ); create object instance ela of ELA; select one re related by self->VAR[R626]->DUS[R624]->RE[R514]; relate re to pro across R502 using ela;
Here are listings of all of the activies in the class and its state machine(s).
select one type related by self->TYPE[R625]; unrelate self from type across R625; select one re related by self->RE[R514]; unrelate self from re across R514; re.delete(); delete object instance re; select many oprds related by self->OPRD[R631]; for each oprd in oprds oprd.delete(); delete object instance oprd; end for;
Here are listings of all of the activies in the class and its state machine(s).
select one nra related by self->NRA[R642]; unrelate self from nra across R642; select one ins related by self->INS[R643]; if (not empty ins) unrelate self from ins across R643; end if; select one var related by self->VAR[R626]; unrelate self from var across R626; select one val related by var->VAL[R635]; unrelate var from val across R635; select one dus related by var->DUS[R624]; unrelate var from dus across R624; delete object instance var; dus.delete(); delete object instance dus;
Here are listings of all of the activies in the class and its state machine(s).
select many prns related by self->PRN[R647]; for each prn in prns prn.delete(); delete object instance prn; end for; select one ins related by self->INS[R648]; if (not empty ins) select one min related by self->MIN[R648]; unrelate self from ins across R648 using min; end if; select one val related by self->VAL[R629]; unrelate self from val across R629; select one dus related by val->DUS[R624]; unrelate val from dus across R624; delete object instance val; dus.delete(); delete object instance dus;
Adds an instantiated accessor to the specified process model.
select one re related by self->VAL[R629]->DUS[R624]->RE[R514]; select any pro from instances of PRO where (selected.action_id == param.actionId) and (selected.ordinal_position == param.ordinalPosition); create object instance ela of ELA; relate re to pro across R502 using ela; select many prns related by self->PRN[R647]; for each prn in prns prn.addToProcessModel( actionId:param.actionId, ordinalPosition:param.ordinalPosition ); end for;
Table 2. Data
An expression can use a left-hand operand, and a left-hand operand is always used in an expression. The boolean operator, not, is an example of an expression without a left hand operand.
An equation includes one or more expressions. The expressions compose the equation. Equation evaluation in the metamodel is done using Reverse Polish Notation (RPN). The order of construction involves evaluating the left-most expression, then evaluating the right-most expression, and then the operator. The metamodel uses the ordinal position of the expression to decide evaluation order.
Values can be assigned to one or more variables at any given time, and a variable always has an assigned value. If no explicit assignment has been made, then the variable holds the default value for the data type. Values exist without variables. Consider the set of numeric values. It would be wrong to suggest the numeral one or the decimal one-half don''t exist in the absence of a variable. Variables in action language aren''t created or typed without assignment (explicit or implicit), so there''s no reason to assume an untyped (no default) variable would exist per this metamodel.
An unspecialized value always belongs to the set defined by a type. A type provides the definition for all of it''s values. This relationship requires creation of a value for every type. While this seems onerous, the relationship between value and variable implies that a default value exists for every type, therefore the values required by this relationship compose the set of default values.
The subsystem of the metamodel concerning domains.
Table 3. Classes
An external domain is a domain that requires or provides services to the domain being modeled. An external domain can be another Shlaer-Mellor modeled domain or a realized domain. The realized domain can be modeled using some other modeling method, might be existing code, or might be an executable. The bridges from a modeled domain to a realized domain are defined in the model with respect to the modeled domain''s requirements, and they can require some extra integration logic, external to the model, to meet the needs of the realized domain.
A synchronous bridge always returns data to the caller in a timely fashion. Timely should be defined by the domain providing the service. A synchronous bridge provided by another domain can launch asynchronous actions to obtain the return value, but this domain will be blocked while waiting on the actions to complete. The analyst should take this into consideration. If the external domain definition of timely doesn''t match the modeled domain definition of timely, then some mechanism must be put in place to allow the bridge to be treated as an asynchronous bridge. Special considerations: A synchronous service is used to access a data value from an external domain. NOTE: It is legal for the domain being modeled to call its own synchronous service as well.
An incoming bridge represents a service provided by the domain being modeled. A synchronous, incoming bridge returns data to the external domain in a timely fashion. An asynchronous, incoming bridge doesn''t return data the the external domain. An incoming bridge might also be referred to as a "domain function". Although incoming bridges are intended for external access, they can also be called internally by the domain being modeled.
"During analysis, a bridge between two domains represents a set of assumptions (from the client''s perspective) and a set of requirements (from the server''s). * The client thinks of a bridge as a set of capabilities that it assumes will be provided by another domain. The client does not care which domain pro- vides the capabilities. * The server thinks of the bridge as a set of requirements. The server does not care which domain needs the service, and therefore makes no assumptions about the client." [OL:MWS] Bridges can contain both synchronous and asynchronous processes. The following is a list of assumptions, on bridging domains, taken from [OL:MWS]: * OOA Mechanisms: "The application and service domains assume that the mecha- nisms of OOA (data storage, event transmission, and the like) are provided in some form." This means the other domains have a way of persisting shared data, handling events directed at them, synchronizing time, etc. This is the same as client and server computing machines. * Instant Data Attributes: "The application domain assumes that sensor-based attributes such as Cooking Tank.Actual Temperature have up-to-date values." The action of such a bridge will be considered part of the atomicity in the process model that calls it. Access will work as if it is from a data store. * Counterparts: "Although an object in one domain doesn''t require the exist- ence of an object in another, an instance of object in one domain may have as a counterpart an instance of an object in another domain. For example, a train (in the Railroad Management domain) may have a counterpoint train icon in the User Interface domain."
Table 4. Domain
In the context of the domain being modeled, the modeled domain might require services from external domains. An external domain specified in the model will provide services to only the modeled domain. In reality, the external domain would provide services to other domains, modeled and non-modeled, but in the context of the domain being modeled, it is the only domain requiring services. Even though a 1:M relationship doesn''t require an associative object, making the outgoing bridge an associative object constrains outgoing bridges to be explicitly associated with the client-server relationship between two domains.
The subsystem of the metamodel concerned with object and relationship dynamics.
Table 5. Classes
A lifecycle state model abstracts the common behavior of an object that applies to all instances. "Two forms of state models are commonly used in analysis; in OOA, we use the Moore form." [OL:MWS] Although there is no direct relationship between instance and lifecycle, the relationship is explicitly directed by the mandatory relationship between lifecycle and object and the mandatory relationship between instance and object. The empty set makes this very ugly to model explicitly, because the relationship between Instance and Lifecycle has to be 1c:Mc and be dependent on the already modeled path from Instance to Object to Lifecycle. The logical associative object would be "Active Instance", which would imply a "Passive Instance" object be created as part of a subtyping of Instance. A Lifecycle is instance-based, not object-based. This means that state is maintained for each instance of the object, not for the object, but the model of behavior is defined the same for all instances of the object.
The entry transition rule enforces the "same data rule", which states, "All events that cause a transition into a particular state must carry exactly the same event data." [OL:MWS] [OL:MWS] and [OOA96] define the data as, identifier data and supplemental data, where the supplemental data is the external data supplied as event parameters, and the identifier data is the target state designator. This means that an entry rule is composed of the parameter data to be carried by the event causing the transition, and the destination state designator.
The Assigner is a "state model that is responsible for creating instances of the relationship by associating instances of the participating objects with one another. ... the purpose of the Assigner is to act as a single point of control through which competing requests are serialized". [OL:MWS] An Assigner is object-based, not instance-based. This means that state is maintained for the object, not for each instance of the object.
Here are listings of all of the activies in the class and its state machine(s).
Clean up all relationships to prepare this instance for deletion.
select one smc related by self->SMC[R350]; select one sta related by smc->STA[R353]; unrelate smc from sta across R353; unrelate smc from self across R350; delete object instance smc; select one lif related by self->LIF[R360]; unrelate self from lif across R360; select one cre related by self->CRE[R348]; unrelate self from cre across R348; select one del related by self->DEL[R349]; if (not empty del) select one des related by self->DES[R349]; unrelate self from del across R349 using des; delete object instance des; end if; select one ins related by self->INS[R361]; unrelate self from ins across R361;
Table 6. Dynamics
A living state can be designated as a creation state. A state model will only have one creation state. The creation aspect could be made an attribute of living state, but that would imply that the creation aspect wasn''t permanent. There should be no reason to dynamically change which state is designated for creation.
A lifecycle state machine controls the life of one object instance, and an object instance can be controlled by a lifecycle state machine. Every instance has it''s own state machine.
The subsystem of the metamodel concerning objects, instances, and attributes.
Table 8. Classes
An identifier is used to uniquely identify the members of a set. "An identifier is a set of one or more attributes whose values uniquely distinguish each instance of an object." [OL:MWS] The set always has one identifying attribute that applies to all set members, but some identifying might only apply to some subset members. e.g., a subset formed from the intersection of two sets will have at least two identifying attributes, one from each set.
A subsequent specialization occurs due to other specializations. It shows that the subset exists without being linked to a specific metamodel element. The subsequent specialization can be due to specialization of the subtype leaf with no other differentiator at its own level.
A supertype represents a partitioning of the set associated with a specialized object. The supertype isn''t a subset of the object, but can collect a subset of attributes that are shared by the subsets formed by the supertype''s partitioning. The representation of the metamodel supertype on the object model is the part of the supertype/subtype relationship attached to the supertype object, not the supertype object itself. The identifier for the supertype is the name of the graphical relationship, that denotes the subtyping. i.e., the relationship with the bar across it in the Shlaer-Mellor notation, or the relationship with the triangle on the end in the UML notation.
Subtyping is the defining of subsets via a supertype partitioning. The relationship is abstracted to capture the many to many condition that arises from an intersection of two objects. On the object model, the subtyping is the leg from the supertype part of the relationship to the subtype object.
A non-referential attribute "is an abstraction of a single characteristic possessed by all entities that were themselves abstracted as an object." [OL:MWS] It should be noted that at least one of the non-referential attributes related to an object will participate in identification of the instances. While precedence has been set in some tools to not abstract arbitrary identifiers, a primary key must exist, and it would be specious to say we can assume it''s existence.
Multi-level partitioning abstracts the relationship formed when a proper subset is further partitioned (subset) by a supertype partitioning. A multi-level partitioning is instantiated whenever a subtype is subtyped in the object model.
A number used to identify a group of identifiers. Each group of identifiers are used to uniquely identify an object instance. The preferred identifier will have a groupId value of 1. The preferred identifier is the only identifier used to formalize an instance relationship as referential attributes. "An object may have several identifiers, each composed of one or more attributes. For example, an Airport object may have the atttributes Airport Code Latitude Longitude City Number of Passenger Gates The Airport Code attribute is an identifier of the Airport object, and the combination of Latitude and Longitude is another identifier of Airport. If an object has multiple identifiers, one such identifier is chosen as the preferred identifier." [OL:MWS] In tools, like BridgePoint, an indication is placed next to identifying attributes, and grouping of identifiers is done numerically. e.g., {I}, {I2}, {I3}, etc. This metamodel is just using a numeric indicator. The numeral, 1, is the preferred identifier, and like BridgePoint, the editor part of the toolset might choose to only display numerals greater than one.
Here are listings of all of the activies in the class and its state machine(s).
Determines if the attribute is related to the specfied object.
belongsTo = true;
select one oa related by self->OA[R124] where selected.object_name == param.object;
if (empty oa)
select one spa related by self->SPA[R124] where selected.subtype_name == param.object;
if (empty spa)
belongsTo = false;
end if;
end if;
return belongsTo;
Here are listings of all of the activies in the class and its state machine(s).
select many idps related by self->IDP[R102]; for each idp in idps select one atr related by idp->ATR[R102]; unrelate self from atr across R102 using idp; delete object instance idp; end for; select many itns related by self->ITN[R101]; for each itn in itns select one ins related by itn->INS[R101]; unrelate self from ins across R101 using itn; delete object instance itn; ins.delete(); delete object instance ins; end for;
Here are listings of all of the activies in the class and its state machine(s).
rc =false;
select one obj related by self->OBJ[R107];
if (not empty obj)
if (obj.domain_name == param.domain)
rc = true;
end if;
else
select one prp related by self->PRP[R107];
// Check for root supertype.
select one obj related by prp->NSB[R108]->SUP[R136]->OBJ[R134];
while (empty obj)
select many itss related by prp->ISB[R108]->ITS[R135];
for each its in itss
if (its.domain_name == param.domain)
rc = true;
break;
end if;
end for;
if (not rc)
// Move up to next subtyping
select one prp related by prp->NSB[R108]->SUP[R136]->PRP[R114];
// Check for root supertype.
select one obj related by prp->NSB[R108]->SUP[R136]->OBJ[R134];
end if;
end while;
if (not rc and (obj.domain_name == param.domain))
rc = true;
end if;
end if;
return rc;
Returns true if the type of state model specified already exists for the subset.
rc = true;
if (param.assigner)
select one asr related by self->ASR[R354];
if (not empty asr)
rc = false;
end if;
else
select one lif related by self->LIF[R347];
if (not empty lif)
rc = false;
end if;
end if;
return rc;
Instantiate attributes associated directly with this subset, and then get the next level subsets and tell them to instantiate their attributes.
select one obj related by self->OBJ[R107];
if (not empty obj)
select many oas related by obj->OA[R129];
for each oa in oas
select one nra related by oa->ATR[R124]->NRA[R103];
select one type related by nra->TYPE[R123];
nra.instantiate( objectInstance:param.objectInstance );
end for;
else
select one prp related by self->PRP[R107];
select many spas related by prp->SPA[R130];
for each spa in spas
select one nra related by spa->ATR[R124]->NRA[R103];
select one type related by nra->TYPE[R123];
nra.instantiate( objectInstance:param.objectInstance );
end for;
select many sups related by prp->SUP[R122];
for each sup in sups
select one sub related by sup->OBJ[R134]->SUB[R107];
if (empty sub)
select one sub related by sup->PRP[R114]->SUB[R107];
end if;
sub.instantiateAttributes( objectInstance:param.objectInstance );
end for;
end if;
Finds identifiers in this subtype and creates referentials, then finds any higher-level sub/supertypes and repeats the operation.
select any irl from instances of IRL where selected.number == param.relationship;
// First collect any identifiers for this subtype
irl.createReferentials( objectName:self.name );
// Then search up the hierarchy until the root supertype is found.
select one obj related by self->OBJ[R107];
if (empty obj)
select one prp related by self->PRP[R107];
select many sups related by prp->SUP[R122];
for each sup in sups
select one sub related by sup->OBJ[R134]->SUB[R107];
if (empty sub)
select one sub related by sup->PRP[R114]->SUB[R107];
end if;
sub.associateReferentials( relationship:param.relationship );
end for;
end if;
Checks to see if this subset is a member of the named set (object).
rc = false;
select one obj related by self->OBJ[R107] where selected.name == param.object;
if (not empty obj)
rc = true;
else
select one nsb related by self->PRP[R107]->NSB[R108];
if (not empty nsb)
select one obj related by nsb->SUP[R136]->OBJ[R134] where selected.name == param.object;
if (not empty obj)
rc = true;
else
select one sub related by nsb->SUP[R136]->PRP[R114]->SUB[R107];
rc = sub.isSubsetOf( object:param.object );
end if;
else
select one isb related by self->PRP[R107]->ISB[R108];
select any obj related by isb->OBJ[R135] where selected.name == param.object;
if (not empty obj)
rc = true;
end if;
end if;
end if;
return rc;
select one obj related by self->OBJ[R107];
if (not empty obj)
select many nms related by obj->NM[R131];
for each nm in nms
select one im related by nm->IM[R533];
im.instantiate( objectInstance:param.objectInstance );
end for;
else
select one prp related by self->PRP[R107];
select many smts related by prp->SBT[R122]->OBS[R126]->SMT[R125];
for each smt in smts
select one im related by smt->IM[R533];
im.instantiate( objectInstance:param.objectInstance );
end for;
select many sups related by prp->SUP[R122];
for each sup in sups
select one sub related by sup->OBJ[R134]->SUB[R107];
if (empty sub)
select one sub related by sup->PRP[R114]->SUB[R107];
end if;
sub.instantiateMethods( objectInstance:param.objectInstance );
end for;
end if;
Here are listings of all of the activies in the class and its state machine(s).
Determines if the named subtype is part of this supertype''s hierarchy.
rc = false;
select any prp related by self->PRP[R122] where selected.name == param.subtype;
if (not empty prp)
rc = true;
else
select many sups related by self->PRP[R122]->SUP[R114];
for each sup in sups
rc = sup.hasSubtype( subtype:param.subtype );
if (rc)
break;
end if;
end for;
end if;
return rc;
Here are listings of all of the activies in the class and its state machine(s).
Determines if this subset''s state model segment is a peer state model segment. This routine checks for a supertype partitioning across R122, then gets the supertype object(s) across R114 and determines if there is an associated state model segment. If there is no associated state model segment, then this method calls itself to recurse through the supertype object''s hierarchy.
// Determine if this is a peer segment. i.e., not a splice
peer = true;
// Get supertyping
select one sub related by self->SUB[R107];
select any sup related by sub->PRP[R107]->SUP[R122];
if (not empty sup)
select many sups related by sub->PRP[R107]->SUP[R122];
for each sup in sups
// Get subertype object
select one prp related by sup->PRP[R114];
if (not empty prp)
// Does this subtype have a state model segment?
select any sps related by prp->SBT[R122]->OBS[R126]->SPS[R125];
if (not empty sps)
peer = false;
else
peer = prp.hasPeerSegment();
end if;
if (not peer)
break;
end if;
end if;
end for;
end if;
return peer;
Here are listings of all of the activies in the class and its state machine(s).
Determines if the named subtype is this object or part of this object''s subtyping hierarchy.
rc = false;
if (self.name == param.subtype)
rc = true;
else
select many sups related by self->SUP[R134];
for each sup in sups
rc = sup.hasSubtype( subtype:param.subtype );
if (rc)
break;
end if;
end for;
end if;
return rc;
Here are listings of all of the activies in the class and its state machine(s).
Satisfies deleting all relationships to this instance and all related instance
data, such as attribute instances, method instances, and state machines.
Doesn''t delete this instance. That must be handled by the caller. The
architecture domain should call this at the end of processing a deletion state.select one sub related by self->SUB[R112]; // Cleanup relationships select many rins related by self->RIN[R120.''is related to'']; for each rin in rins select one ins related by rin->INS[R120.''is related to'']; unrelate self from ins across R120.''is related to'' using rin; rin.delete(); delete object instance rin; end for; // Cleanup attributes select many atns related by self->ATN[R643]; for each atn in atns unrelate self from atn across R643; atn.delete(); delete object instance atn; end for; // Cleanup methods select many ains related by self->AIN[R648]; for each ain in ains ain.delete(); delete object instance ain; end for; // Cleanup state machines select one lsm related by self->LSM[R361]; if (not empty lsm) lsm.delete(); delete object instance lsm; end if; // Cleanup self unrelate self from sub across R112; select many itns related by self->ITN[R101]; for each itn in itns select one id related by itn->ID[R101]; unrelate self from id across R101 using itn; delete object instance itn; end for;
Here are listings of all of the activies in the class and its state machine(s).
select any ins from instances of INS where selected.id == param.objectInstance; create object instance atn of ATN; relate atn to self across R642; relate atn to ins across R643; create object instance var of VAR; relate var to atn across R626; create object instance dus of DUS; relate dus to var across R624; select one type related by self->TYPE[R123]; relate type to dus across R625;
Table 9. Object
Subsets are formed by supertype partitionings, and a subset is a subtype for one or more supertypes. The partitioning relationship is thus abstracted as a subtyping. Non-intersecting subtypes are further constrained by R136 to belong to only one supertype. "OOA does not permit creating an instance of the supertype without creating an instance of one subtype, and vice versa." [OL:MWS]
Every non-referential attribute adheres to a known type. The type imposes type constraints on the attribute. NOTE: Referential attributes will also have a known type, but those are set where they are non-referential attributes.
An object specialization results in one subtyping of an object, and the subtyping can be the result of multiple defined object specialization types. While a single specialization actually results in two subtypings, additional subtypings in the same generalization will not result in two subtypings. e.g., An object, A, exists, and it is decided an attribute only applies to some instances of A and not others. A subtype, B, is created to hold the attribute, and a subtype, C, is created to represent the instances without the attribute. Another attribute is defined to only apply to some instances of A, so subtype, D, is created. D requires no subsequent specialization, because the remaining instances are already defined by B and C.
An object attribute characterizes an object. The object and all subsets of an object are characterized by object attributes, as all of the object attributes apply to all instances of the object. As there is always an identifier attribute, an object is always characterized by at least one object attribute.
A supertype can partition an object, or it can a partition a proper subset. An object is partitioned by one or more supertypes. A partitioning of an object by a single supertype should be pictured as one or more parallel chords, each crossing the arc of the set at two distinct points. When the partitioning of the same object is done by more than one supertype, the chords of the supertypes intersect each other.
A non-intersecting subset is a subtype for one supertype, and the supertype defines the partitioning for all of its subtypes. This relationship adds further constraint, for non-intersecting subsets, to R122, which defines all of the subtyping relationships.
Rendered here are the contained package diagrams.
This package can be used to check various instantiation scenarios for the object subsystem. Current usage: Create an unspecialized object, and create each of the types of specialized objects.
Table 10. Classes
Here are listings of all of the activies in the class and its state machine(s).
An example of object intersection is object A as supertype with subtype objects
C and D and object B as supertype with subtype objects D and E. Subtype D is
subset formed by the intersection of A and B.
Diagram:
+----------+ +---------+ +----------+
| C | | D | | E |
| | | | | |
+----------+ +---------+ +----------+
| | | |
+---------+ +---------+
| |
+---------+ +---------+
| A | | B |
| | | |
+---------+ +---------+
// Object A create object instance domain of DOM; create object instance modeled_domain of MDOM; relate domain to modeled_domain across R1; create object instance objA of OBJ; relate objA to modeled_domain across R105; create object instance subA of SUB; relate subA to objA across R107; // Subset C create object instance subC of SUB; create object instance psubC of PRP; relate subC to psubC across R107; create object instance non_psubC of NSB; relate psubC to non_psubC across R108; // Supertype A create object instance superA of SUP; create object instance chdA of CHD; relate superA to objA across R134 using chdA; relate non_psubC to superA across R136; create object instance subtypeC of SBT; relate superA to psubC across R122 using subtypeC; create object instance obsA of OBS; relate subtypeC to obsA across R126; create object instance sbsC of SBS; relate sbsC to obsA across R125; // Object B create object instance objB of OBJ; relate objB to modeled_domain across R105; create object instance subB of SUB; relate subB to objB across R107; // Subset E create object instance subE of SUB; create object instance psubE of PRP; relate subE to psubE across R107; create object instance non_psubE of NSB; relate psubE to non_psubE across R108; // Supertype B create object instance superB of SUP; create object instance chdB of CHD; relate superB to objB across R134 using chdB; relate non_psubE to superB across R136; create object instance subtypeE of SBT; relate superA to psubE across R122 using subtypeE; create object instance obsB of OBS; relate subtypeE to obsB across R126; create object instance sbsE of SBS; relate sbsE to obsB across R125; // Intersecting subset D create object instance subD of SUB; create object instance psubD of PRP; relate subD to psubD across R107; create object instance isb_psubD of ISB; relate psubD to isb_psubD across R108; create object instance intA of ITS; relate isb_psubD to objA across R135 using intA; create object instance intB of ITS; relate isb_psubD to objB across R135 using intB; // Supertype relationships for intersecting subtypes create object instance subtypeD of SBT; relate psubD to superA across R122 using subtypeD; relate psubD to superB across R122 using subtypeD; relate obsA to subtypeD across R126; relate intA to obsA across R125; relate obsB to subtypeD across R126; relate intB to obsB across R125; // Attributes // Make the first one an identifier, as you can''t create instances without an // identifier. // NOTE: In intersections, an identifier must be common to all intersecting // sets. // TODO: Create a check for this // TODO: Handle this for cases with multiple intersections. // * Supers A, B, and C intersect at sub D. // * Super A intersects super B at sub D and super A intersects super F // at sub C. (common identifier for A, B, and F) create object instance attribute1 of ATR; create object instance nonref1 of NRA; relate attribute1 to nonref1 across R103; create object instance objectAttribute1 of OA; relate objectAttribute1 to attribute1 across R124; relate objectAttribute1 to objA across R129; create object instance identifier1 of ID; create object instance participation1 of IDP; relate identifier1 to attribute1 across R102 using participation1; // Make an numeric attribute as a specializer for subtype C. create object instanc
Here are listings of all of the activies in the class and its state machine(s).
An example of multi-directional subtyping is object A as supertype with subtype
objects B and C in one direction and subtype objects D and E in the other.
Diagram:
+---------+ +---------+
| B | | C |
| | | |
+---------+ +---------+
| |
+-------------+
|
+---------+
| A |
| |
+---------+
|
+-------------+
| |
+---------+ +---------+
| D | | E |
| | | |
+---------+ +---------+
create object instance domain of DOM; create object instance modeled_domain of MDOM; relate domain to modeled_domain across R1; create object instance objA of OBJ; relate objA to modeled_domain across R105; create object instance subA of SUB; relate subA to objA across R107; // Subset B create object instance subB of SUB; create object instance psubB of PRP; relate subB to psubB across R107; create object instance non_psubB of NSB; relate psubB to non_psubB across R108; // Subset C create object instance subC of SUB; create object instance psubC of PRP; relate subC to psubC across R107; create object instance non_psubC of NSB; relate psubC to non_psubC across R108; // Supertype A1 create object instance superA1 of SUP; create object instance chdA1 of CHD; relate superA1 to objA across R134 using chdA1; create object instance subtypeB of SBT; relate superA1 to psubB across R122 using subtypeB; // Object specialization for B is below. create object instance subtypeC of SBT; relate superA1 to psubC across R122 using subtypeC; create object instance obsC of OBS; relate obsC to subtypeC across R126; create object instance sbsC of SBS; relate sbsC to obsC across R125; // Specialize across another supertype (direction) // Subset D create object instance subD of SUB; create object instance psubD of PRP; relate subD to psubD across R107; create object instance non_psubD of NSB; relate psubD to non_psubD across R108; // Subset E create object instance subE of SUB; create object instance psubE of PRP; relate subE to psubE across R107; create object instance non_psubE of NSB; relate psubE to non_psubE across R108; // Supertype A2 create object instance superA2 of SUP; create object instance chdA2 of CHD; relate superA2 to objA across R134 using chdA2; create object instance subtypeD of SBT; relate superA2 to psubD across R122 using subtypeD; create object instance obsD of OBS; relate obsD to subtypeD across R126; create object instance sbsD of SBS; relate sbsD to obsD across R125; create object instance subtypeE of SBT; relate superA2 to psubE across R122 using subtypeE; // Object specialization for E is below. // Attributes // Make the first one an identifier, as you can''t create instances without an // identifier. create object instance attribute1 of ATR; create object instance nonref1 of NRA; relate attribute1 to nonref1 across R103; create object instance objectAttribute1 of OA; relate objectAttribute1 to objA across R129; relate objectAttribute1 to attribute1 across R124; create object instance identifier1 of ID; create object instance participation1 of IDP; relate identifier1 to attribute1 across R102 using participation1; // Make the second one a specializer for subtype B. create object instance attribute2 of ATR; create object instance nonref2 of NRA; relate attribute2 to nonref2 across R103; create object instance attribution2 of SPA; relate attribution2 to attribute2 across R124; relate attribution2 to psubB across R130; create object instance objectSpecialization2 of OBS; relate attribution2 to objectSpecialization2 across R125; relate objectSpecialization2 to subtypeB across R126; // Make the third one a specializer for subtype E. create object instance attribute3 of ATR; create object instance nonref3 of NRA; relate attribute3 to nonref3 across R103; create object instance attribution3 of SPA; rel
Here are listings of all of the activies in the class and its state machine(s).
An example of multi-level subtyping is object A as supertype with subtype
objects B and C and object C as supertype with subtype objects D and E.
Diagram:
+---------+ +---------+
| D | | E |
| | | |
+---------+ +---------+
| |
+-----------+
|
+---------+ +---------+
| B | | C |
| | | |
+---------+ +---------+
| |
+-------------+
|
+---------+
| A |
| |
+---------+
// Object A create object instance domain of DOM; create object instance modeled_domain of MDOM; relate domain to modeled_domain across R1; create object instance objA of OBJ; relate objA to modeled_domain across R105; create object instance subA of SUB; relate subA to objA across R107; // Subset B create object instance subB of SUB; create object instance psubB of PRP; relate subB to psubB across R107; create object instance non_psubB of NSB; relate psubB to non_psubB across R108; // Subset C - Will be specialized further create object instance subC of SUB; create object instance psubC of PRP; relate subC to psubC across R107; create object instance non_psubC of NSB; relate psubC to non_psubC across R108; // Supertype A create object instance superA of SUP; create object instance chdA of CHD; relate superA to objA across R134 using chdA; create object instance subtypeB of SBT; relate superA to psubB across R122 using subtypeB; create object instance obsB of OBS; relate obsB to subtypeB across R126; create object instance sbsB of SBS; relate sbsB to obsB across R125; create object instance subtypeC of SBT; relate superA to psubC across R122 using subtypeC; // Object specialization of C is done with an attribute below. // Specialize Subset C // Subsubset D create object instance subD of SUB; create object instance psubD of PRP; relate subD to psubD across R107; create object instance non_psubD of NSB; relate psubD to non_psubD across R108; // Subsubset E create object instance subE of SUB; create object instance psubE of PRP; relate subE to psubE across R107; create object instance non_psubE of NSB; relate psubE to non_psubE across R108; // Supertype C create object instance superC of SUP; create object instance multiC of MLV; relate superC to psubC across R114 using multiC; create object instance subtypeD of SBT; relate superC to psubC across R122 using subtypeD; create object instance obsD of OBS; relate obsD to subtypeD across R126; create object instance sbsD of SBS; relate sbsD to obsD across R125; create object instance subtypeE of SBT; relate superC to psubE across R122 using subtypeE; create object instance obsE of OBS; relate obsE to subtypeE across R126; create object instance sbsE of SBS; relate sbsE to obsE across R125; // Attributes // Make the first one an identifier, as you can''t create instances without an // identifier. create object instance attribute1 of ATR; create object instance nonref1 of NRA; relate attribute1 to nonref1 across R103; create object instance objectAttribute1 of OA; relate objectAttribute1 to attribute1 across R124; relate objectAttribute1 to objA across R129; create object instance identifier1 of ID; create object instance participation1 of IDP; relate identifier1 to attribute1 across R102 using participation1; // Make the second one a specializer for one of the subtypes. create object instance attribute2 of ATR; create object instance nonref2 of NRA; relate attribute2 to nonref2 across R103; create object instance attribution2 of SPA; relate attribution2 to attribute2 across R124; relate attribution2 to psubC across R130; create object instance objectSpecialization2 of OBS; relate attribution2 to objectSpecialization2 across R125; relate objectSpecialization2 to subtypeC across R126; // Create an attribute on the supertype create object instance attribute3 of A
Here are listings of all of the activies in the class and its state machine(s).
An example of single-level, two-way subtyping is object A as supertype with
subtype objects B and C.
Diagram:
+---------+ +---------+
| B | | C |
| | | |
+---------+ +---------+
| |
+-----------+
|
+---------+
| A |
| |
+---------+
create object instance domain of DOM; create object instance modeled_domain of MDOM; relate domain to modeled_domain across R1; create object instance objA of OBJ; relate objA to modeled_domain across R105; create object instance subA of SUB; relate subA to objA across R107; // Subset B create object instance subB of SUB; create object instance psubB of PRP; relate subB to psubB across R107; create object instance non_psubB of NSB; relate psubB to non_psubB across R108; // Subset C create object instance subC of SUB; create object instance psubC of PRP; relate subC to psubC across R107; create object instance non_psubC of NSB; relate psubC to non_psubC across R108; // Supertype A create object instance superA of SUP; create object instance chdA of CHD; relate objA to superA across R134 using chdA; create object instance subtypeB of SBT; relate superA to psubB across R122 using subtypeB; create object instance subtypeC of SBT; relate superA to psubC across R122 using subtypeC; create object instance obsC of OBS; relate obsC to subtypeC across R126; create object instance sbsC of SBS; relate sbsC to obsC across R125; // Attributes // Make the first one an identifier, as you can''t create instances without an // identifier. create object instance attribute1 of ATR; create object instance nonref1 of NRA; relate attribute1 to nonref1 across R103; create object instance objectAttribute1 of OA; relate objectAttribute1 to attribute1 across R124; relate objectAttribute1 to objA across R129; create object instance identifier1 of ID; create object instance participation1 of IDP; relate identifier1 to attribute1 across R102 using participation1; // Make the second one a specializer for subtype B. create object instance attribute2 of ATR; create object instance nonref2 of NRA; relate attribute2 to nonref2 across R103; create object instance attribution2 of SPA; relate attribution2 to attribute2 across R124; relate attribution2 to psubB across R130; create object instance objectSpecialization2 of OBS; relate attribution2 to objectSpecialization2 across R125; relate objectSpecialization2 to subtypeB across R126; // Create an instance of subtype B create object instance instance1 of INS; relate instance1 to subB across R112; create object instance instantiation1 of ITN; relate instance1 to identifier1 across R101 using instantiation1; // Create an instance of subtype C create object instance instance2 of INS; relate instance2 to subC across R112; create object instance instantiation2 of ITN; relate instance2 to identifier1 across R101 using instantiation2;
An example of single-level, three-way subtyping is object A as supertype with
subtype objects B, C, and D.
Diagram:
+---------+ +---------+ +---------+
| B | | C | | D |
| | | | | |
+---------+ +---------+ +---------+
| | |
+-----------+-----------+
|
+---------+
| A |
| |
+---------+
create object instance domain of DOM; create object instance modeled_domain of MDOM; relate domain to modeled_domain across R1; create object instance objA of OBJ; relate objA to modeled_domain across R105; create object instance subA of SUB; relate subA to objA across R107; // Subset B create object instance subB of SUB; create object instance psubB of PRP; relate subB to psubB across R107; create object instance non_psubB of NSB; relate psubB to non_psubB across R108; // Subset C create object instance subC of SUB; create object instance psubC of PRP; relate subC to psubC across R107; create object instance non_psubC of NSB; relate psubC to non_psubC across R108; // Subset D create object instance subD of SUB; create object instance psubD of PRP; relate subD to psubD across R107; create object instance non_psubD of NSB; relate psubD to non_psubD across R108; // Supertype A create object instance superA of SUP; create object instance chdA of CHD; relate superA to objA across R134 using chdA; create object instance subtypeB of SBT; relate superA to psubB across R122 using subtypeB; create object instance subtypeC of SBT; relate superA to psubC across R122 using subtypeC; create object instance subtypeD of SBT; relate superA to psubD across R122 using subtypeD; create object instance obsD of OBS; relate obsD to subtypeD across R126; create object instance sbsD of SBS; relate sbsD to obsD across R125; // Attributes // Make the first one an identifier, as you can''t create instances without an // identifier. create object instance attribute1 of ATR; create object instance nonref1 of NRA; relate attribute1 to nonref1 across R103; create object instance objectAttribute1 of OA; relate objectAttribute1 to attribute1 across R124; relate objectAttribute1 to objA across R129; create object instance identifier1 of ID; create object instance participation1 of IDP; relate identifier1 to attribute1 across R102 using participation1; // Make the second one a specializer for subtype B. create object instance attribute2 of ATR; create object instance nonref2 of NRA; relate attribute2 to nonref2 across R103; create object instance attribution2 of SPA; relate attribution2 to attribute2 across R124; create object instance objectSpecialization2 of OBS; relate objectSpecialization2 to attribution2 across R125; relate objectSpecialization2 to subtypeB across R126; // Make the third one a specializer for subtype C. create object instance attribute3 of ATR; create object instance nonref3 of NRA; relate attribute3 to nonref3 across R103; create object instance attribution3 of SPA; relate attribution3 to attribute3 across R124; create object instance objectSpecialization3 of OBS; relate objectSpecialization3 to attribution3 across R125; relate objectSpecialization3 to subtypeC across R126; // Create an instance of subtype 1 create object instance instance1 of INS; relate instance1 to subB across R112; create object instance instantiation1 of ITN; relate instance1 to identifier1 across R101 using instantiation1; // Create an instance of subtype 2 create object instance instance2 of INS; relate instance2 to subC across R112; create object instance instantiation2 of ITN; relate instance2 to identifier1 across R101 using instantiation2; // Create an instance of subtype 3 create object instance instance3 of INS; relate instance3 to
Process Modeling package
Table 11. Classes
An accessor provides access to reference elements and defines the signature of the access. The accessor represents bridges, events, and operations. In other words, things that would be known as functions, procedures, or methods in third generation programming languages like C or Java. An accessor is a value once instantiated in the metamodel, that can be referenced in process models.
An instance method requires an instantiation, before it can be used. The dynamics of the instance method only apply to a single object instance. Instance methods are favored over events when actions need to occur within the atomicity of a process.
Objects can have methods associated with them to handle synchronous processing tasks. In Object Lifecycles, methods weren''t explicitly called as such, but the processes used in the process models were explicitly tied to an object and available for reuse in many process models.
A non-specializing instance method applies to all instantiations of an object, regardless of subtyping. In the object model, these appear in unspecialized objects and root supertypes of specialized objects only.
An object method doesn''t require an instantiation to be invoked. It is the method analog to the assigner state machine. It is used for encapsulating synchronous object dynamics that aren''t specific to an object instance. Typical usage of an object method is to initialize an instance unconditionally related to another instance in cases where actions must be performed upon creation of the instance. Such a condition can''t use state machine creation, as the asynchronous nature violates the unconditional aspect of the relationship.
A reference element is any Shlaer-Mellor element that can be accessed as part of a procedural model. A reference element invokes an action and/or assigns a value to a variable. The reference element constrains which elements in the metamodel can participate in a process.
The number of unique paths in this control structure. Examples: an if statement has one path an if-else statement has two paths an if-elif-else statement has three paths a switch-case statement has paths equal to the number of cases
An iteration process steps through an ordinal value from a specified starting point to a specified ending point. Typical iteration processes in third generation programming languages are for loops. This analysis only supports a single step index into a fixed length array, therefore the iteration always starts at the first array element (one-based) and indexes through the end of the array. External editors will have to adjust their value arrays accordingly or use a loop.
Here are listings of all of the activies in the class and its state machine(s).
Create an instance of this accessor, and it''s parameters.
create object instance ain of AIN; select any aref from instances of AREF; relate ain to aref across R422; relate ain to self across R640; create object instance val of VAL; relate ain to val across R629; create object instance dus of DUS; relate val to dus across R624; select one type related by aref->CORE[R403]->TYPE[R401]; relate type to dus across R625; create object instance re of RE; relate dus to re across R514; select many prms related by self->PRM[R540]; for each prm in prms prm.instantiate( accessorInstance:ain.id ); end for; return ain.id;
Here are listings of all of the activies in the class and its state machine(s).
select one acc related by self->MTH[R532]->ISY[R534]->SYA[R524]->ACC[R505]; instId = acc.instantiate(); select any ain from instances of AIN where selected.id == instId; select any ins from instances of INS where selected.id == param.objectInstance; create object instance min of MIN; relate ain to ins across R648 using min;
Here are listings of all of the activies in the class and its state machine(s).
rc = true;
select one om related by self->OM[R532] where selected.name == param.object;
if (empty om)
select one nm related by self->IM[R532]->NM[R533] where selected.name == param.object;
if (empty nm)
select one obs related by self->IM[R532]->SMT[R533]->OBS[R125] where selected.subtype_name == param.object;
if (empty obs)
rc = false;
end if;
end if;
end if;
return rc;
Here are listings of all of the activies in the class and its state machine(s).
Here are listings of all of the activies in the class and its state machine(s).
Create an instance of this parameter related to the specified accessor instance.
select any ain from instances of AIN where selected.id == param.accessorInstance; create object instance prn of PRN; relate prn to self across R645; relate prn to ain across R647; create object instance var of VAR; relate prn to var across R626; select any emp from instances of EMP; select one val related by emp->VAL[R629]; relate val to var across R635; create object instance dus of DUS; relate var to dus across R624; select one type related by self->TYPE[R541]; relate dus to type across R625; create object instance re of RE; relate dus to re across R514;
Here are listings of all of the activies in the class and its state machine(s).
select one re related by self->RE[R514];
unrelate self from re across R514;
re.delete();
delete object instance re;
select many exps related by self->EXP[R622];
for each exp in exps
select one tyop related by exp->TYOP[R632];
unrelate exp from tyop across R632;
select one out related by exp->OUT[R611];
unrelate out from exp across R611;
select one tyop related by out->TYOP[R634];
unrelate out from tyop across R634;
select one oprd related by out->OPRD[R618];
unrelate out from oprd across R618;
delete object instance out;
select one rho related by exp->RHO[R617];
unrelate exp from rho across R617;
select one oprd related by rho->OPRD[R615];
unrelate rho from oprd across R615;
delete object instance rho;
select one dus related by oprd->DUS[R631];
unrelate oprd from dus across R631;
delete object instance oprd;
select one lho related by exp->LHO[R616];
if (not empty lho)
unrelate exp from lho across R616;
select one oprd related by lho->OPRD[R615];
unrelate lho from oprd across R615;
delete object instance lho;
select one dus related by oprd->DUS[R631];
unrelate oprd from dus across R631;
delete object instance oprd;
end if;
unrelate self from exp across R622;
delete object instance exp;
end for;
Here are listings of all of the activies in the class and its state machine(s).
Returns the name of the accessor or state that contains this action. In the case of states, different event (accessor) names can be used to cause entry into the state, so the state name must be used.
name = "";
select one acc related by self->AE[R500]->BRG[R509]->ASB[R3]->ASA[R506]->ACC[R505];
if (empty acc)
select one acc related by self->AE[R500]->BRG[R509]->SYB[R3]->SYA[R524]->ACC[R505];
if (empty acc)
select one acc related by self->AE[R500]->ATA[R509]->ISY[R534]->SYA[R524]->ACC[R505];
if (empty acc)
select one acc related by self->AE[R500]->MTH[R509]->ISY[R534]->SYA[R524]->ACC[R505];
if (empty acc)
select one sta related by self->AE[R500]->STA[R509];
name = sta.name;
end if;
end if;
end if;
end if;
if (not empty acc)
name = acc.name;
end if;
return name;
Table 12. Process
A control structure controls zero to many processes, and a process can have its execution controlled by a control structure. Another way to look at this relationship is as containment where a control structure can contain other processes. Scoping is avoided in this analysis as variables are scoped by the action, not by any processes.
The subsystem of the metamodel concerning relationships. This diagram borrows heavily from the miUML (www.miuml.org) metamodel, because why reinvent the open-sourced wheel? The key differences are the extra level of abstraction due to instance representation in this metamodel, and the lack of a generalization relationship in this metamodel, as generalizations aren''t relationships in this metamodel.
Table 13. Classes
"A Perspective is a point of view from a hypothetical Instance on an Association." [miUML] Perspective was taken from the miUML metamodel, which doesn''t have an instance object, so in this metamodel, instance isn''t hypothetical and always has a perspective when involved in a relationship. Further discussion on perspective can be found in the chapter 4, "Reflexive Relationships", in [OOA96].
An instance of composition is the loop segment containing the relationship instance that is the result of the composition equation. "[When a relationship is the logical consequence of other relationships,] Such a relationship is said to be formed by composition (as in composition of functions in mathematics. [...] A relationship formed by composition cannot be formalized in referential attributes, since the connections between the instances is already given by the connections between the [composing relationships]. A relationship formed by composition is annotated on the model as [composed relationship = 1st composing relationship + 2nd composing relationship [+ nth composing relationship ...]]." [OL:MWS] "Composed Relationships. Another special case occurs when the constraint on the referential attribute is such that it identifies a single instance of the associated object. [...] Composition of relationships captures the constraint directly in data [...] However the use of composition is limited in that it requires that the constraint always identify a single associated instance." [OOA96] Both definitions identify compositions as relationship combinations that loop back to the originating instance. [miUML] calls compositions, "Constrained Loops", because the compostion equation forms a constraint on the object instances allowed to participate. [OOA96] also discusses collapsed referentials, but the example shows them to be an alternative way to draw compositions on the object model. This metamodel will only model a composition and leave the way to display it up to the model editor.
An associative relationship requires further abstraction by an object. The set defined by the object allows instances of relationships to have further relationships, data properties, and dynamic processing. An associative relationship relates the associative object to a relationship between object instances.
Here are listings of all of the activies in the class and its state machine(s).
select any sub from instances of SUB where selected.name == param.objectName; select many idps related by sub->OBJ[R107]->OA[R129]->ATR[R124]->IDP[R102]; if (empty idps) select many idps related by sub->PRP[R107]->SPA[R130]->ATR[R124]->IDP[R102]; end if; for each idp in idps select one atr related by idp->ATR[R102]; create object instance refatr of ATR; refatr.name = atr.name + "(R" + TC::intToString( i:self.number ) + ")"; create object instance ref of REF; relate ref to refatr across R103; relate idp to ref across R137; select one ncm related by self->NCM[R213]; relate ref to ncm across R128; end for;
Table 14. Relationship
Table 15. Classes
An enumeration value is one of the enumerators that compose an enumeration. The uses of enumeration values are constrained by the operations supported by the enumeration type. An enumeration value can never be identified by just the value name; it must always use the enumeration definition name as well. e.g., def::value
An Operator represents a function that may be defined for a Type. Not all Operators will be visible in implementation. e.g., an action language may choose to allow automatic conversion from one type to another, 5 + "5" = 10. In such a case, a string to numeric Operator must be defined as part of the instantiation of the metamodel.
"An Operator is polymorphic in that it may be applied to multiple Types." [miUML] The Typed Operator is the mapping of a Type to an Operator. The context of the result of the operation is the same as the context of the Typed Operator chosen. This implies precedence must be built into the process model, if auto- matic type conversion is desired, because the result of e.g., 5 + "5" is different if ''+'' is a string operator vs a numeric operator. (This also requires that the corresponding conversion operator is defined.)
"To define a data type that represents calendar-clock time, write: data type <data type name> is time range is from <year-mon-day> (<hour:min:sec >) to <year-mon-day> (<hour:min:sec >) precision is <smallest discriminated value> [ year | month | day | hour | minute | second | millisec | microsec ] The operations permitted using data types based on time and duration are: time := time ± duration duration := duration ± duration duration := duration * numeric duration := duration / numeric duration := time - time as well as the standard comparisons of < (read as "before"), >, ≤ , and ≥ . Each such comparison yields a data element of base type boolean. Comparisons are defined only between elements of the same base type." [OOAData]
"For data elements that have the nature of names, we need to be able to define symbolic data types: data type <data type name> is symbolic length is (from <minimum number of characters> to ) <maximum number of characters> (default value is <character string>) The analyst specifies the maximum and minimum number of characters required based on his or her knowledge of the longest and shortest plausible values. Hence: data type gas name is symbolic length is from 2 to 15 default value is Helium The operations defined for symbolic data types are: - concatenate (represented as +); the result of concatenation is a data element of base type symbolic. - comparison for identical value, represented as = (identical in value) and != (not identical in value). The result of such a comparison yields a data element of base type boolean. - comparison for position in a collating sequence[5], represented as < (before), > (after), <= (before or identical), and >= (identical or after). The result of such a comparison yields a data element of base type boolean. [5] A collating sequence prescribes the order of all the characters in a specified character set, typically including letters, numbers, and punctuation marks. Collating sequences are defined in the implementation environment, and may vary from country to country depending on the concept of "alphabetical order" and the repertoire of characters or symbols used in the natural language." [OOAData]
A relationship instance reference is the type to which all relationship instances must conform. This is a core type that says relationship instances have a common set of operations defined for usage.
The ordinal core type automatically populated in the metamodel is specified as ascending and based upon identifier, because the only known operation is for traversing a collection of object instances. To support other ordinal uses in a process model, the user must create a user-defined ordinal type. The below gives more detail on ordinals: "Ordinal data types are used to express order, such as first, second, and so on. However, the subject of ordering is a lot more interesting that just this common example; hence the following digression. An ordering is always applied to a set of elements. The set can be finite or infinite. There are two types of orderings to consider. The first is the most familiar; it is a complete ordering. What this means is that you can express the concept of "before" (represented as <) between any two members of the set. Hence, 7 is before 26 ( 7 < 26 ). A complete ordering has the property of transitivity: If A is before B, and B is before C, then A is before C. A practical example would be the ordering of the cars that make up a freight train. Assume we define a first car. Then we could pick any two cars and easily determine which one was before the other. Far more interesting are the partial orderings. Consider this sketch of a partial ordering. A -> B -> C -> D + -> E -> F -> G Using the obvious interpretation, we can say that A < B (A is before B), C < D, C < E, and E < F. But we cannot say anything about the relationship between D and F: They are non-comparable. Examples of structures that are partially ordered include PERT charts, trees used for any purpose, interlock chains, the connectivity of an electric grid, and the like. All of these can be modeled in complete detail using standard OOA relationships; for examples see [Starr96] and Chapter 4 of Shlaer-Mellor Method: The OOA96 Report. Note, however, that when modeling such a structure, one frequently finds it necessary to employ quite a number of ancillary objects (such as root node, parent node, child node, and leaf node) together with a significant set of relationships all required to express a generally well-known concept. While this can be quite satisfying when one is in a purist frame of mind, the pragmatist points out that such constructions are often of limited value, obscuring, as they can, the true purpose of the model. This becomes particularly pertinent when constructing models of an architecture, where ordering is a particularly prominent theme (see The Timepoint Architecture chapter). Hence we have defined the ordinal base data type, leaving it to the judgment of the analyst as for when to use an ordinal attribute as opposed to using more fully expressive OOA objects and relationships. Returning now to the main theme, an ordinal data type is defined by: data type <data type name> is ordinal The operations permitted for ordinal data types are - the comparisons = and != (identical and not identical in value) - the comparisons < (read as "before"), >, <= , and >= . Each such comparison yields a data element of base type boolean if the ordering is complete, and of base type extended boolean if the ordering is partial." [OOAData] NOTE: This metamodel doesn''t support an extended boolean type, so a comp
The order specifier attribute determines the basis of the ordering. The order specifier can be an object attribute, if the ordinal is composed of objects, a meta-attribute, e.g., identifier, name, etc., common ordering based upon data type, i.e., numeric +/- 1, alphabetical for strings, etc., or physical placement. (A TBD symbol or keytword will be defined to indicate placement.) Placement is to be considered ordered by a means external to the data. e.g., an array. A placement ordinal will have means of inserting, moving, and removing ordered elements. Placement ordinals will also have associated marks, so placement can be based on platform considerations. e.g., memory location, timestamp, etc. All ordinals will have the ability to add and remove elements. The order specifier can be dynamically changed in the process models.
Numeric is as described in [OOAData] below. NOTE: The description isn''t a model. Some seeming attributes of numeric in the description might be modeled as their own objects. e.g., "units" aren''t always used, so cannot be an attribute. "If a data type is numeric in nature, write: data type <data type name> is numeric (base <N>) range is from <low limit> to <high limit> units are <unit symbol> precision is <smallest discriminant> ( default value is <value> ) where base N specifies the base of the quantities <low limit>, <high limit>, <smallest discriminant> and <value>. If base N is omitted, base 10 is assumed. Hence: data type ring diameter is numeric range is from 0 to 39 units are cm precision is 0.01 data type bit pattern is numeric base 8 range is from 0 to 177777 units are octal bits precision is 1 Note that the analyst does not specify whether a numeric data type will be implemented as an integer or a real number. This will ultimately be determined by the architecture, based on the native types available in the implementation language, the word length of these native types, and the range and precision required for the data type. As a result, the OOA models of any domain are entirely decoupled from the implementation technology, thereby maximizing the potential for reuse across a wide range of platforms and implementation languages. The operations permitted for numeric data types are: - the standard arithmetic operations +, -, * (multiplication), / (division), %% (division modulo N), and ** (exponentiation). The result of such an operation is again of base type numeric. - the standard arithmetic comparisons of = , != , <, >, <= , and >= . The result of such a comparison yields a data element of base type boolean." [OOAData]
An instance reference is the type to which all object instances must conform. This is a core type that says object instances have a common set of operations defined for usage.
"If a data type permits a finite set of values, define it as: data type <name> is enumerated values are <value 1 >, <value 2 >, . . . <value N > ( default value is <value k > ) 4 as in: data type IC color is enumerated values are red, blue, black, green, silver The only operations permitted for data elements of an enumerated data type are the comparison operations, represented as = (identical in value) and != (not identical in value). The result of either comparison yields a data element of type boolean." [OOAData]
"Similarly, to define a data type that represents duration, write data type <data type name> is duration range is from <low limit> to <high limit> units are [ year | month | day | hour | minute | second | millisec | microsec ] precision is <smallest discriminated value> The operations permitted using data types based on time and duration are: time := time ± duration duration := duration ± duration duration := duration * numeric duration := duration / numeric duration := time - time as well as the standard comparisons of < (read as "before"), >, ≤ , and ≥ . Each such comparison yields a data element of base type boolean. Comparisons are defined only between elements of the same base type." [OOAData]
Core types are defined within the context of the Shlaer-Mellor Method. Every Shlaer-Mellor model, adhering to this metamodel, will support these types. Core types are not intended to be multiply instantiated. Each core type is defined only once in the metamodel. Specialization of the core types are done through definitions based on the core types. These definitions are considered domain types, so they aren''t modeled in this metamodel. The enumeration definition is an exception to this rule, as it has a known structure.
"The boolean base data type is exactly what you expect: a pre-defined enumerated data type with values True and False. To define a domain-specific data type based on a boolean base type, write: data type <name> is boolean (default value is <value>) The operations permitted for data elements based on these base types include the comparison operations, represented as = (identical in value) and != (not identical in value). The result of either comparison yields a data element of base type boolean. The logical operations, not, and, & or, are defined in the standard way." [OOAData]
"To define a data type for data elements that represent arbitrary identifiers: data type <data type name> is arbitrary The implementation of an arbitrary type like all the base data types is determined by the architecture domain. Hence the analyst should make no assumptions as to how this is done: the arbitrary type may be implemented as a handle, an integer, a character string, or by any other scheme the architects devise. For this reason, the analyst cannot specify a default value for the base data type arbitrary." [OOAData]
Here are listings of all of the activies in the class and its state machine(s).
Operator association associates the operator for use in an equation.
select any type related by self->TYPE[R406] where selected.name == param.type; select many tyops related by self->TYOP[R406] where selected.type_name == param.type; for each tyop in tyops unrelate self from type across R406 using tyop; select one restype related by tyop->TYPE[R415]; unrelate restype from tyop across R415; delete object instance tyop; end for;
Here are listings of all of the activies in the class and its state machine(s).
select many operators related by self->OPER[R406];
for each operator in operators
operator.unassign(type:self.name);
select any type related by operator->TYPE[R406.''is used in a context established by''];
if (empty type)
delete object instance operator;
end if;
end for;
Here are listings of all of the activies in the class and its state machine(s).
select any result from instances of TYPE where selected.name == rcvd_evt.result;
if (empty result)
// Wait 10 milliseconds and retry, since type creation is asynchronous. This
// code could launch a creation event, but the responsibility lies outside of
// this process. This process only has to understand the asynchronous nature
// of type creation and acommodate it.
create event instance recreate of TYOP_A1:create(name:rcvd_evt.name, symbol:rcvd_evt.symbol, type:rcvd_evt.type, result:rcvd_evt.result) to TYOP class;
bridge retry_timer = TIM::timer_start(microseconds:10000, event_inst:recreate);
else
select any operator from instances of OPER where (selected.name == rcvd_evt.name) and (selected.symbol == rcvd_evt.symbol);
if (empty operator)
create object instance operator of OPER;
operator.name = rcvd_evt.name;
operator.symbol = rcvd_evt.symbol;
end if;
select any type from instances of TYPE where selected.name == rcvd_evt.type;
create object instance typed_op of TYOP;
relate operator to type across R406 using typed_op;
relate typed_op to result across R415;
// For assignment operators, make them the required operator if requestor is
// a core type (which it probably is).
if (operator.name == "assignment")
select one core related by type->CORE[R401];
if (not empty core)
relate core to operator across R419;
end if;
end if;
end if;
"This is a precise specification of the processing required to transform the Operands to produce either a return value or an update result, depending on the Typed Operator specialization." [miUML] NOTE: miUML has this typed as "psuedocode", because of not yet having an "Operator definition language". In BridgePoint, it''s declared as a derived type, so OAL can be used to define the operator.
self.definition=false;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many timds from instances of TIMD; if (cardinality timds == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "time"; core.type = data_t::TIME; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of TIMD attempted!"); generate TIMD2:destroy to self; end if;
"The operations permitted using data types based on time ... are:
time := time ± duration
as well as the standard comparisons of < (read as "before"), >, ≤ , and ≥ .
Each such comparison yields a data element of base type boolean.
Comparisons are defined only between elements of the same base type."
[OOAData]
time := time ± time
NOTE: For mixed type operations, conversion operators must be supported.
The explicit conversion cases are:
duration := time: time->duration
NOTE: The architecture should add boundary checks on this conversion, as
durations are often expressed in (e.g.,) microseconds. The system needs to
be able to support very large numbers if values are more than one hour.generate TYOP_A1:create(name:"assignment", symbol:":=", type:"time", result:"time") to TYOP class; generate TYOP_A1:create(name:"addition", symbol:"+", type:"time", result:"time") to TYOP class; generate TYOP_A1:create(name:"subtraction", symbol:"-", type:"time", result:"time") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"time", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"time", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"greater", symbol:">", type:"time", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"lesser", symbol:"<", type:"time", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"greater or equal", symbol:">=", type:"time", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"lesser or equal", symbol:"<=", type:"time", result:"boolean") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
Responsible for instantiating this core data type and all operations associated with it. NOTE: At the time of this writing, core data types are never expected to be deleted, as deleting a core type would require deletion of all user data types based on the core type and all attributes and synchronous functionality ultimately based on the core type. There is no logical default value to use as a fall back.
// Only create if type doesn''t exist select many symds from instances of SYMD; if (cardinality symds == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name="symbolic"; core.type = data_t::SYMBOLIC; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of SYMD attempted!"); generate SYMD2:destroy to self; end if;
Responsible for instantiating this core data type and all operations associated with it. NOTE: At the time of this writing, core data types are never expected to be deleted, as deleting a core type would require deletion of all user data types based on the core type and all attributes and synchronous functionality ultimately based on the core type. There is no logical default value to use as a fall back.
select one core related by self->CORE[R403]; if (not empty core) core.destroy(); unrelate core from self across R403; delete object instance core; end if;
"The operations defined for symbolic data types are:
- concatenate (represented as +); the result of concatenation is a data
element of base type symbolic.
- comparison for identical value, represented as = (identical in value) and
!= (not identical in value). The result of such a comparison yields a
data element of base type boolean.
- comparison for position in a collating sequence[5], represented as <
(before), > (after), <= (before or identical), and >= (identical or
after). The result of such a comparison yields a data element of base
type boolean.
[5] A collating sequence prescribes the order of all the characters in a
specified character set, typically including letters, numbers, and punctuation
marks. Collating sequences are defined in the implementation environment, and
may vary from country to country depending on the concept of "alphabetical
order" and the repertoire of characters or symbols used in the natural
language." [OOAData] generate TYOP_A1:create(name:"assignment", symbol:":=", type:"symbolic", result:"symbolic") to TYOP class; generate TYOP_A1:create(name:"concatenate", symbol:"+", type:"symbolic", result:"symbolic") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"symbolic", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"symbolic", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"greater", symbol:">", type:"symbolic", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"lesser", symbol:"<", type:"symbolic", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"greater or equal", symbol:">=", type:"symbolic", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"lesser or equal", symbol:"<=", type:"symbolic", result:"boolean") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many rrefs from instances of RREF; if (cardinality rrefs == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "relationship instance reference"; core.type = data_t::RELATIONSHIP_INSTANCE_REFERENCE; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of type RREF attempted!"); generate RREF2:destroy to self; end if;
The operations permitted for instance reference data types are
- the comparisons = and != (identical and not identical in value)
- the set existence checks of empty and not empty.generate TYOP_A1:create(name:"assignment", symbol:":=", type:"relationship instance reference", result:"relationship instance reference") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"relationship instance reference", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"relationship instance reference", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"empty", symbol:"empty", type:"relationship instance reference", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not empty", symbol:"not empty", type:"relationship instance reference", result:"boolean") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many ordds from instances of ORDD; if (cardinality ordds == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "ordinal"; core.type = data_t::ORDINAL; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of ORDD attempted!"); generate ORDD2:destroy to self; end if;
The operations permitted for instance reference data types are
- the comparisons = and != (identical and not identical in value)
- the set existence checks of empty and not empty.generate TYOP_A1:create(name:"assignment", symbol:":=", type:"ordinal", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"join", symbol:"+", type:"ordinal", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"ordinal", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"ordinal", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"empty", symbol:"empty", type:"ordinal", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not empty", symbol:"not empty", type:"ordinal", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"numeric", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"numeric", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"symbolic", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"symbolic", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"boolean", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"boolean", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"arbitrary", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"arbitrary", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"duration", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"duration", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"time", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"time", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"instance reference", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"instance reference", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"insert", symbol:"insert into", type:"function reference", result:"ordinal") to TYOP class; generate TYOP_A1:create(name:"remove", symbol:"remove from", type:"function reference", result:"ordinal") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
Responsible for instantiating this core data type and all operations associated with it. NOTE: At the time of this writing, core data types are never expected to be deleted, as deleting a core type would require deletion of all user data types based on the core type and all attributes and synchronous functionality ultimately based on the core type. There is no logical default value to use as a fall back.
// Only create if type doesn''t exist select many numis from instances of NUMI; if (cardinality numis == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "numeric"; core.type = data_t::NUMERIC; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of NUMI attempted!"); generate NUMI2:destroy to self; end if;
Responsible for instantiating this core data type and all operations associated with it. NOTE: At the time of this writing, core data types are never expected to be deleted, as deleting a core type would require deletion of all user data types based on the core type and all attributes and synchronous functionality ultimately based on the core type. There is no logical default value to use as a fall back.
select one core related by self->CORE[R403]; if (not empty core) core.destroy(); unrelate core from self across R403; delete object instance core; end if;
"the standard arithmetic operations +, -, * (multiplication), / (division), %% (division modulo N), and ** (exponentiation). The result of such an operation is again of base type numeric. the standard arithmetic comparisons of = , != , <, >, <= , and >=. The result of such an operation is of base type boolean." [OOAData]
generate TYOP_A1:create(name:"assignment", symbol:":=", type:"numeric", result:"numeric") to TYOP class; generate TYOP_A1:create(name:"addition", symbol:"+", type:"numeric", result:"numeric") to TYOP class; generate TYOP_A1:create(name:"subtraction", symbol:"-", type:"numeric", result:"numeric") to TYOP class; generate TYOP_A1:create(name:"multiplication", symbol:"*", type:"numeric", result:"numeric") to TYOP class; generate TYOP_A1:create(name:"division", symbol:"/", type:"numeric", result:"numeric") to TYOP class; generate TYOP_A1:create(name:"modulo", symbol:"%%", type:"numeric", result:"numeric") to TYOP class; generate TYOP_A1:create(name:"exponentiation", symbol:"**", type:"numeric", result:"numeric") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"numeric", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"numeric", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"greater", symbol:">", type:"numeric", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"lesser", symbol:"<", type:"numeric", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"greater or equal", symbol:">=", type:"numeric", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"lesser or equal", symbol:"<=", type:"numeric", result:"boolean") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many irefs from instances of IREF; if (cardinality irefs == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "instance reference"; core.type = data_t::INSTANCE_REFERENCE; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of type IREF attempted!"); generate IREF2:destroy to self; end if;
The operations permitted for instance reference data types are
- the comparisons = and != (identical and not identical in value)
- the set existence checks of empty and not empty.generate TYOP_A1:create(name:"assignment", symbol:":=", type:"instance reference", result:"instance reference") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"instance reference", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"instance reference", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"empty", symbol:"empty", type:"instance reference", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not empty", symbol:"not empty", type:"instance reference", result:"boolean") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many enums from instances of ENUM; if (cardinality enums == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "enumeration"; core.type = data_t::ENUMERATION; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of ENUM attempted!"); generate ENUM2:destroy to self; end if;
"The only operations permitted for data elements of an enumerated data type are the comparison operations, represented as = (identical in value) and != (not identical in value). The result of either comparison yields a data element of type boolean." [OOAData]
generate TYOP_A1:create(name:"assignment", symbol:":=", type:"enumeration", result:"enumeration") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"enumeration", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"enumeration", result:"boolean") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many durds from instances of DURD; if (cardinality durds == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "duration"; core.type = data_t::DURATION; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of DURD attempted!"); generate DURD2:destroy to self; end if;
"The operations permitted using data types based on ... duration are:
duration := duration ± duration
duration := duration * numeric
duration := duration / numeric
duration := time - time
as well as the standard comparisons of < (read as "before"), >, ≤ , and ≥ .
Each such comparison yields a data element of base type boolean.
Comparisons are defined only between elements of the same base type."
[OOAData]
NOTE: For mixed type operations, conversion operators must be supported.
The explicit conversion cases are:
duration * numeric: duration->numeric result: numeric
duration / numeric: duration->numeric result: numeric
duration := numeric: numeric->duration
duration := time: time->durationgenerate TYOP_A1:create(name:"assignment", symbol:":=", type:"duration", result:"duration") to TYOP class; generate TYOP_A1:create(name:"addition", symbol:"+", type:"duration", result:"duration") to TYOP class; generate TYOP_A1:create(name:"subtraction", symbol:"-", type:"duration", result:"duration") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"duration", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"duration", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"greater", symbol:">", type:"duration", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"lesser", symbol:"<", type:"duration", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"greater or equal", symbol:">=", type:"duration", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"lesser or equal", symbol:"<=", type:"duration", result:"boolean") to TYOP class; // It is highly recommended that the architecture handle conversions auto- // matically, so the analyst doesn''t have to explicitly add the conversion // operator. generate TYOP_A1:create(name:"convert to numeric", symbol:"->NUMI", type:"duration", result:"numeric") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
create object instance type of TYPE;
type.name = param.name;
create object instance domd of DOMD;
relate domd to type across R401;
select any mdom from instances of MDOM where selected.name == param.domain;
relate domd to mdom across R412;
select many cores from instances of CORE;
for each core in cores
if (core.type == param.coreType)
relate core to domd across R402;
break;
end if;
end for;
select one type related by self->TYPE[R401]; if (not empty type) type.remove(); unrelate type from self across R401; delete object instance type; end if; select one core related by self->CORE[R402.''is based on'']; unrelate self from core across R402.''is based on'';
Here are listings of all of the activies in the class and its state machine(s).
select one operator related by self->OPER[R419]; unrelate self from operator across R419; select one type related by self->TYPE[R401]; if (not empty type) type.remove(); unrelate type from self across R401; delete object instance type; end if; select many udts related by self->DOMD[R402]; for each udt in udts unrelate self from udt across R402; generate DOMD2:destroy() to udt; end for;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many comps from instances of COMP; if (cardinality comps == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "composite"; core.type = data_t::COMPOSITE; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of COMP attempted!"); generate COMP2:destroy to self; end if;
The operations permitted using data types based on composite are limited to equality comparison and assignment to another composite type.
generate TYOP_A1:create(name:"assignment", symbol:":=", type:"composite", result:"composite") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"composite", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"composite", result:"boolean") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many bools from instances of BOOL; if (cardinality bools == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; relate core to self across R403; type.name = "boolean"; core.type = data_t::BOOLEAN; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of BOOL attempted!"); generate BOOL2:destroy to self; end if;
"The operations permitted for data elements based on these base types include the comparison operations, represented as = (identical in value) and != (not identical in value). The result of either comparison yields a data element of base type boolean. The logical operations, not, and, & or, are defined in the standard way." [OOAData]
generate TYOP_A1:create(name:"assignment", symbol:":=", type:"boolean", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"boolean", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"boolean", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"logical not", symbol:"not", type:"boolean", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"logical and", symbol:"and", type:"boolean", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"logical or", symbol:"or", type:"boolean", result:"boolean") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many arids from instances of ARID; if (cardinality arids == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "arbitrary"; core.type = data_t::ARBITRARY; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of ARID attempted!"); generate ARID2:destroy to self; end if;
[OOAData] prescribes no operators for arbitrary. Arbitrary is treated like a composite, where the internals are unknown, so the only valid operations permitted using data types based on arbitrary are limited to equality comparison and assignment to another arbitrary type.
generate TYOP_A1:create(name:"assignment", symbol:":=", type:"arbitrary", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"equal", symbol:"=", type:"arbitrary", result:"boolean") to TYOP class; generate TYOP_A1:create(name:"not equal", symbol:"!=", type:"arbitrary", result:"boolean") to TYOP class;
Here are listings of all of the activies in the class and its state machine(s).
// Only create if type doesn''t exist select many arefs from instances of AREF; if (cardinality arefs == 1) create object instance type of TYPE; create object instance core of CORE; relate type to core across R401; type.name = "accessor reference"; core.type = data_t::ACCESSOR_REFERENCE; relate core to self across R403; self.generateSupportedOperators(); else LOG::LogFailure(message:"Multiple creation of type AREF attempted!"); generate AREF2:destroy to self; end if;
The operations permitted for instance reference data types are
- the comparisons = and != (identical and not identical in value)
- the set existence checks of empty and not empty.generate TYOP_A1:create(name:"assignment", symbol:":=", type:"accessor reference", result:"accessor reference") to TYOP class;
Table 16. Type
A core type always has at least one operator defined for it, but an operator might be defined for a domain type instead of a core type. The assignment operator would be good to establish this relationship, as all types have an assignment operator. i.e., what good is a datatype that can''t be assigned?
// Each core type is responsible for it''s own creation. generate BOOL1:create() to BOOL creator; generate COMP1:create() to COMP creator; generate DURD1:create() to DURD creator; generate TIMD1:create() to TIMD creator; generate NUMI1:create() to NUMI creator; generate ARID1:create() to ARID creator; generate ENUM1:create() to ENUM creator; generate ORDD1:create() to ORDD creator; generate SYMD1:create() to SYMD creator; generate IREF1:create() to IREF creator; generate AREF1:create() to AREF creator;
Bridges into the metamodel domain.
Rendered here are the contained package diagrams.
Incoming bridges for creating model elements of the Process Model subsystem as metamodel instances.
Table 18. Process Model Bridges
Add a constant value to the left or right hand operand of an expression. As the actual value isn''t that interesting to the metamodel, the parameter, name, is used to allow process model construction within the constraints the metamodel. The value of name is symbolic representation of the value is akin to using defines in C to represent "magic numbers".
Add a return value to the left or right operand of an expression. This bridge will be called when an accessor is part of an equation. e.g., a = a + sum(b, c) If the return value is on the right hand side of an assignment, it can be the return from the current process model. This call will be used whenever any synchronous accessor (synchronous bridge, object method, or attribute action) is added to a process model.
Adds an asynchronous bridge call to the process specified in the action specified. A synchronous bridge call will be added as a return value added to an operand.
Adds an empty process model to prepare it for addition of process modeling elements.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any acc from instances of ACC where selected.name == param.bridge_name;
if (empty acc)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Bridge, " + param.bridge_name + ", not instantiated!" );
else
select one brg related by acc->ASA[R505]->ASB[R506]->BRG[R3];
if (empty brg)
select one brg related by acc->SYA[R505]->SYB[R524]->BRG[R3];
end if;
select one ae related by brg->AE[R509];
select one act related by ae->ACT[R500];
if (not empty act)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Action already instantiated for bridge, " + param.bridge_name + "." );
else
create object instance act of ACT;
relate act to ae across R500;
LOG::LogInfo( message:"Action added to bridge," + param.bridge_name + ", without any processes." );
end if;
end if;
end if;
return result;
Adds an empty process model to prepare it for addition of process modeling elements.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any der from instances of DER where selected.derived_name == param.attribute;
if (empty der)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Derived attribute, " + param.attribute + ", not instantiated!" );
else
select any atr from instances of ATR where (selected.name == der.value_name) and selected.belongsTo( object:param.object );
if (empty atr)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Derived attribute, " + param.attribute + ", not a member of " + param.object + "!");
else
select one ae related by der->ATA[R522]->AE[R509];
select one act related by ae->ACT[R500];
if (not empty act)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Action already instantiated for derived attribute, " + param.attribute + "." );
else
create object instance act of ACT;
relate act to ae across R500;
LOG::LogInfo( message:"Action added to derived attribute," + param.attribute + ", without any processes." );
end if;
end if;
end if;
end if;
return result;
Adds an empty process model to prepare it for addition of process modeling elements.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any mth from instances of MTH where selected.name == param.method;
if (empty mth)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Method, " + param.method + ", not instantiated!" );
else
select one ae related by mth->AE[R509];
select one act related by ae->ACT[R500];
if (not empty act)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Action already instantiated for method, " + param.method + "." );
else
create object instance act of ACT;
relate act to ae across R500;
LOG::LogInfo( message:"Action added to method," + param.method + ", without any processes." );
end if;
end if;
end if;
return result;
Adds an empty process model to prepare it for addition of process modeling elements.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select any sta related by sub->LIF[R347]->SM[R300]->STA[R341] where selected.name == param.state;
if (empty sta)
select any sta related by sub->ASR[R354]->SM[R300]->STA[R341] where selected.name == param.state;
if (empty sta)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"State, " + param.state + ", not instantiated!" );
end if;
end if;
if ( creationResult_t::SUCCESS == result )
select one ae related by sta->AE[R509];
select one act related by ae->ACT[R500];
if (not empty act)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Action already instantiated for state, " + param.state + "." );
else
create object instance act of ACT;
relate ae to act across R500;
LOG::LogInfo( message:"Action added to state," + param.state + ", without any processes." );
end if;
end if;
end if;
end if;
return result;
Add an attribute of an object instance, already added to the process model, to the left-hand or right-hand operand of the specified expression.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select any atr related by sub->OBJ[R107]->OA[R129]->ATR[R124] where selected.name == param.attribute;
if (empty atr)
select any atr related by sub->PRP[R107]->SPA[R130]->ATR[R124] where selected.name == param.attribute;
end if;
if (empty atr)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Attribute, " + param.attribute + ", not instantiated!" );
else
// An object instance must exist to access the attribute instance.
select any trd related by pro->RE[R502]->EQU[R514]->EXP[R622]->LHO[R616]->OPRD[R615]->DUS[R631]->VAR[R624]->TRD[R626] where selected.name == param.instance;
if (empty trd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Unable to find object instance handle in this process model!" );
else
select any atn related by trd->VAR[R626]->VAL[R635]->INS[R629]->ATN[R643] where selected.attribute_name == param.attribute;
select one dus related by atn->VAR[R626]->DUS[R624];
select one oprd related by exp->LHO[R616]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Left hand operand not instantiated!" );
else
if (not param.leftHand)
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right hand operand not instantiated!" );
end if;
end if;
if (
Add an equation without expressions to the process specified within the action specified.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.ordinalPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.ordinalPosition ) + "!");
else
create object instance re of RE;
create object instance ela of ELA;
relate re to pro across R502 using ela;
create object instance equ of EQU;
relate equ to re across R514;
LOG::LogInfo( message: "Equation added to action without any expressions!" );
end if;
end if;
end if;
return result;
Add an expression, without operands, operation, or outcome, at the position specified to the equation of the process specified in the action specified.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
create object instance exp of EXP;
exp.ordinal_position = param.ordinalPosition;
relate exp to equ across R622;
LOG::LogInfo( message: "Expression added to equation without any operands!" );
end if;
end if;
end if;
end if;
return result;
Add an iteration process to the specified action at the specified ordinal position.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
create object instance pro of PRO;
pro.ordinal_position = param.ordinalPosition;
relate pro to act across R501;
create object instance csp of CSP;
csp.closure_position = param.closurePosition;
relate csp to pro across R536;
create object instance itp of ITP;
itp.current_index = 1;
relate itp to csp across R537;
end if;
end if;
return result;
Add a loop process to the specified action at the specified ordinal position.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
create object instance pro of PRO;
pro.ordinal_position = param.ordinalPosition;
relate pro to act across R501;
create object instance csp of CSP;
csp.closure_position = param.closurePosition;
relate csp to pro across R536;
create object instance lop of LOP;
relate lop to csp across R537;
end if;
end if;
return result;
Add an object to the right-hand operand of the specified expression as an instance. The only valid use of this is when you are creating an object instance for assignment to a variable for later use in the process model, which is why it is always the right-hand operand.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select one rho related by exp->RHO[R617];
if (empty rho)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right-hand operand not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
create object instance ins of INS;
relate ins to sub across R112;
// Create all attribute instances
sub.instantiateAttributes(objectInstance:ins.id);
// Create all method instances
sub.instantiateMethods(objectInstance:ins.id);
// Create state machine
select one lif related by sub->LIF[R347];
if (not empty lif)
create object instance lsm of LSM;
relate lsm to ins across R361;
relate lsm to lif across R360;
select any cre related by lif->SM[R300]->STA[R341]->LIV[R305]->CRE[R306];
relate cre to lsm across R348;
select any del related by lif->SM[R300]->STA[R341]->DEL[R305];
if (not empty del)
create object instance des of DES;
relate del to lsm across R349 using des;
end if;
end if;
// Find the identifiers for the instance and relate them to the instance.
select one prp related by sub->PRP[R107];
if (not empty prp)
select many ids related by sub->PRP[R107]->SPA[R130]->ATR[R124]->ID[R102];
for each id in ids
create object instance itn of ITN;
relate ins to id across R101 using itn;
end for;
else
select many ids related by sub->OBJ[R107]->OA[R129]->ATR[R124]->ID[R102];
Add a left-hand or right-hand operand to the expression. The order of addition to the expression is left-hand operand, right-hand operand, and then operator, and this is strictly enforced.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select one lho related by exp->LHO[R616];
if (param.leftHand)
if (not empty lho)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Left hand operand already created for this expression!" );
else
create object instance oprd of OPRD;
create object instance lho of LHO;
relate lho to oprd across R615;
relate lho to exp across R616;
LOG::LogInfo( message:"Left operand created without any data assignment!" );
end if;
else
if (empty lho)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Left hand operand must be created before right hand operand!" );
else
select one rho related by exp->RHO[R617];
if (not empty rho)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Right hand operand already created for this expression!" );
else
create object instance oprd of OPRD;
create object instance rho of RHO;
relate rho to oprd across R615;
relate rho to exp across R617;
LOG::LogInfo( message:"Right operand created without any data assignment!" );
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Add a path evaluation process to the specified action at the specified ordinal position. This creates the path evaluation specifier and opens the first path container.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
create object instance pro of PRO;
pro.ordinal_position = param.ordinalPosition;
relate pro to act across R501;
create object instance csp of CSP;
csp.closure_position = param.closurePosition;
relate csp to pro across R536;
create object instance pep of PEP;
pep.numPaths = 1;
relate pep to csp across R537;
end if;
end if;
return result;
Add a referential attribute of an object instance, already added to the process model, to the left-hand or right-hand operand of the specified expression.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select any ref related by sub->OBJ[R107]->OA[R129]->ATR[R124]->REF[R103] where selected.name == param.attribute;
if (empty ref)
select any ref related by sub->PRP[R107]->SPA[R130]->ATR[R124]->REF[R103] where selected.name == param.attribute;
end if;
if (empty ref)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Referential attribute, " + param.attribute + ", not instantiated!" );
else
// An object instance must exist to access the attribute instance.
select any trd related by pro->RE[R502]->EQU[R514]->EXP[R622]->LHO[R616]->OPRD[R615]->DUS[R631]->VAR[R624]->TRD[R626] where selected.name == param.instance;
if (empty trd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Unable to find object instance handle in this process model!" );
else
select any atn related by trd->VAR[R626]->VAL[R635]->INS[R629]->ATN[R643] where selected.attribute_name == param.attribute;
select one dus related by atn->VAR[R626]->DUS[R624];
select one oprd related by exp->LHO[R616]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Left hand operand not instantiated!" );
else
if (not param.leftHand)
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right hand operand not instantiated!" );
end if;
Add a Statement Process to the specified action at the specified ordinal position.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
create object instance pro of PRO;
pro.ordinal_position = param.ordinalPosition;
relate pro to act across R501;
create object instance stp of STP;
relate stp to pro across R536;
// Determine if container relationships need to be instantiated.
closest = 0.0;
select many csps from instances of CSP where ( selected.ordinal_position < param.ordinalPosition ) and ( selected.closure_position >= param.ordinalPosition );
for each csp in csps
// Position numbering is one-based, and the statement can''t be added at
// the control structure position.
if (csp.ordinal_position > closest)
closest = csp.ordinal_position;
end if;
end for;
select any csp from instances of CSP where selected.ordinal_position == closest;
if (not empty csp)
create object instance pns of PNS;
relate csp to pro across R538 using pns;
select one pep related by csp->PEP[R537];
if (not empty pep)
create object instance pas of PAS;
relate pep to pns across R539 using pas;
end if;
end if;
end if;
end if;
return result;
Returns the identifier of the action instance associated with the specified element. Will return an invalid identifier if the model isn''t correct for this action.
// Start with an invalid id.
// TODO: Verify this works
select any act from instances of ACT where selected.id != selected.id;
id = act.id;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any acc from instances of ACC where selected.name == param.bridge_name;
if (empty acc)
LOG::LogFailure( message:"Bridge, " + param.bridge_name + ", not instantiated!" );
else
select one brg related by acc->ASA[R505]->ASB[R506]->BRG[R3];
if (empty brg)
select one brg related by acc->SYA[R505]->SYB[R524]->BRG[R3];
end if;
select one ae related by brg->AE[R509];
select one act related by ae->ACT[R500];
if (empty act)
LOG::LogFailure( message:"Action not instantiated for bridge, " + param.bridge_name + "." );
else
id = act.id;
end if;
end if;
end if;
return id;
Returns the identifier of the action instance associated with the specified element. Will return an invalid identifier if the model isn''t correct for this action.
// Start with an invalid id.
select any act from instances of ACT where selected.id != selected.id;
id = act.id;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any der from instances of DER where selected.derived_name == param.attribute;
if (empty der)
LOG::LogFailure( message:"Derived attribute, " + param.attribute + ", not instantiated!" );
else
select any atr from instances of ATR where (selected.name == der.value_name) and selected.belongsTo( object:param.object );
if (empty atr)
LOG::LogFailure( message:"Derived attribute, " + param.attribute + ", not a member of " + param.object + "!");
else
select one ae related by der->ATA[R522]->AE[R509];
select one act related by ae->ACT[R500];
if (empty act)
LOG::LogFailure( message:"Action not instantiated for derived attribute, " + param.attribute + "." );
else
id = act.id;
end if;
end if;
end if;
end if;
return id;
Returns the identifier of the action instance associated with the specified element. Will return an invalid identifier if the model isn''t correct for this action.
// Start with an invalid id.
select any act from instances of ACT where selected.id != selected.id;
id = act.id;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any mth from instances of MTH where selected.name == param.method;
if (empty mth)
LOG::LogFailure( message:"Method, " + param.method + ", not instantiated!" );
else
select one ae related by mth->AE[R509];
select one act related by ae->ACT[R500];
if (empty act)
LOG::LogFailure( message:"Action not instantiated for method, " + param.method + "." );
else
id = act.id;
end if;
end if;
end if;
return id;
Returns the identifier of the action instance associated with the specified element. Will return an invalid identifier if the model isn''t correct for this action.
// Start with an invalid id.
select any act from instances of ACT where selected.id != selected.id;
id = act.id;
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select any sta related by sub->LIF[R347]->SM[R300]->STA[R341] where selected.name == param.state;
if (empty sta)
select any sta related by sub->ASR[R354]->SM[R300]->STA[R341] where selected.name == param.state;
if (empty sta)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"State, " + param.state + ", not instantiated!" );
end if;
end if;
if ( creationResult_t::SUCCESS == result )
select one ae related by sta->AE[R509];
select one act related by ae->ACT[R500];
if (empty act)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Action not instantiated for state, " + param.state + "." );
else
id = act.id;
end if;
end if;
end if;
end if;
return id;
Add an enumeration value to the left or right hand operand of an expression.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select any enud from instances of ENUD where selected.name == param.enumerationName;
if (empty enud)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Enumeration, " + param.enumerationName + ", not instantiated!" );
else
select any enuv related by enud->ENUV[R420] where selected.name == param.valueName;
if (empty enuv)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Enumeration value, " + param.valueName + ", not instantiated for ," + param.enumerationName + "!" );
else
select one dus related by enuv->VAL[R629]->DUS[R624];
select one oprd related by exp->LHO[R616]->OPRD[R615];
if (not param.leftHand)
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right hand operand not instantiated!" );
end if;
end if;
if (not empty oprd)
relate oprd to dus across R631;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Add a transient variable to the left or right hand operand of an expression.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any re related by pro->RE[R502];
select one equ related by re->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select any type from instances of TYPE where selected.name == param.typeName;
if (empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Type, " + param.typeName + ", not instantiated!" );
else
select one oprd related by exp->LHO[R616]->OPRD[R615];
if (not param.leftHand)
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right hand operand not instantiated!" );
end if;
end if;
if (not empty oprd)
create object instance var of VAR;
create object instance trd of TRD;
trd.name = param.name;
relate trd to var across R626;
create object instance dus of DUS;
relate dus to var across R624;
relate dus to type across R625;
relate dus to re across R514;
LOG::LogInfo( message:"Transient variable created with no value and no assigned operand!" );
relate oprd to dus across R631;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Add a constant value to the left or right hand operand of an expression.
As the actual value isn''t that interesting to the metamodel, the parameter,
name, is used to allow process model construction within the constraints the
metamodel. The value of name is symbolic representation of the value is akin to
using defines in C to represent "magic numbers".
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any re related by pro->RE[R502];
select one equ related by re->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select any type from instances of TYPE where selected.name == param.typeName;
if (empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Type, " + param.typeName + ", not instantiated!" );
else
select one oprd related by exp->LHO[R616]->OPRD[R615];
if (not param.leftHand)
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right hand operand not instantiated!" );
end if;
end if;
if (not empty oprd)
create object instance usv of USV;
usv.value_name = param.name;
relate usv to type across R636;
create object instance val of VAL;
relate usv to val across R629;
create object instance dus of DUS;
relate dus to val across R624;
relate dus to type across R625;
create object instance re of RE;
relate dus to re across R514;
relate oprd to dus across R631;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Add a return value to the left or right operand of an expression. This bridge
will be called when an accessor is part of an equation. e.g., a = a + sum(b, c)
If the return value is on the right hand side of an assignment, it can be
the return from the current process model.
This call will be used whenever any synchronous accessor (synchronous
bridge, object method, or attribute action) is added to a process model. result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select any rvl from instances of RVL where selected.access_name == param.name;
if (empty rvl)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Return value, " + param.name + ", not instantiated!" );
else
select one dus related by rvl->VAL[R629]->DUS[R624];
select one oprd related by exp->LHO[R616]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Left hand operand not instantiated!" );
else
if (not param.leftHand)
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right hand operand not instantiated!" );
end if;
end if;
if (not empty oprd)
select one acc related by rvl->SYA[R529]->ACC[R505];
if ((not param.leftHand) and (act.getAccessorName() == acc.name))
relate oprd to dus across R631;
else
relate oprd to dus across R631;
instId = acc.instantiate();
select any ain from instances of AIN where selected.id == instId;
ain.addToProcessModel( actionId:act.id, ordinalPosition:param.processPosition );
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Adds an asynchronous bridge call to the process specified in the action
specified.
A synchronous bridge call will be added as a return value added to an
operand.result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.ordinalPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.ordinalPosition ) + "!");
else
select any asb from instances of ASB where selected.name == param.name;
if (empty asb)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Bridge, " + param.name + "not instantiated!");
else
select one acc related by asb->ASA[R506]->ACC[R505];
instId = acc.instantiate();
select any ain from instances of AIN where selected.id == instId;
ain.addToProcessModel( actionId:act.id, ordinalPosition:param.ordinalPosition );
end if;
end if;
end if;
end if;
return result;
Adds an event accessor to the process specified in the action specified.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.ordinalPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.ordinalPosition ) + "!");
else
// TODO: Event instances require an object instance
select any evt from instances of EVT where (selected.name == param.name) and (selected.object_name == param.object);
if (empty evt)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Event, " + param.name + ", not instantiated for object, " + param.object + "!" );
else
select one acc related by evt->ASA[R506]->ACC[R505];
instId = acc.instantiate();
select any ain from instances of AIN where selected.id == instId;
ain.addToProcessModel( actionId:act.id, ordinalPosition:param.ordinalPosition );
end if;
end if;
end if;
end if;
return result;
Creates an instance of the specified relationship and attaches it to the operand at the specified position.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select any sub from instances of SUB where selected.name == param.toObject;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"To object, " + param.toObject + ", not instantiated!" );
else
select any irl from instances of IRL where (selected.number == param.relationshipNumber) and ((selected.left_object_name == param.toObject) or (selected.right_object_name == param.toObject));
if (empty irl)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Relationship, R" + TC::intToString( i: param.relationshipNumber ) + ", not instantiated or not related to object, " + param.toObject + "!" );
else
select one oprd related by exp->LHO[R616]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Left hand operand not instantiated!" );
else
if (not param.leftHand)
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right hand operand not instantiated!" );
end if;
end if;
if (not empty oprd)
create object instance rin of RIN;
relate rin to irl across R638;
create object instance val of VAL;
relate val to rin across R629;
create object instance dus of DUS;
relate dus to val across R624;
select any rref from instances of RREF;
relate rin to rref across R421;
select one type related by rref->CORE[R403]->TYPE[R401];
relate type to dus across R625;
relate oprd to dus across R631;
end if;
end if;
end if;
Add an uninitialized parameter instance to the accessor process model at the specified operand. Upon creation of an instance of the accessor and assignment of value to the parameter, the uninitialized parameter instance will become an initialized parameter instance.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
prmAccName = act.getAccessorName();
select any prm from instances of PRM where (selected.name == param.parameter) and (selected.accessor_name == prmAccName);
if (empty prm)
select one sta related by act->AE[R500]->STA[R509];
if (not empty sta)
select any evp from instances of EVP where (selected.name == param.parameter) and (selected.state_name == prmAccName);
if (not empty evp)
select one prm related by evp->PRM[R542];
end if;
end if;
end if;
if (empty prm)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No parameter instance instantiated with the given identifier!");
else
select one oprd related by exp->LHO[R616]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Left hand operand not instantiated!" );
else
if (not param.leftHand)
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right hand operand not instantiated!" );
end if;
end if;
if (not empty oprd)
create object instance prn of PRN;
relate prn to prm across R645;
create object instance var of VAR;
relate var to prn across R626;
create object instance val of VAL;
relate val to var across R635;
// Creating an uninitialized variable as empty set
// We only need one empty set value for all variables using it.
select any emp from instances of EMP;
if (empty emp)
create object instance emp of EMP;
end if;
relate emp to val across R629;
Add a perspective to the specified relationship instance at the specified operand position.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (param.leftHand)
select one oprd related by exp->LHO[R616]->OPRD[R615];
end if;
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No operand for expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select one rin related by oprd->DUS[R631]->VAL[R624]->RIN[R629];
if (empty rin)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No relationship instance at the operand for expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select one psp related by rin->PSP[R216];
if (not empty psp)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Relationship instance already has perspective, " + psp.phrase + "!" );
else
create object instance trv of TRV;
select one psp related by rin->IRL[R638]->SYR[R201]->SYP[R206]->PSP[R204];
if (empty psp)
select one psp related by rin->IRL[R638]->BIN[R201]->ACP[R207]->ASP[R205]->PSP[R204];
if (empty psp)
select one psp related by rin->IRL[R638]->BIN[R201]->PSS[R208]->ASP[R205]->PSP[R204];
end if;
end if;
relate psp to rin across R216 using trv;
create object instance re of RE;
relate re to psp across R514;
create object instance ela of ELA;
relate re to pro across R502 using ela;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Assigns the named value, or the value help by a named variable, to the named parameter at the given position in a process model.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any prn related by pro->RE[R502]->DUS[R514]->VAR[R624]->PRN[R626] where selected.parameter_name == param.parameter;
if (empty prn)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No parameter named, " + param.parameter + ", in process!" );
else
select any equ related by pro->RE[R502]->EQU[R514];
if (not empty equ)
// Accessor is being used in an equation, so make sure the upi is correct upi.
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select one rvl related by exp->RHO[R617]->OPRD[R615]->DUS[R631]->VAL[R624]->RVL[R629];
if (param.leftHand)
select one rvl related by exp->LHO[R616]->OPRD[R615]->DUS[R631]->VAL[R624]->RVL[R629];
end if;
if (empty rvl)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No accessor at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select any prn related by rvl->SYA[R529]->ACC[R505]->AIN[R640]->PRN[R647] where selected.parameter_name == param.parameter;
if (empty prn)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No parameter named, " + param.parameter + ", at position, " + TC::realToString( r: param.expressionPosition ) + "!" );
end if;
end if;
end if;
end if;
end if;
if ( creationResult_t::SUCCESS == result )
// Grab the empty set value
select one val related by prn->VAR[R626]->VAL[R635];
oldval = val;
// Find named value or variable
select many duss related by pro->RE[R502]->DUS[R514];
for each dus in duss
select one usv related by dus->VAL[R624]->USV[R629] where selected.value_name == param.name;
if (empty usv)
select one trd related by dus->VAR[R624]->TRD[R626] where selected.name == param.name;
if (empty trd)
select one atn related by dus->VAR[R624]->ATN[R626] where selected.attribute_name == param.name;
if (empty atn)
select one prn related by dus->VAR[R624]->PRN[R626] where selected.parameter_name == param.name;
if (not empty prn)
Adds a the specified keyword value to the process model at the specified statement position.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select one oprd related by exp->LHO[R616]->OPRD[R615];
if (not param.leftHand)
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Right hand operand not instantiated!" );
end if;
end if;
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Left hand operand not instantiated!" );
else
select any keyi from instances of KEYI where selected.keyword == param.name;
if (empty keyi)
select any key from instances of KEY;
create object instance keyi of KEYI;
keyi.keyword = param.name;
relate keyi to key across R423;
create object instance val of VAL;
relate keyi to val across R629;
create object instance dus of DUS;
relate val to dus across R624;
select one type related by key->CORE[R403]->TYPE[R401];
relate type to dus across R625;
relate oprd to dus across R631;
else
select one dus related by keyi->VAL[R629]->DUS[R624];
relate oprd to dus across R631;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any act from instances of ACT where selected.id == param.actionId;
if (empty act)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Action not instantiated!" );
else
select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
if (empty pro)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any equ related by pro->RE[R502]->EQU[R514];
if (empty equ)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
else
select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
if (empty exp)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
else
select one oprd related by exp->RHO[R617]->OPRD[R615];
if (empty oprd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No operand has been added to the expression!");
else
select any tyop from instances of TYOP where (selected.operation_name == param.operator) and (selected.type_name == param.type) and (selected.result_type_name == param.resultType);
if (empty tyop)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No typed operator, " + param.operator + ", with type, " + param.type + ", and result type, " + param.resultType + ", instantiated!");
else
relate tyop to exp across R632;
create object instance out of OUT;
relate out to exp across R611;
relate out to tyop across R634;
relate out to oprd across R618;
end if;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Incoming bridges for creating model elements of the Object Model subsystem as metamodel instances.
Table 19. Object Model Bridges
Add the relationship path from a non-referential attribute to the attribute it is derived from. Process modeling of the derivation is added in another bridge.
Create a binary relationship between two specified object instances, or create a temporary binary relationship between one or two specified objects for the purpose of statically verifying an object model. A binary relationship between the same object must specify the object in both the passiveObject and activeObject parameters. The temporary instances are created by setting both instance parameters to zero. Only setting one to zero is an error. The active/passive terminology used is reflective of how verb phrases are often used in relationships with one using an active perspective and one using a passive perspective. It is a differentiator in the metamodel, but not a hard rule for Shlaer-Mellor modeling. If the perspective is unclear or the same in both directions, then just arbitrarily assign the parameters. Referential cheatsheet: (All are reflexive) 1:1 - choose either side 1:1c - 1c 1:M - M 1:Mc - Mc 1c:1c - use associative object 1c:M - use associative object 1c:Mc - use associative object M:M - use associative object Mc:M - use associative object Mc:Mc - use associative object
Create a Shlaer-Mellor intersecting subtype object of the specified supertype objects using the specified relationships in the specified domain. The subtype and supertypes specify the intersection of two sets (objects). The intersecting subtype might have already be created, and this call is just specifying another set participating in the intersection, or the subtype might already exist as a non-intersecting subtype; this call is then transforming the non-intersecting subtype into an intersecting subtype.
Set an existing relationship to be constrained as a composition from it''s participation in a relationship loop, rather than by referential attributes. "[When a relationship is the logical consequence of other relationships,] Such a relationship is said to be formed by composition (as in composition of functions in mathematics. [...] A relationship formed by composition cannot be formalized in referential attributes, since the connections between the instances is already given by the connections between the [composing relationships]. A relationship formed by composition is annotated on the model as [composed relationship = 1st composing relationship + 2nd composing relationship [+ nth composing relationship ...]]." [OL:MWS] "Composed Relationships. Another special case occurs when the constraint on the referential attribute is such that it identifies a single instance of the associated object. [...] Composition of relationships captures the constraint directly in data [...] However the use of composition is limited in that it requires that the constraint always identify a single associated instance." [OOA96] Both definitions identify compositions as relationship combinations that loop back to the originating instance. [miUML] calls compositions, "Constrained Loops", because the compostion equation forms a constraint on the object instances allowed to participate. [OOA96] also discusses collapsed referentials, but the example shows them to be an alternative way to draw compositions on the object model. This metamodel will only model a composition and leave the way to display it up to the model editor.
Create a domain for the purposes of model verification. This creation will always result in a failure, due to the constraint that a domain model must contain at least one object. A log entry will be created for any failure. A duplication failure will be reported with higher precedence.
Create an incoming bridge to the modeled domain. The bridge is created as an asynchronous bridge, which can be changed to synchronous by adding a return type via another provided bridge of this metamodel.
Create an outgoing bridge between the modeled domain and an external domain. The bridge is created as an asynchronous bridge, which can be changed to synchronous by adding a return type via another provided bridge of this metamodel.
Add the relationship path from a non-referential attribute to the attribute it
is derived from.
Process modeling of the derivation is added in another bridge.result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any subtd from instances of SUB where selected.name == param.object_to_derive;
if (empty subtd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object_to_derive + ", not instantiated!" );
else
select any subdf from instances of SUB where selected.name == param.object_derived_from;
if (empty subdf)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object_derived_from + ", not instantiated!" );
else
select any atd from instances of ATR where (selected.name == param.attribute_to_derive) and selected.belongsTo( object: subtd.name );
if (empty atd)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Attribute, " + param.attribute_to_derive + " not instantiated!." );
else
select any adf from instances of ATR where (selected.name == param.attribute_derived_from) and selected.belongsTo( object: subdf.name );
if (empty adf)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Attribute, " + param.attribute_derived_from + " not instantiated!." );
else
create object instance der of DER;
select one nrad related by atd->NRA[R103];
relate adf to nrad across R127 using der;
create object instance ae of AE;
create object instance ata of ATA;
relate ae to ata across R509;
relate ata to der across R522;
create object instance acc of ACC;
create object instance sya of SYA;
relate acc to sya across R505;
create object instance isy of ISY;
relate isy to sya across R524;
relate isy to ata across R534;
create object instance rvl of RVL;
select one type related by nrad->TYPE[R123];
relate type to sya across R529 using rvl;
create object instance atype of TYPE;
create object instance core of CORE;
relate atype to core across R401;
end if;
end if;
end if;
end if;
end if;
return result;
Create an attribute for a given object with type and identification qualifiers. It should be noted, that attribute derivations are created in a separate step.
result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create attribute failed due to invalid attribute name, " + param.name + "." );
else
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select any type from instances of TYPE where selected.name == param.type;
if (empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Data type, " + param.type + ", not instantiated!" );
else
select any oa from instances of OA where selected.object_name == param.object;
select any spa from instances of SPA where selected.subtype_name == param.object;
if (not empty oa or not empty spa)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Attribute already instantiated!" );
else
create object instance attribute of ATR;
create object instance nra of NRA;
relate nra to attribute across R103;
relate nra to type across R123;
if (0 != param.identifier)
create object instance idp of IDP;
create object instance id of ID;
relate id to attribute across R102 using idp;
idp.groupId = param.identifier;
end if;
select any obj from instances of OBJ where selected.name == sub.name;
if (empty obj)
// This is a specializing attribute.
create object instance spa of SPA;
relate spa to attribute across R124;
select one prp related by sub->PRP[R107];
relate spa to prp across R130;
select many sbts related by prp->SBT[R122];
for each sbt in sbts
select any sbs related by sbt->OBS[R126]->SBS[R125];
if (not empty sbs)
select one obs related by sbs->OBS[R125];
unrelate sbs from obs across R125;
relate obs to sbs across R125;
else
create object instance obs of OBS;
relate spa to obs across R125;
relate obs to sbt across R126;
end if;
end for;
else
create object instance oa of OA;
relate oa to obj across R129;
relate oa to attribute across R124;
end if;
end if;
end if;
end if;
end if;
end if;
Create a binary relationship between two specified object instances, or create
a temporary binary relationship between one or two specified objects for the
purpose of statically verifying an object model.
A binary relationship between the same object must specify the object in
both the passiveObject and activeObject parameters.
The temporary instances are created by setting both instance parameters to
zero. Only setting one to zero is an error.
The active/passive terminology used is reflective of how verb phrases are
often used in relationships with one using an active perspective and one using
a passive perspective. It is a differentiator in the metamodel, but not a hard
rule for Shlaer-Mellor modeling. If the perspective is unclear or the same in
both directions, then just arbitrarily assign the parameters.
Referential cheatsheet:
(All are reflexive)
1:1 - choose either side
1:1c - 1c
1:M - M
1:Mc - Mc
1c:1c - use associative object
1c:M - use associative object
1c:Mc - use associative object
M:M - use associative object
Mc:M - use associative object
Mc:Mc - use associative object
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
elif (("" == param.activePhrase) or ("" == param.passivePhrase))
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"This metamodel requires verb phrases at both ends of the binary relationship!" );
else
select any associative from instances of SUB where selected.name == param.associativeObject;
if (empty associative and
((param.activeMany and param.passiveMany) or (param.activeConditional and param.passiveConditional) or
(param.activeMany and param.passiveConditional) or (param.activeConditional and param.passiveMany)))
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"This metamodel enforces use of associative objects for all M:M, M:c, c:M, and c:c relationships!" );
else
select any irl from instances of IRL where selected.number == param.number;
if (not empty irl)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Duplication of relationship number!" );
else
select any actSub from instances of SUB where selected.name == param.activeObject;
if (empty actSub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Active object, " + param.activeObject + ", not instantiated!" );
else
select any passSub from instances of SUB where selected.name == param.passiveObject;
if (empty passSub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Passive object, " + param.passiveObject + ", not instantiated!" );
else
// Create relationship
create object instance rel of REL;
create object instance irl of IRL;
relate actSub to passSub across R133.''is related to'' using irl;
relate irl to rel across R200;
create object instance ncm of NCM;
relate ncm to irl across R213;
create object instance bin of BIN;
relate irl to bin across R201;
// Add perspectives
create object instance apsp of PSP;
apsp.phrase = param.activePhrase;
apsp.conditional = param.activeConditional;
if (param.activeMany)
create object instance amnyp of MNYP;
relate amnyp to apsp across R210;
else
create object instance aonep of ONEP;
relate aonep to apsp across R210;
end if;
create object instance aasp of ASP;
relate aasp to apsp across R204;
create object instance aacp of ACP;
relate aacp to aasp across R205;
relate aacp to bin across R207;
create object instance ppsp of PSP;
ppsp.phrase = param.passivePhrase;
ppsp.conditional = param.passiveConditional;
// Add multiplicity
if (param.passiveMany)
create object instance pmnyp of MNYP;
relate pmnyp to ppsp across R210;
else
create object instance ponep of ONEP;
relate ponep to ppsp across R210;
end if;
create object instance pasp of ASP;
relate pasp to ppsp across R204;
c
Create a Shlaer-Mellor intersecting subtype object of the specified supertype
objects using the specified relationships in the specified domain.
The subtype and supertypes specify the intersection of two sets (objects).
The intersecting subtype might have already be created, and this call is
just specifying another set participating in the intersection, or the subtype
might already exist as a non-intersecting subtype; this call is then
transforming the non-intersecting subtype into an intersecting subtype.
result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create subtype failed due to invalid subtype name, " + param.name + ".");
else
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any supersub1 from instances of SUB where selected.name == param.superset1;
if (empty supersub1)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Supertype object, " + param.superset1 + ", not instantiated!" );
else
select any supersub2 from instances of SUB where selected.name == param.superset2;
if (empty supersub2)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Supertype object, " + param.superset2 + ", not instantiated!" );
else
// Each supersub must belong to a separate set. Intersecting subsets
// always belong to different sets, otherwise they are actually a
// multiway subtyping.
select any obj from instances of OBJ where selected.hasSubtype( subtype:supersub1.name ) and selected.hasSubtype( subtype:supersub2.name );
if (not empty obj)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Supertypes belong to the same object!" );
else
// We could be transforming an existing NSB to an ISB, adding an
// existing ISB to another supertype, or creating a new subtype.
select any sub from instances of SUB where (selected.name == param.name) or (selected.keyletters == param.keyletters);
if (empty sub)
create object instance sub of SUB;
sub.name = param.name;
sub.keyletters = param.keyletters;
create object instance prp of PRP;
relate sub to prp across R107;
create object instance isb of ISB;
relate isb to prp across R108;
else
select any sup1 related by sub->PRP[R107]->ISB[R108]->ITS[R135]->OBS[R125] where selected.supertype_id == param.supertype1;
select any sup2 related by sub->PRP[R107]->ISB[R108]->ITS[R135]->OBS[R125] where selected.supertype_id == param.supertype2;
if (not_empty sup1 and not_empty sup2)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message: "Intersecting subtyping already exists!" );
else
// Transform to ISB
select one nsb related by sub->PRP[R107]->NSB[R108];
if (not empty nsb)
select one prp related by sub->PRP[R107];
unrelate nsb from prp across R108;
delete object instance nsb;
create object instance isb of ISB;
relate isb to prp across R108;
end if;
end if;
end if;
select many objs from instances of OBJ where selected.hasSubtype( subtype:supersub1.name );
for each obj1 in objs
select one prp related by sub->PRP[R107];
select one isb related by prp->ISB[R108];
select any obj related by isb->OBJ[R135] where selected.name == obj1.name;
if (empty
Add an object method to an existing object or subset.
result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create method failed due to invalid method name, " + param.name + "." );
else
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select any mth related by sub->PRP[R107]->SBT[R122]->OBS[R126]->SMT[R125]->IM[R533]->MTH[R532] where selected.name == param.name;
if (empty mth)
select any mth related by sub->OBJ[R107]->NM[R131]->IM[R533]->MTH[R532] where selected.name == param.name;
elif (empty mth and not param.instanceBased)
select any mth related by sub->OBJ[R107]->OM[R132]->MTH[R532] where selected.name == param.name;
end if;
if (not empty mth)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Method, " + param.name + ", already instantiated!" );
else
select one obj related by sub->OBJ[R107];
if (empty obj and not param.instanceBased)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", is a subtype, but instance based isn''t specified!");
else
create object instance mth of MTH;
create object instance ae of AE;
relate mth to ae across R509;
create object instance isy of ISY;
relate isy to mth across R534;
create object instance sya of SYA;
relate sya to isy across R524;
create object instance acc of ACC;
acc.name = param.name;
relate acc to sya across R505;
if (param.instanceBased)
create object instance im of IM;
relate im to mth across R532;
if (empty obj)
create object instance smt of SMT;
relate smt to im across R533;
select one prp related by sub->PRP[R107];
select many sbts related by prp->SBT[R122];
for each sbt in sbts
select any sbs related by sbt->OBS[R126]->SBS[R125];
if (empty sbs)
create object instance obs of OBS;
relate smt to obs across R125;
relate obs to sbt across R126;
else
select one obs related by sbs->OBS[R125];
unrelate sbs from obs across R125;
relate smt to obs across R125;
end if;
end for;
else
create object instance nm of NM;
relate nm to im across R533;
relate nm to obj across R131;
end if;
else
create object instance om of OM;
relate om to mth across R532;
relate om to obj across R132;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Create a Shlaer-Mellor non-intersecting subtype object of the specified supertype object using the specified relationship in the specified domain.
result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create subtype failed due to invalid subtype name, " + param.name + ".");
else
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any supersub from instances of SUB where selected.name == param.supertype;
if (empty supersub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Supertype object, " + param.supertype + ", not instantiated!" );
else
select any sub from instances of SUB where (selected.name == param.name) or (selected.keyletters == param.keyletters);
if (not empty sub)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Duplication of subtype name, " + sub.name + ", or keyletters," + sub.keyletters + "!" );
else
create object instance sub of SUB;
create object instance prp of PRP;
relate sub to prp across R107;
create object instance nsb of NSB;
relate prp to nsb across R108;
select any sup from instances of SUP where selected.id == param.relationship;
if (empty sup)
create object instance sup of SUP;
// Determine if object or subtype partitioning
select one obj related by supersub->OBJ[R107];
if (not empty obj)
create object instance chd of CHD;
relate sup to obj across R134 using chd;
else
select one superprp related by supersub->PRP[R107];
create object instance mlv of MLV;
relate sup to superprp across R114 using mlv;
end if;
end if;
relate sup to nsb across R136;
create object instance sbt of SBT;
relate prp to sup across R122 using sbt;
create object instance obs of OBS;
relate obs to sbt across R126;
// All non-intersecting subtypes are initially created as a
// subsequent specialization. The subtype is migrated when any other
// type of specialization is added.
create object instance sbs of SBS;
relate sbs to obs across R125;
end if;
end if;
end if;
end if;
return result;
Create a Shlaer-Mellor object or root supertype object in the specified domain.
result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create object failed due to invalid object name, " + param.name + "." );
else
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any obj from instances of OBJ where selected.name == param.name;
if (not empty obj)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Duplication of object name, " + obj.name + "!" );
else
create object instance obj of OBJ;
relate obj to domain across R105;
create object instance sub of SUB;
sub.name = param.name;
if ("" == param.keyletters)
sub.keyletters = param.name;
else
sub.keyletters = param.keyletters;
end if;
LOG::LogInfo( message:"Object, " + param.name + ", created with no attributes." );
end if;
end if;
end if;
return result;
Creates a symmetric reflexive relationship on the specified object. "4.2 Modeling Symmetric Reflexive Relationships On the Information Model, show a symmetric relationship with a relationship line that loops back to the object. Since, by definition, such a relationship must have the same name, multiplicity, and conditionality at each end, name and characterize the relationship at one end only. To ensure that an instance of the relationship appears only once in the model, always formalize the relationship with an associative object regardless of the multiplicity of the relationship itself. In Figure 4.1 we show the Employee WORKS WITH Employee relationship so formalized." [OOA96] Unlike The OOA96 Report, this metamodel only requires an associative object for relationship multiplicities that normally require an associative object. For symmetric reflexive, there is only the one multiplicity that doesn''t require an associative object.
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
elif ("" == param.phrase)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"This metamodel requires a verb phrase on a unary relationship!" );
else
select any associative from instances of SUB where selected.name == param.associativeObject;
if (empty associative and (param.many or param.conditional))
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"This metamodel enforces use of associative objects for all M:M, M:c, c:M, and c:c relationships!" );
else
select any irl from instances of IRL where selected.number == param.number;
if (not empty irl)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Duplication of relationship number!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
// Create relationship
create object instance rel of REL;
create object instance irl of IRL;
relate sub to sub across R133.''is related to'' using irl;
relate irl to rel across R200;
create object instance ncm of NCM;
relate ncm to irl across R213;
create object instance syr of SYR;
relate syr to irl across R201;
// Add perspective
create object instance psp of PSP;
create object instance syp of SYP;
relate syp to psp across R204;
relate syr to syp across R206;
// Add multiplicity
if (param.many)
create object instance mnyp of MNYP;
relate mnyp to psp across R210;
else
create object instance onep of ONEP;
relate onep to psp across R210;
end if;
// Determine referential location
idSub = sub;
if (not empty associative)
idSub = associative;
end if;
// Find identifiers and create referentials
idSub.associateReferentials( relationship:irl.number );
if (not empty associative)
create object instance rel of REL;
create object instance arl of ARL;
relate arl to rel across R200;
relate arl to irl across R212;
relate idSub to arl across R202;
end if;
end if;
end if;
end if;
end if;
Set an existing relationship to be constrained as a composition from it''s
participation in a relationship loop, rather than by referential attributes.
"[When a relationship is the logical consequence of other relationships,]
Such a relationship is said to be formed by composition (as in composition of
functions in mathematics. [...] A relationship formed by composition cannot be
formalized in referential attributes, since the connections between the
instances is already given by the connections between the [composing
relationships].
A relationship formed by composition is annotated on the model as [composed
relationship = 1st composing relationship + 2nd composing relationship [+ nth
composing relationship ...]]." [OL:MWS]
"Composed Relationships. Another special case occurs when the constraint on the
referential attribute is such that it identifies a single instance of the
associated object. [...] Composition of relationships captures the constraint
directly in data [...] However the use of composition is limited in that it
requires that the constraint always identify a single associated instance."
[OOA96]
Both definitions identify compositions as relationship combinations that loop
back to the originating instance. [miUML] calls compositions, "Constrained
Loops", because the compostion equation forms a constraint on the object
instances allowed to participate.
[OOA96] also discusses collapsed referentials, but the example shows them
to be an alternative way to draw compositions on the object model. This
metamodel will only model a composition and leave the way to display it up to
the model editor.result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any irl from instances of IRL where selected.number == param.compositionSegmentNumber;
if (empty irl)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Composition relationship, " + TC::intToString( i:param.compositionSegmentNumber ) + ", not instantiated!" );
else
number_of_participants = param.composingSegments.length;
i = 0;
while ( number_of_participants > i )
select any pirl from instances of IRL where selected.number == param.composingSegments[i];
if (empty pirl)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Composition relationship, " + TC::intToString( i:param.composingSegments[i] ) + ", not instantiated!" );
end if;
i = i + 1;
end while;
if (result == creationResult_t::SUCCESS)
select one ncm related by irl->NCM[R213];
select many refs related by ncm->REF[R128];
for each ref in refs
unrelate ref from ncm across R128;
delete object instance ref;
end for;
unrelate ncm from irl across R213;
end if;
create object instance com of COM;
relate com to irl across R213;
create object instance csl of CSL;
relate csl to com across R214;
i = 0;
while ( number_of_participants > i )
select any pirl from instances of IRL where selected.number == param.composingSegments[i];
create object instance lseg of LSEG;
relate pirl to csl across R215 using lseg;
end while;
end if;
end if;
return result;
Add a return type to bridge created as an asynchronous bridge to make it a synchronous bridge.
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any asb from instances of ASB where selected.name == param.bridge_name;
if (empty asb)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Bridge, " + param.bridge_name + ", not instantiated!" );
else
select any type from instances of TYPE where selected.name == param.type;
if (empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Data type, " + param.type + ", not instantiated!" );
else
create object instance syb of SYB;
select one brg related by asb->BRG[R3];
unrelate asb from brg across R3;
relate syb to brg across R3;
select one asa related by asb->ASA[R506];
unrelate asb from asa across R506;
delete object instance asb;
select one acc related by asa->ACC[R505];
unrelate asa from acc across R505;
delete object instance asa;
create object instance sya of SYA;
relate sya to acc across R505;
relate sya to syb across R524;
create object instance val of VAL;
create object instance dus of DUS;
relate dus to type across R625;
create object instance re of RE;
relate dus to re across R514;
relate val to dus across R624;
create object instance rvl of RVL;
relate rvl to val across R629;
relate sya to type across R529 using rvl;
end if;
end if;
end if;
return result;
Create a domain for the purposes of model verification. This creation will
always result in a failure, due to the constraint that a domain model must
contain at least one object. A log entry will be created for any failure.
A duplication failure will be reported with higher precedence.result = creationResult_t::FAILURE;
select any dom from instances of DOM where selected.name == param.name;
if (empty dom)
if ("" == param.name)
LOG::LogFailure( message:"Create domain failed due to invalid name." );
else
create object instance dom of DOM;
create object instance mdom of MDOM;
relate dom to mdom across R1;
// Instantiate core types, or domain type creation will fail.
::createCoreTypes();
LOG::LogInfo( message:"Modeled domain created without any objects." );
end if;
else
result = creationResult_t::DUPLICATE;
LOG::LogFailure(message:"A domain named, " + param.name + ", already exists!");
end if;
return result;
Create an incoming bridge to the modeled domain.
The bridge is created as an asynchronous bridge, which can be changed to
synchronous by adding a return type via another provided bridge of this
metamodel.result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create bridge failed due to invalid name, " + param.name + "." );
else
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any acc from instances of ACC where selected.name == param.name;
if (not empty acc)
select one syb related by acc->SYA[R505]->SYB[R524];
select one asb related by acc->ASA[R505]->ASB[R506];
if (not empty syb or not empty asb)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Bridge, " + param.name + ", already instantiated!" );
end if;
end if;
if ( creationResult_t::SUCCESS == result )
create object instance brg of BRG;
create object instance inbr of INBR;
relate inbr to brg across R4;
relate inbr to mdom across R6;
create object instance asb of ASB;
relate asb to brg across R3;
create object instance acc of ACC;
acc.name = param.name;
create object instance asa of ASA;
relate asa to acc across R505;
relate asa to asb across R506;
end if;
end if;
end if;
return result;
Create an outgoing bridge between the modeled domain and an external domain.
The bridge is created as an asynchronous bridge, which can be changed to
synchronous by adding a return type via another provided bridge of this
metamodel.result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create bridge failed due to invalid object name, " + param.name + "." );
else
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any acc from instances of ACC where selected.name == param.name;
if (not empty acc)
select one syb related by acc->SYA[R505]->SYB[R524];
select one asb related by acc->ASA[R505]->ASB[R506];
if (not empty syb or not empty asb)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Bridge, " + param.name + ", already instantiated!" );
end if;
end if;
if ( creationResult_t::SUCCESS == result )
select any edom from instances of EDOM where selected.name == param.externalDomain;
if (empty edom)
create object instance edom of EDOM;
end if;
create object instance brg of BRG;
create object instance oubr of OUBR;
relate oubr to brg across R4;
relate mdom to edom across R5 using oubr;
create object instance asb of ASB;
relate asb to brg across R3;
create object instance acc of ACC;
acc.name = param.name;
create object instance asa of ASA;
relate asa to acc across R505;
relate asa to asb across R506;
end if;
end if;
end if;
return result;
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select any mth from instances of MTH where (selected.name == param.method) and selected.belongsTo( object:param.object );
if (empty mth)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Method, " + param.method + ", not instantiated!" );
else
select any type from instances of TYPE where selected.name == param.type;
if (empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Data type, " + param.type + ", not instantiated!" );
else
select one sya related by mth->ISY[R534]->SYA[R524];
create object instance rvl of RVL;
create object instance val of VAL;
relate rvl to val across R629;
create object instance dus of DUS;
relate val to dus across R624;
relate dus to type across R625;
relate sya to type across R529 using rvl;
end if;
end if;
end if;
end if;
return result;
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select any atr from instances of ATR where (selected.name == param.attribute) and selected.belongsTo( object:param.object );
if (empty atr)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Attribute, " + param.attribute + ", not instantiated!" );
else
select any type from instances of TYPE where selected.name == param.type;
if (empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Data type, " + param.type + ", not instantiated!" );
else
select one sya related by atr->NRA[R103]->ATA[R523]->ISY[R534]->SYA[R524];
create object instance rvl of RVL;
create object instance val of VAL;
relate rvl to val across R629;
create object instance dus of DUS;
relate val to dus across R624;
relate dus to type across R625;
relate sya to type across R529 using rvl;
end if;
end if;
end if;
end if;
return result;
Adds parameter of specified type to the named bridge.
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any acc from instances of ACC where selected.name == param.bridge_name;
if (empty acc)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Accessor, " + param.bridge_name + ", not instantiated!" );
else
select one brg related by acc->SYA[R505]->SYB[R524]->BRG[R3];
if (empty brg)
select one brg related by acc->ASA[R505]->ASB[R506]->BRG[R3];
if (empty brg)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Bridge, " + param.bridge_name + ", not instantiated!" );
end if;
end if;
if (not empty brg)
select any prm related by acc->PRM[R540] where selected.name == param.name;
if (not empty prm)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Parameter data," + param.name + ", already added to accessor!" );
else
select any type from instances of TYPE where selected.name == param.type;
if (not empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Type, " + param.type + ", not instantiated!" );
else
create object instance prm of PRM;
relate prm to acc across R540;
create object instance nep of NEP;
relate nep to prm across R542;
end if;
end if;
end if;
end if;
end if;
return result;
Adds a parameter of the specified type to the named method.
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where (selected.name == param.object);
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated in domain!" );
else
select any mth from instances of MTH where (selected.name == param.method) and selected.belongsTo( object:sub.name );
if (empty mth)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Method, " + param.method + ", of object, " + param.object + ", not instantiated!" );
else
select one acc related by mth->ISY[R534]->SYA[R524]->ACC[R505];
select any prm related by acc->PRM[R540] where selected.name == param.name;
if (not empty prm)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Parameter data," + param.name + ", already added to accessor!" );
else
select any type from instances of TYPE where selected.name == param.type;
if (not empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Type, " + param.type + ", not instantiated!" );
else
create object instance prm of PRM;
relate prm to acc across R540;
create object instance nep of NEP;
relate nep to prm across R542;
end if;
end if;
end if;
end if;
end if;
return result;
Incoming bridges for creating model elements of the Dynamics subsystem as metamodel instances.
Table 20. Dynamic Model Bridges
Adds an empty instance-based state model segment to the specified subset. As states are unconditional requirements, an informational log message is generated to remind the user that states need to be created. Segments can be whole stand-alone state models, or splices of state models. At the set level, a state model segment is subtyped as a general segment to allow for subset segments to be subtyped as specializing segments. General segments can only exist at the object level (topmost) of a subtyping hierarchy. Subtype segments are labeled peer segments when they represent a whole lifecycle (even if a splice), or a splice when they represent a unique path within the whole lifecycle. Splices are branches formed via one supertype relationship. Splicing can be done multi-level, but a multidirectional supertype requires another splice. An object instance can only be in one state at a time, and the state must be unambiguous. A splice represents a instance-determined branch in the path of the lifecycle. A splice should always share a common transition from a common state to start the path, but the path doesn''t have to rejoin at the same state or by the same transition. The "same data" rule applies to the common transition at the start of a splice, even though the instance-based states can have their own process models. Peer subtype segments are not splices of a supertype; they represent the whole lifecycle of an object instance. Peer subtypes restrict the legality of the existence of state models among subtypes, because an object instance can''t have two concurrent lifecycles; this implies special caution when dealing with multidirectional and intersecting subtypes. A peer subtype segment will have no segments above it in a subtyping hierarchy.
Add a data member to an entry rule. An entry rule with no data members will not allow an event with parameters to be assigned to it''s transition. An entry rule with data will use the data to ensure the same data rule is followed whenever an event is assigned to it''s transition.
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where (selected.name == param.object);
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select one model related by sub->LIF[R347]->SM[R300];
if (empty model)
select one model related by sub->ASR[R354]->SM[R300];
end if;
if (empty model)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"State model not instantiated!" );
else
select any sta from instances of STA where (selected.name == param.stateName) and (selected.model_id == model.id);
if (empty sta)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"State, " + param.stateName + ", not instantiated!" );
else
select any type from instances of TYPE where selected.name == param.dataType;
if (empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Data type, " + param.dataType + ", not instantiated!" );
else
select one enrl related by sta->ENRL[R325];
if (empty enrl)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Entry rule not instantiated for state, " + param.stateName + "!" );
else
create object instance end of END;
relate type to end across R359;
LOG::LogInfo( message:"Entry data instantiated without any event parameters!" );
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Adds a state to an existing state model.
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select one model related by sub->LIF[R347]->SM[R300];
if (param.isAssigner)
select one model related by sub->ASR[R354]->SM[R300];
end if;
select any sta related by model->STA[R341] where (selected.name == param.name) or (selected.number == param.number);
if (not empty sta)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"State, " + param.name + ", already instantiated!" );
else
if (param.isAssigner)
if ((state_t::CREATION == param.type) or (state_t::DELETION == param.type))
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"State type is invalid for this state model!" );
else
select one asr related by sub->ASR[R354];
if (empty asr)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Assigner model not instantiated!" );
else
select one sm related by asr->SM[R300];
select one smc related by asr->ASM[R352]->SMC[R350];
if (state_t::START == param.type)
select one ncs related by asr->NCS[R345];
if (not empty ncs)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Start state already instantiated!" );
else
create object instance sta of STA;
sta.name = param.name;
sta.number = param.number;
relate sta to sm across R341;
relate sta to smc across R353;
create object instance liv of LIV;
relate liv to sta across R305;
create object instance cre of CRE;
relate cre to liv across R306;
create object instance ncs of NCS;
relate ncs to cre across R313;
relate ncs to asr across R345;
end if;
else
create object instance sta of STA;
sta.name = param.name;
sta.number = param.number;
relate sta to sm across R341;
relate sta to smc across R353;
create object instance liv of LIV;
relate liv to sta across R305;
create object instance nst of NST;
relate nst to liv across R306;
end if;
end if;
end if;
else
select one lif related by sub->LIF[R347];
if (empty lif)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Assigner model not instantiated!" );
else
select one sm related by lif->SM[R300];
create object instance sta of STA;
sta.name = param.name;
sta.number = param.number;
relate sta to sm across R341;
if (state_t::DELETION == param.type)
else
create objec
Adds an empty instance-based state model segment to the specified subset.
As states are unconditional requirements, an informational log message is
generated to remind the user that states need to be created.
Segments can be whole stand-alone state models, or splices of state models.
At the set level, a state model segment is subtyped as a general segment to
allow for subset segments to be subtyped as specializing segments. General
segments can only exist at the object level (topmost) of a subtyping hierarchy.
Subtype segments are labeled peer segments when they represent a whole
lifecycle (even if a splice), or a splice when they represent a unique path
within the whole lifecycle.
Splices are branches formed via one supertype relationship. Splicing can be
done multi-level, but a multidirectional supertype requires another splice. An
object instance can only be in one state at a time, and the state must be
unambiguous.
A splice represents a instance-determined branch in the path of the
lifecycle. A splice should always share a common transition from a common state
to start the path, but the path doesn''t have to rejoin at the same state or by
the same transition. The "same data" rule applies to the common transition at
the start of a splice, even though the instance-based states can have their own
process models.
Peer subtype segments are not splices of a supertype; they represent the
whole lifecycle of an object instance. Peer subtypes restrict the legality of
the existence of state models among subtypes, because an object instance can''t
have two concurrent lifecycles; this implies special caution when dealing with
multidirectional and intersecting subtypes.
A peer subtype segment will have no segments above it in a subtyping
hierarchy.result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select one lif related by sub->LIF[R347];
if ( empty lif )
create object instance sm of SM;
create object instance lif of LIF;
relate lif to sm across R300;
relate lif to sub across R347;
end if;
create object instance spl of SPL;
create object instance sms of SMS;
relate lif to sms across R362 using spl;
select one obj related by sub->OBJ[R107];
if (not empty obj)
create object instance gs of GS;
relate gs to sms across R363;
else
select one prp related by sub->PRP[R107];
select many sbts related by prp->SBT[R122];
for each sbt in sbts
create object instance sps of SPS;
relate sps to sms across R363;
select any sbs related by sbt->OBS[R126]->SBS[R125];
if (not empty sbs)
select one obs related by sbs->OBS[R125];
unrelate sbs from obs across R125;
delete object instance sbs;
relate sps to obs across R125;
else
create object instance obs of OBS;
relate obs to sps across R125;
relate sbt to obs across R126;
end if;
if (prp.hasPeerSegment())
create object instance psg of PSG;
relate psg to sps across R364;
else
create object instance ssg of SSG;
relate ssg to sps across R364;
end if;
end for;
end if;
LOG::LogInfo( message:"Lifecycle state model created without states!" );
end if;
end if;
return result;
Adds a successful transition to an existing state model between the specified to and from states. Creates and assigns the specified event to the exit rule created.
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where (selected.name == param.object);
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select one model related by sub->LIF[R347]->SM[R300];
if (param.isAssigner)
select one model related by sub->ASR[R354]->SM[R300];
end if;
if (empty model)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"State model not instantiated!" );
else
select any fsta related by model->STA[R341] where selected.name == param.fromState;
select any tsta related by model->STA[R341] where selected.name == param.toState;
if (empty fsta or empty tsta)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"State, " + param.fromState + " or " + param.toState + ", not instantiated!" );
else
select one del related by fsta->DEL[R305];
if (not empty del)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"From state can''t be a deletion state!" );
else
select any evt related by fsta->LIV[R305]->EXRL[R324]->EVT[R326] where selected.name == param.eventName;
if (not empty evt)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Event, " + param.eventName + ", already exits state, " + fsta.name + ", at a different exit point!" );
else
select any evt from instances of EVT where (selected.name == param.eventName) and (selected.object_name == param.object);
if (empty evt)
// Create event
create object instance evt of EVT;
relate evt to sub across R535;
create object instance asa of ASA;
relate asa to evt across R506;
create object instance acc of ACC;
relate acc to asa across R505;
acc.name = param.eventName;
end if;
// Do the "to" transition.
create object instance trule of TRUL;
select one enrl related by tsta->ENRL[R325];
if (empty enrl)
create object instance enrl of ENRL;
end if;
relate trule to enrl across R321;
relate enrl to tsta across R325;
create object instance tr of TR;
relate tr to enrl across R323;
// Always successful in this bridge. "Can''t happen" and "event ignored"
// have their own bridges.
create object instance st of ST;
relate st to tr across R355;
relate st to tsta across R332;
// Do the "from" transition.
create object instance trulx of TRUL;
create object instance exrl of EXRL;
relate trulx to exrl across R321;
relate exrl to tr across R329;
select one liv related by fsta->LIV[R305];
relate liv to exrl across R324;
end if;
end if;
end if;
end if;
end if;
end if;
return result;
Create a "Can''t Happen" or "Event Ignored" transistion between two existing states.
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select one model related by sub->LIF[R347]->SM[R300];
if (empty model)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"State model not instantiated!" );
else
select any fsta related by model->STA[R341] where selected.name == param.fromState;
select any tsta related by model->STA[R341] where selected.name == param.toState;
if (empty fsta or empty tsta)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"State, " + param.fromState + " or " + param.toState + ", not instantiated!" );
else
// Do the "to" transition.
create object instance trule of TRUL;
create object instance enrl of ENRL;
relate trule to enrl across R321;
relate enrl to tsta across R325;
create object instance tr of TR;
relate tr to enrl across R323;
create object instance ut of UT;
relate ut to tr across R355;
if (transition_t::CANNOT_HAPPEN == param.type)
create object instance cht of CHT;
relate cht to ut across R331;
else
create object instance eit of EIT;
relate eit to ut across R331;
end if;
create object instance trulx of TRUL;
create object instance exrl of EXRL;
relate trulx to exrl across R321;
relate exrl to tr across R329;
select one liv related by fsta->LIV[R305];
relate liv to exrl across R324;
LOG::LogInfo( message:"Transition rules created without event!" );
end if;
end if;
end if;
end if;
return result;
Adds a parameter of the specified type to the named event.
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any sub from instances of SUB where (selected.name == param.object);
if (empty sub)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated in domain!" );
else
select any evt from instances of EVT where (selected.name == param.event) and (selected.object_name == sub.name);
if (empty evt)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Event, " + param.event + ", of object, " + param.object + ", not instantiated!" );
else
select one acc related by evt->ASA[R506]->ACC[R505];
select any prm related by acc->PRM[R540] where (selected.name == param.name) and (selected.accessor_name == param.event);
if (not empty prm)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Parameter data," + param.name + ", already added to accessor!" );
else
select any type from instances of TYPE where selected.name == param.type;
if (not empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Type, " + param.type + ", not instantiated!" );
else
select one enrl related by evt->ENRL[R356];
select many ends related by enrl->END[R357] where selected.type_name == type.name;
spotFound = false;
for each end in ends
if (end.type_name == param.type)
select any evp related by end->EVP[R358] where selected.accessor_name == evt.name;
if (empty evp)
create object instance prm of PRM;
relate prm to acc across R540;
create object instance evp of EVP;
relate evp to prm across R542;
relate evp to end across R358;
spotFound = true;
break;
end if;
end if;
end for;
if (not spotFound)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"No entry data found for parameter type, " + type.name + "!" );
end if;
end if;
end if;
end if;
end if;
end if;
return result;
result = creationResult_t::SUCCESS;
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
// Assigner state model must be instantiated for the whole set.
select any obj from instances of OBJ where selected.name == param.object;
if (empty obj)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
else
select any sub from instances of SUB where selected.name == param.object;
if ( sub.hasStateModel( assigner:true ) )
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"State model already instantiated!" );
else
create object instance sm of SM;
create object instance asr of ASR;
relate asr to sm across R300;
relate asr to sub across R354;
create object instance smc of SMC;
create object instance asm of ASM;
relate asm to smc across R350;
relate asr to asm across R352;
LOG::LogInfo( message:"Assigner state model created without states!" );
end if;
end if;
end if;
return result;
Incoming bridges for creating model elements of the Data subsystem as metamodel instances.
Table 21. Data Bridges
Add an enumeration value to an existing enumeration type. This bridge must be called for each enumeration value. Every enumeration type requires at least one enumeration.
Add an enumeration value to an existing enumeration type.
This bridge must be called for each enumeration value. Every enumeration
type requires at least one enumeration.result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create object failed due to invalid object name, " + param.name + "." );
else
select any domain from instances of MDOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
select any enum from instances of ENUM;
if (empty enum)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Enumeration type not instantiated!" );
else
select any enud from instances of ENUD where selected.name == param.enumeration;
if (not empty enud)
select any enuv related by enud->ENUV[R420] where selected.name == param.name;
if (not empty enuv)
result = creationResult_t::DUPLICATE;
LOG::LogInfo( message:"Enumeration value, " + param.name + ", already assigned to enumeration, " + param.enumeration + "." );
end if;
else
create object instance enud of ENUD;
end if;
if ( creationResult_t::SUCCESS == result )
relate enud to enum across R416;
create object instance enuv of ENUV;
enuv.name = param.name;
relate enuv to enud across R420;
create object instance value of VAL;
relate enuv to value across R629;
create object instance dus of DUS;
relate dus to value across R624;
create object instance re of RE;
relate dus to re across R514;
select one type related by enum->CORE[R403]->TYPE[R401];
relate type to dus across R625.''constrains'';
end if;
end if;
end if;
end if;
Create a new user-defined type from a domain model to be verified against the Shlaer-Mellor metamodel. The only expected failure scenarios are duplication, and invalid parameters.
result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create type failed due to invalid type name, " + param.name + "." );
else
select any domain from instances of DOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain not instantiated!" );
else
select any type from instances of TYPE where selected.name == param.name;
if (not empty type)
result = creationResult_t::DUPLICATE;
LOG::LogInfo( message:"Duplicate type instantiation attempt!" );
else
generate DOMD1:create( name:param.name, coreType:param.coreType, domain:param.domain ) to DOMD creator;
end if;
end if;
end if;
return result;
Create an operator for a user-defined type that is not already part of the set of operators for its core type.
result = creationResult_t::SUCCESS;
if ("" == param.name)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Create operator failed due to invalid name, " + param.name);
else
select any domain from instances of DOM where selected.name == param.domain;
if (empty domain)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Domain not instantiated!" );
else
select any type from instances of TYPE where selected.name == param.type;
if (empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Type not instantiated!" );
else
select any type from instances of TYPE where selected.name == param.resultType;
if (empty type)
result = creationResult_t::FAILURE;
LOG::LogFailure( message:"Result type not instantiated!" );
else
select any tyop from instances of TYOP where (selected.type_name == param.type) and (selected.operation_name == param.name) and (selected.result_type_name == param.resultType);
if (not empty tyop)
result = creationResult_t::DUPLICATE;
LOG::LogFailure( message:"Duplication of operator, " + param.name + " , for type, " + param.type + "." );
else
generate TYOP_A1:create( type:param.type, name:param.name, symbol:param.symbol, result:param.resultType ) to TYOP class;
end if;
end if;
end if;
end if;
end if;
return result;
Table 22. Shlaer-Mellor Metamodel Interface Messages
Add an enumeration value to an existing enumeration type. This bridge must be called for each enumeration value. Every enumeration type requires at least one enumeration.
Adds an empty instance-based state model segment to the specified subset. As states are unconditional requirements, an informational log message is generated to remind the user that states need to be created. Segments can be whole stand-alone state models, or splices of state models. At the set level, a state model segment is subtyped as a general segment to allow for subset segments to be subtyped as specializing segments. General segments can only exist at the object level (topmost) of a subtyping hierarchy. Subtype segments are labeled peer segments when they represent a whole lifecycle (even if a splice), or a splice when they represent a unique path within the whole lifecycle. Splices are branches formed via one supertype relationship. Splicing can be done multi-level, but a multidirectional supertype requires another splice. An object instance can only be in one state at a time, and the state must be unambiguous. A splice represents a instance-determined branch in the path of the lifecycle. A splice should always share a common transition from a common state to start the path, but the path doesn''t have to rejoin at the same state or by the same transition. The "same data" rule applies to the common transition at the start of a splice, even though the instance-based states can have their own process models. Peer subtype segments are not splices of a supertype; they represent the whole lifecycle of an object instance. Peer subtypes restrict the legality of the existence of state models among subtypes, because an object instance can''t have two concurrent lifecycles; this implies special caution when dealing with multidirectional and intersecting subtypes. A peer subtype segment will have no segments above it in a subtyping hierarchy.
Add the relationship path from a non-referential attribute to the attribute it is derived from. Process modeling of the derivation is added in another bridge.
Create a binary relationship between two specified object instances, or create a temporary binary relationship between one or two specified objects for the purpose of statically verifying an object model. A binary relationship between the same object must specify the object in both the passiveObject and activeObject parameters. The temporary instances are created by setting both instance parameters to zero. Only setting one to zero is an error. The active/passive terminology used is reflective of how verb phrases are often used in relationships with one using an active perspective and one using a passive perspective. It is a differentiator in the metamodel, but not a hard rule for Shlaer-Mellor modeling. If the perspective is unclear or the same in both directions, then just arbitrarily assign the parameters. Referential cheatsheet: (All are reflexive) 1:1 - choose either side 1:1c - 1c 1:M - M 1:Mc - Mc 1c:1c - use associative object 1c:M - use associative object 1c:Mc - use associative object M:M - use associative object Mc:M - use associative object Mc:Mc - use associative object
Create a domain for the purposes of model verification. This creation will always result in a failure, due to the constraint that a domain model must contain at least one object. A log entry will be created for any failure. A duplication failure will be reported with higher precedence.
Create a Shlaer-Mellor intersecting subtype object of the specified supertype objects using the specified relationships in the specified domain. The subtype and supertypes specify the intersection of two sets (objects). The intersecting subtype might have already be created, and this call is just specifying another set participating in the intersection, or the subtype might already exist as a non-intersecting subtype; this call is then transforming the non-intersecting subtype into an intersecting subtype.
Create an incoming bridge to the modeled domain. The bridge is created as an asynchronous bridge, which can be changed to synchronous by adding a return type via another provided bridge of this metamodel.
Create an outgoing bridge between the modeled domain and an external domain. The bridge is created as an asynchronous bridge, which can be changed to synchronous by adding a return type via another provided bridge of this metamodel.
Set an existing relationship to be constrained as a composition from it''s participation in a relationship loop, rather than by referential attributes. "[When a relationship is the logical consequence of other relationships,] Such a relationship is said to be formed by composition (as in composition of functions in mathematics. [...] A relationship formed by composition cannot be formalized in referential attributes, since the connections between the instances is already given by the connections between the [composing relationships]. A relationship formed by composition is annotated on the model as [composed relationship = 1st composing relationship + 2nd composing relationship [+ nth composing relationship ...]]." [OL:MWS] "Composed Relationships. Another special case occurs when the constraint on the referential attribute is such that it identifies a single instance of the associated object. [...] Composition of relationships captures the constraint directly in data [...] However the use of composition is limited in that it requires that the constraint always identify a single associated instance." [OOA96] Both definitions identify compositions as relationship combinations that loop back to the originating instance. [miUML] calls compositions, "Constrained Loops", because the compostion equation forms a constraint on the object instances allowed to participate. [OOA96] also discusses collapsed referentials, but the example shows them to be an alternative way to draw compositions on the object model. This metamodel will only model a composition and leave the way to display it up to the model editor.
Adds an asynchronous bridge call to the process specified in the action specified. A synchronous bridge call will be added as a return value added to an operand.
Add a constant value to the left or right hand operand of an expression. As the actual value isn''t that interesting to the metamodel, the parameter, name, is used to allow process model construction within the constraints the metamodel. The value of name is symbolic representation of the value is akin to using defines in C to represent "magic numbers".
Add a return value to the left or right operand of an expression. This bridge will be called when an accessor is part of an equation. e.g., a = a + sum(b, c) If the return value is on the right hand side of an assignment, it can be the return from the current process model. This call will be used whenever any synchronous accessor (synchronous bridge, object method, or attribute action) is added to a process model.
Rendered here are the contained package diagrams.
Table 23. Datatypes
Table 24. EE
This bridge operation starts a timer set to expire in the specified number of microseconds, generating the passed event upon expiration. Returns the instance handle of the timer.
This bridge operation starts a timer set to expire in the specified number of microseconds, generating the passed event upon expiration. Upon expiration, the timer will be restarted and fire again in the specified number of microseconds generating the passed event. This bridge operation returns the instance handle of the timer.
Returns the time remaining (in microseconds) for the passed timer instance. If the timer has expired, a zero value is returned.
This bridge operation attempts to set the passed existing timer to expire in the specified number of microseconds. If the timer exists (that is, it has not expired), a TRUE value is returned. If the timer no longer exists, a FALSE value is returned.
This bridge operation attempts to add the specified number of microseconds to a passed existing timer. If the timer exists (that is, it has not expired), a TRUE value is returned. If the timer no longer exists, a FALSE value is returned.