| Stereotype |
Applies to |
Documentation |
Tags |
| abbreviation |
|
Normally the abbreviation of a class's name is formed from the initial letters of the words in the name. If there's only one
word, it's formed by prepending "A_" or "An_". This stereotype is provided to support the {abbreviation} tag, which allows
the modeller to override the default behaviour.
|
|
| access |
|
Indicates that the type is an access to the type specified in the accompanying {access-to-type}. |
|
| access-to-operation |
|
The marked datatype must have only one operation, whose name is discarded (and can be omitted): instead, the datatype specifies
an access to an operation of the given profile.
|
|
| accessor |
|
The tagged operation is an accessor for one of the attributes of the class, determined by scope (instance/class), name and
parameter or result type.
|
|
| active |
|
Each instance of the class is to have an associated task.
Setting the "isActive" modifier "true" has the same effect but is less visible for such a significant aspect of the generated
code, and also doesn't allow setting of {priority} and {stack}.
|
|
| association-class-naming
*deprecated*
|
|
This stereotype supports the tags {association-name}, which is used to specify the name to be used for the association part
of an AssociationClass, and {class-name}, which is used to specify the name to be used for the class part. Both can be supplied;
if only one is supplied, the other part retains the name specified in the model; if neither is supplied, the name used is
formed by appending "_Class" to the AssociationClass name.
|
|
| atomic |
|
The attribute must be read from memory or written to memory each time it is accessed, like «volatile», but additionally in
such a way that it's proof against concurrent access.
The implementation may limit the size of objects that can be treated as atomic.
|
|
| bounded-string |
|
Specifies that the datatype is a string of length up to a maximum. The maximum length is specified in the tag {length}. |
|
| callback |
|
If applied to a type, callback support code is to be generated. The idea here is that a (lower-level) Domain may need to support
Observers from higher-level Domains, and the higher-level Domains can register to be notified when something has changed in
the lower-level Domain.
If applied to an operation, the operation is to be an Observer of some change in a lower-level domain. This implies the stereotype
«class». The operation must take a single parameter of the type concerned.
|
|
| cardinality |
|
Specifies (in the associated {max} tag) the maximum number of instances of a class. Note, under some circumstances ColdFrame
can calculate the maximum number of instances (for example, if the class has a single identifier of an enumeration type):
this setting will override such a calculation.
|
|
| class |
| CallEvent |
| SignalEvent |
| StateMachine |
|
This stereotype is used to manage class events, which is a ColdFrame concept that distinguishes events directed to state machines
(instance events) from events originating outside the domain (class events, because external entities have no visibility of
state-machine related events).
|
|
| constraint |
|
Indicates that the type is a constrained subtype of the type specified in the accompanying {constrains}.
The constraints are indicated in the accompanying {lower} and {upper}, at least one of which must be present.
If either {lower} or {upper} is absent, the lower or upper bound respectively of the {constrains} type is used.
|
|
| convention |
|
Specifies that the conventions of the programming language specified in the accompanying {language} tag are to be used.
If specified on a class, the class must be stereotyped «datatype».
|
|
| counterpart |
|
The type is used for references to instances in other domains. |
|
| datatype |
|
Specifies that the class in fact specifies a (record) type or struct. |
|
| discriminated |
|
Causes the generation of discriminated records; the discriminant is an enumeration type with literals formed from the attribute
names with _T appended.
To be applied to a Class stereotyped «datatype» and with attributes.
|
|
| domain |
|
A domain is a separate real, hypothetical, or abstract world inhabited by a distinct set of classes that behave according
to rules and policies characteristic of that domain.
A domain is translated as a top-level Ada package, with the name derived from the package name using the usual name conversion
rules (it can be overridden using the tagged value {name}).
Child UML packages are included (recursively), unless they are steretyped «ignore». The child UML package structure is not
reflected in the generated code (for example, all classes end up as direct Ada child packages of the domain package).
|
|
| domain-interface |
|
Supports unit test.
Marks a package (which needs to be a child of a «domain» package) as containing all the «public» classes and «callback» types,
any types used by them, and any exceptions that form part of the external interface of the parent package.
Use the {name} tag to define the name to generate (the code will still be placed in the directory derived from the actual
package name, which should be <parent>_Interface).
|
|
| entry |
|
In an active class, you can specify task entries using the «entry» stereotype. It's permissible to have an ordinary operation
with the same name as an «entry», because «entry» operations don't generate normal subprograms.
In a «protected» type, you can nominate procedures (operations without a return value) as entries using the «entry» stereotype.
The point about an entry of a protected type is that your implementation specifies a guard condition; callers of the entry
block until the guard becomes open.
|
|
| final |
|
If applied to a (Simple)State, indicates that the marked state is a final state; no outgoing transitions are allowed.
If applied to an Operation, indicates that the marked operation deletes the instance.
Used in state machines to ensure that no further accesses are made to the deleted instance.
The (generated) operation Delete is automatically «final».
|
|
| finalize |
|
Operations to be called to clean up as an instance is deleted (for example, to tidy up associations) are marked with the stereotype
«finalize». (It would be possible in theory to use Ada's controlled types, but that depends on your target language being
Ada). Also, it's possible to have more than one «finalize» operation; if so, they're called in alphabetical order.
|
|
| fixed-string |
|
Specifies that the datatype is a fixed length string. The length is specified in the tag {length}. |
|
| id |
|
The attribute is an identifying attribute. |
|
| ignore |
|
Used on a package to indicate that the contents of the package is to be ignored for code generation (it may, for example,
include additional documentation).
Used on a state transition to indicate that the trigger event is to be ignored in the source state.
|
|
| imported |
|
Specifies that the object is to be found at the external reference specified in the {imported} tag. |
|
| init |
|
Operations to be called from the Domain Initialize procedure are marked with the stereotype «init». This implies the stereotype
«class». These operations must be parameterless procedures.
|
|
| not-null |
|
This stereotype is applied to an operation parameter which is not permitted to be null.
It must only be applied to parameters of an access type (for example, a class in the domain).
|
|
| null |
|
Specifies an empty record; useful for a callback with no actual data associated. |
|
| protected |
|
Specifies that instances of the type are protected against concurrent access by multiple threads of execution.
To be applied to a Class stereotyped «datatype» and with attributes.
|
|
| public |
|
Specifies that the marked class is part of the public interface of the domain. |
|
| renaming |
| DataType |
| Exception |
| Operation |
|
Specifies that the object is a renaming of the external reference specified in the {renames} tag. |
|
| singleton |
|
Specifies that the marked class has precisely one instance (which will be automatically created on domain initialization). |
|
| source |
|
If you have a symmetrical association of multiplicity 1:1, 1c:1c, 1-(1:1) or 1-(1c:1c), ColdFrame requires you to tell it
how the association is to be formalized.
This stereotype marks the association end from which the referential attribute (which appears in the other end, or which forms
the identifier of the Association Class) is taken.
|
|
| teardown |
|
Instance operations to be called during teardown (in unit test) are marked with the stereotype «teardown». |
|
| unsigned |
|
Specifies that the datatype is an unsigned type, with modulus stated in the accompanying {mod} tag. |
|
| utility |
|
Specifies that the "class" has no instances, and is merely a wrapper for operations. |
|
| volatile |
|
The attribute must be read from memory or written to memory each time it is accessed. |
|
| Tag |
Documentation |
Stereotype |
| abbreviation |
Normally the abbreviation of a class's name is formed from the initial letters of the words in the name. If there's only one
word, it's formed by prepending "A_" or "An". This tag allows the modeller to override this, if the default behaviour leads
to aliasing.
|
abbreviation |
| access-to-type |
Names the type to which the marked type is an access; it must be a domain type, not one of those that ColdFrame defines (such
as Integer).
Mandatory.
|
access |
| association-name
*deprecated*
|
This tag is used to specify the name to be used for the association part of an AssociationClass. If not supplied, the name
used is the AssociationClass name.
|
association-class-naming |
| class-name
*deprecated*
|
This tag is used to specify the name to be used for the class part of an AssociationClass. If neither this tag nor {association-name}
is supplied, the name used is formed by appending "_Class" to the AssociationClass name.
|
association-class-naming |
| constrains |
The type to be constrained; mandatory. |
constraint |
| formalizes |
The marked identifying attribute suffices to formalize the named association. It must be the name of the class at the other
end of the association.
|
id |
| hash |
Specifies how a renamed type is to be hashed. Currently the only supported styles are:
* 'discrete', which will work for imported enumerations or integer ranges but not for private or access types, and
* 'enumeration', which is similar but acts as a code generation optimization directive.
|
renaming |
| hash |
Specifies how an imported type is to be hashed. Currently the only supported styles are:
* 'discrete', which will work for imported enumerations or integer ranges but not for private or access types, and
* 'enumeration', which is similar but acts as a code generation optimization directive.
|
imported |
| imported |
Specifies the package where the element is actually declared. |
imported |
| init |
Specifies the fully-qualified name of an operation to be called before any other domain initialization. |
domain |
| language |
Specifies the programming language whose conventions are to be used in the translation; mandatory. |
convention |
| length |
Specifies the maximum length of the «bounded-string» string. |
bounded-string |
| length |
Specifies the length of the «fixed-string» string. |
fixed-string |
| lower |
The lower bound of the new type (in Ada, subtype). |
constraint |
| max |
Specifies the maximum number of instances of the class; mandatory. |
cardinality |
| mod |
If the value is m, the tagged «unsigned type» is to be able to store values 0 .. m - 1. |
unsigned |
| name |
The Ada package name to be used, if not the default (the UML package name). |
domain |
| name |
The Ada package name to be used, if not the default (the UML package name).
Should match the name of the parent «domain» package.
|
domain-interface |
| priority |
Specifies the task priority as a signed offset from the default. |
active |
| renames |
Specifies the fully-qualified name of the renamed element. |
renaming |
| revision |
The VCS revision of the UML model. |
domain |
| revision |
The VCS revision of the UML model. |
domain-interface |
| stack |
Specifies the stack size for the task (the default is 20_000 bytes). |
active |
| upper |
The upper bound of the new type (in Ada, subtype). |
constraint |
| Type |
Documentation |
| Autonumber |
Used for automatically-generated instance identifiers.
For Ada, translates to Long_Long_Integer (typically 64-bits).
|
| Boolean |
The standard boolean type.
Corresponds directly to the Ada Boolean.
|
| Character |
The standard character type.
Corresponds directly to the Ada Character.
|
| Counterpart |
Used for references to instances in other domains (but see «counterpart»). |
| Date |
May correspond to a calendar date, but for Ada translates to ColdFrame.Project.Calendar.Time (the same as Time). |
| Duration |
A time interval.
Corresponds directly to the Ada Duration.
|
| Float |
The standard short float type.
Corresponds directly to the Ada Float.
|
| Integer |
The standard integer type.
Corresponds directly to the Ada Integer.
|
| Long_Float |
The standard long float type.
Corresponds directly to the Ada Long_Float.
|
| Natural |
An integer, constrained to be greater than or equal to zero.
Corresponds directly to the Ada Natural.
|
| Positive |
An integer, constrained to be greater than zero.
Corresponds directly to the Ada Positive.
|
| Real |
A floating-point value.
For Ada, translates to Float.
|
| String |
A fixed-length character string, normally used as an operation parameter, when it has the length of the actual. Can only be
used for an attribute if the attribute is given an initial value.
Corresponds directly to the Ada String.
|
| Text |
An unbounded string.
For Ada, translates to Ada.Strings.Unbounded.Unbounded_String.
|
| Time |
May correspond to a time-of-day, but for Ada translates to ColdFrame.Project.Calendar.Time (the same as Date). |
| Timer |
Used mainly for timeouts in state machines.
A timer can hold at most one event, which is to be released at some future time but which can be cancelled or revoked.
|
| Unbounded_String |
A variable-length string.
Corresponds directly to Ada.Strings.Unbounded.Unbounded_String.
|