![]() ![]() |
||||
|
||||
A property set defines a named group of property types,
property names, and property constant
values.
Syntax
property_set ::=
property setdefining_property_set_identifier is
{ property_type_declaration
| property_name_declaration
| property_constant }+
enddefining_property_set_identifier
;
Naming Rules
Property set defining identifiers must be unique in the
global namespace.
The defining identifier following the reserved word end
must be identical to the defining identifier
following the reserved word propertyset.
Associated with every property set is a property set
namespace that contains the defining
identifiers for all property types declared within that property set. This means that properties
with
the same identifier can be declared in different property sets.
A property or property type declared in a property set
is named by its qualified name, that is the
property set identifier followed by the property identifier, separated by a double colon (“::”).
Predeclared properties and property types are referred to by their property identifiers. |
||||
A property type declaration associates an identifier
with a property type. A property type denotes
the set of legal values in a property association that are the result of evaluating the associated
property expression.
Syntax
property_type_declaration ::=
defining_property_type_identifier
: type property_type_designator ;
property_type_designator ::=
property_type | unique_property_type_identifier
property_type ::=
aadlboolean
| aadlstring
| enumeration_type
| units_type
| number_type
| range_type
| classifier_type
| reference_type
enumeration_type ::=
enumeration
( defining_enumeration_literal_identifier
{ , defining_enumeration_literal_identifier }* )
units_type ::=
units units_list
units_list ::=
( defining_unit_identifier
{ , defining_unit_identifier => unit_identifier *
numeric_literal }* )
number_type ::=
aadlreal [
real_range ] [ units units_designator ]
| aadlinteger
[ integer_range ] [ units units_designator ]
units_designator ::=
units_unique_property_type_identifier
| units_list
real_range ::= real_lower_bound ..
real_upper_bound
real_lower_bound ::= signed_aadlreal_or_constant
real_upper_bound ::= signed_aadlreal_or_constant
integer_range ::= integer_lower_bound ..
integer_upper_bound
integer_lower_bound ::= signed_aadlinteger_or_constant
integer_upper_bound ::= signed_aadlinteger_or_constant
signed_aadlreal_or_constant ::=
( signed_aadlreal
| [ sign ] real_property_constant_term )
signed_aadlinteger_or_constant ::=
( signed_aadlinteger
| [ sign ] integer_property_constant_term )
sign ::= + | -
signed_aadlinteger ::=
[ sign ] integer_literal
[ unit_identifier ]
signed_aadlreal ::=
[ sign ] real_literal
[ unit_identifier ]
range
of number_type
| range of number_unique_property_type_identifier
classifier_type ::=
classifier
[ ( component_category { , component_category }* ) ]
reference_type ::=
reference
[ ( referable_element_category
{ , referable_element_category }* ) ]
referable_element_category ::=
component_category | connections |
server subprogram
unique_property_type_identifier ::=
[ property_set_identifier ::
] property_type_identifier
Naming Rules
All property type defining identifiers declared within
the same property set must be distinct from
each other, i.e., unique within the property set namespace.
A property type is named by its property type identifier
or the qualified name specified by the
property set/property type identifier pair, separated by a double colon (::). An unqualified
property
type identifier must be part of the predeclared property sets. Otherwise, the property type identifier
must appear in the property set namespace.
An enumeration type introduces an enumeration namespace.
The enumeration literal identifiers in
the enumeration list declare a set of enumeration literals. They must be unique within this
namespace.
A units type introduces a units namespace. The
units identifiers in the units list declare a set of
units literals. They must be unique within this namespace.
The units identifier to the right of a => must
refer to a unit identifier defined in the same units type
declaration.
Legality Rules
The value of the first numeric literal that appears in
a range of a number_type
must not be greater
than the value of the second numeric literal including the values units.
Range values should always be declared with unit literals
if the property requires a unit literal.
The unique property constant identifier in an integer
range must represent an integer constant.
A boundless range type may be declared such that the
actual range declarations have no limit on
the upper and lower bound.
The unique property constant identifier in a real range
must represent a real constant.
If the property requires a unit , then the unit
must be specified for both lower and upper bound.
Semantics
A property type declaration associates an identifier
with a property type.
The aadlboolean property type represents the two
values, true and false.
The aadlstring property type represents all legal
strings of the AADL.
An enumeration property type represents an explicitly
listed set of enumeration identifiers as the
set of legal values.
A units property type represents an explicitly
listed set of measurement unit identifiers as the set
of legal values. The second and succeeding unit identifiers are declared with a multiplier
representing the conversion factor that is applied to the previous unit to determine the value in
terms of the specified measurement unit.
An aadlreal property type represents a real value
or a real value and its measurement unit. If a
units clause is present, then the type value is a pair of values, a real value and a unit. The unit
may
only be one of the enumeration literals specified in the units clause. If a units clause is absent,
then the value is a real value. If a simple range is present, then the real value must be an element
of the specified range.
An aadlinteger property type represents an integer
value or an integer value and its measurement
unit. If an units clause is present, then the value is a pair of values, and unit may only be
one of
the enumeration literals specified in the units clause. If an units clause is absent, then the
value is
an integer value. If a simple range is present, then the integer value must be an element of the
specified range.
The range type represents closed intervals of
numbers. It specifies that a property of this type has
a value that is a range term. The range type specifies the number type of values in the range.
A
property specifying a range term as its value indicates a least value called the lower bound of the
interval, a greatest value called the upper bound of the interval, and optionally the difference
between adjacent values called the delta. The delta may be unspecified, in which case the range
is dense, but it is otherwise undefined whether the range is an interval of the real or the rational
numbers.
A classifier property type represents the subset
of syntactically legal component classifier
references whose category matches one of component categories in the specified list. If the
category list is absent, all component classifier references are acceptable.
A reference type (indicated by the reserved word reference)
represents the subset of
syntactically legal references to those components whose category matches one of component
categories in the specified list, or to connections, or to server subprogram features. If the
category
list is absent, all components, connections, and server subprograms are acceptable.
NOTES:
The classifier and reference
property types support the specification of properties representing binding
constraints.
Examples
Length_Unit : type units ( mm,
cm => mm * 10,
m => cm * 100, km => m * 1000 );
OnOff : type aadlboolean;
Car_Length : type aadlreal 1.5
.. 4.5 units ( meter );
Speed_Range : type range of aadlreal
0 .. 250 units ( kph ); |
||||
All property names that appear in a property association
list must be declared with property name
declarations inside a property set. Property names are typed and are defined for specific
component, port, port group, subprogram, access, mode, flow, and connection categories.
Syntax
property_name_declaration ::=
defining_property_name_identifier
: [ access ] [ inherit ]
( single_valued_property | multi_valued_property )
applies
to (
( property_owner_category
{ , property_owner_category }*
| all
)
) ;
single_valued_property ::=
property_type_designator
[ => default_property_expression ]
multi_valued_property ::=
list of property_type_designator
[ =>
( [ default_property_expression
{ , default_property_expression }* ]
)
]
property_owner_category ::=
component_category
[ classifier_reference ]
| mode | port
group | flow
| [ event ]
[ data ] port
| server subprogram
| parameter
| [ connection_type
] connections
connection_type ::=
port group |
[ event ] [ data ] port | access | parameter
Naming Rules
All property name defining identifiers declared within
the same property set must be distinct from
each other and distinct from all property type defining identifiers declared within that property set.
The property set namespace contains the defining identifiers for all property names declared within
that property set.
Legality Rules
The reserved word access is only permitted for
property name declarations whose applies to
property category list contains categories of subcomponents that can be required or provided
subcomponents. These categories are data and bus.
Semantics
A property name declaration introduces a new property
by a name that is of a specified property
type, accepts a single value or a list of values, and may specify a default property expression.
This
property is defined for those component categories, specific component classifiers, or for port, port
group, flow, subprogram, mode, and connection categories that are listed after the applies to in
the Property_Owner_Category list.
This indicates that component classifiers and
subcomponents corresponding to the specified category, ports, port groups, flows, subprograms,
modes, and connections can have property associations for such a property. If the category
specification includes a classifier, and the classifier is a component type, then the property applies
to both the type and implementation of the specified component category. In the case of a
component implementation classifier, the property applies only to the implementation. The
reserved word all in the applies to statement indicates that the property applies to any
Property_Owner_Category.
A property declared with the reserved word access
is associated with the access to a
subcomponent rather than the data component itself. For example, two components can require
access to a data component, one requiring read-only access, while the other requires write-only
access.
A property declared with the reserved word inherit indicates
that if a property value cannot be
determined for a component, then its value will be inherited from a containing component. The
detailed rules for determining property values are described in Section 10.3.
A property name declared without a default value is considered
undefined (see also Section 10.3).
A property name declared to have a list of values is considered to have an empty list if no default
value is declared.
Examples
Wheel_speed : aadlinteger 0
rpm .. 5000 rpm units ( rpm )
applies to ( system ); |
||||
Property constants are property values that are known
by a symbolic name. Property constants
are provided in the predeclared property sets and can be defined in property sets. They can be
referenced in property expressions by name wherever the value itself is permissible.
Syntax
property_constant ::=
single_valued_property_constant
| multi_valued_property_constant
single_valued_property_constant ::=
defining_property_constant_identifier : constant
( ( aadlinteger | aadlreal
[ units_unique_property_type_identifier
] )
| aadlstring
| aadlboolean
| enumeration_unique_property_type_identifier
| integer_range_unique_property_type_identifier
| real_range_unique_property_type_identifier
| integer_unique_property_type_identifer
| real_unique_property_type_identifer
)
=>
constant_property_value ;
multi_valued_property_constant ::=
defining_property_constant_identifier : constant list
of
( ( aadlinteger | aadlreal
[ units_unique_property_type_identifier
] )
| aadlstring
| aadlboolean
| enumeration_unique_property_type_identifier
| integer_range_unique_property_type_identifier
| real_range_unique_property_type_identifier
| integer_unique_property_type_identifer
| real_unique_property_type_identifer
)
=> ( [
constant_property_value { , constant_property_value }* ]
) ;
constant_property_value ::=
string_literal
| signed_integer
| signed_real
| boolean_value
| enumeration_identifier
| signed_aadlinteger ..
signed_aadlinteger [ delta
signed_aadlinteger ]
| signed_aadlreal ..
signed_aadlreal [ delta signed_aadlreal ]
unique_property_constant_identifier
::=
value ( [ property_set_identifier ::
] property_constant_identifier
)
Naming Rules
The defining property constant identifier must be distinct
from all other property constant identifiers,
property name identifiers, and property type identifiers in the namespace of the property set that
contains the property constant declaration.
A property constant is named by its property constant
identifier or the qualified name specified by
the property set/property constant identifier pair, separated by double colon (::).
An unqualified
property constant identifier must be part of the predeclared property sets. Otherwise, the property
constant identifier must appear in the property set namespace.
Legality Rules
If a property constant declaration has more than one
property expression, it must contain the
reserved words list of.
The property type of the property constant declaration
must match the property type of the
constant property value.
If the constant property value is an integer
or real value with a unit identifier, then the property
type specification of the property constant must include a units identifier.
Semantics
Property constants allow integer, real, and string values
to be known by symbolic name and
referenced by that name in property expressions. This reference is expressed by the construct
value() resulting in the value of the constant to be used instead of the reference.
Examples
Max_Threads : constant aadlinteger
=> 256; |
||||