10.1 Property Sets
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.
10.1.1 Property Types
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 value’s 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 );
10.1.2 Property Names
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 );
10.1.3 Property Constants
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;