11.1    Property Sets

(1)   A property set defines a named group of property types, property definitions, and property constant values.

Syntax

property_set ::= 
    property set defining_­property_set_identifier is 
       { import_declaration }*
       { property_type_declaration 
         | property_definition_declaration 
         | property_constant }*
    end defining_property_set_identifier ;

Naming Rules

(N1)     Property set defining identifiers must be unique in the global namespace.

(N2)     The defining identifier following the reserved word end must be identical to the defining identifier following the reserved word property set.

(N3)     Associated with every property set is a property set namespace that contains the defining identifiers for all property types, property definitions, and property constants declared within that property set.  This means that property types, properties, and property constants with the same identifier can be declared in different property sets. 

(N4)     A property, property constant, or property type declared in a property set is always named by its qualified name that is the property set identifier followed by the property identifier, separated by a double colon (“::”).  This qualification is necessary even for references to properties, property constants, and property types in the same property set due to the fact that predeclared properties do not have to be qualified. Predeclared properties and property types may be referred to by their property identifiers without a property set qualifier.

(N5)     The property set identifiers and package names listed in an import_declaration must exist in the global namespace.

(N6)     The property set identifier of a qualified property name must be listed in an import_declaration of the property set or package unless it is the name of the property set that contains the qualified name.

Semantics

(2)   Property definitions, property types, and property constants are organized into property sets. They are referenced by qualifying them with the property set name.  This qualification is not required if the property set is one of the predeclared property sets.

(3)   An import_declaration of a property set specifies which property sets and packages can be named in qualified references to items in other property sets.

11.1.1    Property Types

(1)   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 ;
 
property_type ::=
       aadlboolean | aadlstring
     | enumeration_type | units_type
     | number_type | range_type
     | classifier_type
     | reference_type
     | record_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_type ::=
      range of number_type
    | range of number_unique_property_type_identifier 
 
classifier_type ::=
    classifier 
    [ ( classifier_category_reference { , classifier_category_reference }* ) ]
 
classifier_category_reference ::= 
    -- AADL or Annex meta model classifier
    classifier_qualified_meta_model_identifier  
 
qualified_meta_model_identifier ::= 
    [ { annex_identifier }** ] meta_model_class_identifier
 
meta_model_class_identifier ::= { identifier }+
 
reference_type ::=
     reference  [ ( reference_category 
                   { , reference_category }* ) ]
 
reference_category ::= 
    -- AADL or Annex meta model named element
    named_element_qualified_meta_model_identifier 
 
unique_property_type_identifier ::= 
    [ property_set_identifier :: ] property_type_identifier
 
record_type ::= 
    record ( record_field
             { record_field }* )
record_field ::= 
    defining_field_identifier : [ list of ] property_type_designator ;
 
property_type_designator ::= 
    unique_property_type_identifier |
    property_type

Naming Rules

(N1)     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. 

(N2)     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. 

(N3)     An enumeration type introduces an enumeration namespace.  The enumeration literal identifiers in the enumeration list declare an ordered list of enumeration literals. They must be unique within this namespace.

(N4)     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.

(N5)     The units identifier to the right of a => in a units literal statement must refer to a unit identifier defined earlier in the sequence of the same units type declaration.

(N6)     The classifier meta model identifier must refer to a class in the AADL meta model or an Annex meta model.  In the case of an Annex meta model, the identifier is qualified by the annex name.  Acceptable classes are listed in tabular form in Appendix C.3 and in relevant Annex standards.

(N7)     The named element meta model identifier must refer to a class in the AADL meta model or an Annex meta model that is a subclass of the NamedElement class and a structural feature, in the case of the AADL core language a subclass of the ClassifierFeature class. In the case of an Annex meta model, the identifier is qualified by the annex name. Acceptable classes are listed in tabular form in an appendix of this standard and in relevant Annex standards.

(N8)     The identifiers of the property field declarations in a record property type must be unique within the record declaration, i.e., the record type represents a local namespace for record field identifiers.

Legality Rules

(L1)      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 value’s units.

(L2)      Range values must always be declared with unit literals if the property requires a unit literal.

(L3)      The unique property constant identifier in an integer range must represent an integer constant. If the integer type requires units, then the constant value must include a unit literal of the specified units type.

(L4)      A boundless range type may be declared such that the actual range declarations have no limit on the upper and lower bound.

(L5)      The unique property constant identifier in a real range must represent a real constant. If the real type requires units, then the constant value must include a unit literal of the specified units type.

(L6)      If the property requires a unit, then the unit must be specified for both lower and upper bound and the unit literal must be of the specified units type..

(L7)      If a range is specified for aadlinteger or aadlreal then the actual value assigned to a property of this type must be within the specified range.

NOTES:

In the original AADL standard reserved words were used to identify the classifier category or reference category. Those names are compatible with the qualified meta model identifiers of AADL V2 with the exception of connections. It is now named connection.

Semantics

(2)   A property type declaration associates an identifier with a property type.

(3)   The aadlboolean property type represents the two values, true and false.

(4)   The aadlstring property type represents all legal strings of the AADL.

(5)   An enumeration property type represents an ordered list of enumeration identifiers as the set of legal values. 

(6)   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 a preceding unit to determine the value in terms of the specified measurement unit.

(7)   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

(8)   An aadlinteger property type represents an integer value or an integer value and its measurement unit.  If a 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 a units clause is absent, then the value is an integer value.

(9)   The range property 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. 

(10)  A classifier property type represents the subset of syntactically legal classifier references, whose class is a subclass of the Classifier meta model class and of one of the meta model classes listed in the classifier identifier list. For core AADL this is typically the meta model class that represents a component category.  If the classifier identifier list is absent, all classifier references are acceptable.

(11)  A reference property type represents the subset of syntactically legal references to those model elements, whose class is a subclass of the meta model class Named Element and ClassifierFeature or a structural element of an annex clause.  A ClassifierFeature is a structural element that is contained in a component, such as ports, flow specifications, subcomponents, or connections.  If the identifier list is absent, all model elements whose class is a subclass of NamedElement and ClassifierFeature are acceptable.

(12)  A record type represents a group of property associations, i.e., a collection of property values, where each element of the collection of property values is accessible by name.  The record fields must be explicitly declared by name, each with its own property type. 

NOTES:

The classifier and reference property types support the specification of properties representing binding constraints.

Units literals are not case sensitive.  For example, mW and MW represent the same units literal.  Therefore, it is advisable to choose literal names such as milliWatts and MegaWatts.

Examples

property set mine is

  Length_Unit : type units ( mm, cm => mm * 10,

                           m => cm * 100, km => m * 1000 );

  OnOff : type aadlboolean;

  -- This type declaration references a separately declared units type

  Car_Length : type aadlreal 1.5 m .. 4.5 m units mine::Length_Unit ;

  -- This type declaration defines the units in place

  Speed_Range : type range of aadlreal 0.0 kph .. 250.0 kph units ( kph );

  Position : type record (

       X: aadlinteger;

       Y: aadlinteger; );

end mine;

 

11.1.2     Property Definitions

(1)   All property names that appear in a property association list must be declared with property definition declarations inside a property set.  Properties are typed and are defined for any named element in an AADL model.

Syntax

property_definition_declaration ::= 
    defining_property_name_identifier:
        [ inherit ]
        ( single_valued_property | multi_valued_property )
        applies to (  property_owner { , property_owner }* ) ;
 
single_valued_property ::=
    property_type_designator [ => default_property_expression ]
 
multi_valued_property ::=
    { list of }+ property_type_designator 
    [ => default_property_list_value
    ]
 
property_owner ::= 
  -- AADL or Annex meta model named element
    named_element_qualified_meta_model_identifier  |
    unique_classifier_reference
 
unique_classifier_reference ::=
    package_name :: classifier_identifier

Note: Different from AADL V1 the access keyword is no longer used in property definitions. The fact that a property applies to an access feature is already specified in the applies to clause.

Naming Rules

(N1)     All defining identifiers of property definitions 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 definitions declared within that property set.

(N2)     A property is named by its property definition identifier or the qualified name specified by the property set/property definition identifier pair, separated by a double colon (“::”).  An unqualified property identifier must be part of the predeclared property sets.

(N3)     The named_element_meta_model_identifier must identify the name of a class in the AADL meta model or an Annex meta model that is a subclass of the AADL meta model class NamedElement.  In case of an Annex meta model, the identifier is qualified by the annex name.  Acceptable classes are listed in tabular form in an appendix of this standard and in relevant Annex standards.

(N4)     The unique_classifier_reference must identify the name of a classifier in the public section of the named package.

Legality Rules

(L1)      All properties are automatically defined for components of the category abstract, i.e., the category abstract is implicitly included in all applies to statements.

(L2)      Classifier and reference property definition must not have a default value.

Semantics

(2)   A property definition declaration introduces a new property 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 named elements of an AADL model whose meta model name is listed after the applies to in the  list, or those model elements that are of the specified component type.  Acceptable meta model names are listed in tabular form in Appendix C.3 of this standard and in relevant Annex standards.

(3)   The Property_Owner list may include component types qualified by a package name.  In this case, the property can only be associated with components of this component type or its extensions. If the Property_Owner list includes NamedElement, then the property can be associated with all model elements.

(4)   A property defined 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 11.3.

(5)   A property declared without a default value is considered undefined (see also Section 11.3).  A property declared to have a list of values is considered to have an empty list if no default value is declared.

Examples

-- added to Property Set mine from previous example

Value_Type: type enumeration ( estimate, benchmark, measured );

Rotation_Units: type units ( rpm );

  Position : type record (

       X: aadlinteger;

       Y: aadlinteger; );

GPS_Position : mine::Position applies to ( system );

 

 

11.1.3    Property Constants

(1)   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 
            property_type_designator
        => constant_property_expression;
 
multi_valued_property_constant ::=
    defining_property_constant_identifier : constant ( list of )+
            property_type_designator
        => constant_property_list_value ;
 
unique_property_constant_identifier ::= 
   [ property_set_identifier :: ] property_constant_identifier

Naming Rules

(N1)     The defining property constant identifier must be distinct from all other property constant identifiers, property definition identifiers, and property type identifiers in the namespace of the property set that contains the property constant declaration.

(N2)     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

(L1)      A property constant cannot be declared for the classifier property type or the reference property type.

(L2)      If a property constant declaration has more than one property expression, it must contain the reserved words list of.

(L3)      The property type of the property constant declaration must match the property type of the constant property value.

Semantics

(2)   Property constants allow integer, real, string, and other property values to be known by symbolic name and referenced by that name in property expressions.  This reference is expressed by referencing the unique property constant identifier.

Examples

Max_Threads : constant aadlinteger => 256;