| 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 |
| 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. |