Properties. Quantities associated with a component that describe
how the application the component wraps is to be used or that specify
information required by the application (e.g., files, executable calls,
etc.). Properties are typically process-oriented quantities and are defined
for the component type as a whole. Each usage/instance of the component
will have all properties defined in a descriptor for the component (values
for the properties will be set based on specific instance usage).
Parameters. Quantities that are to be exposed as inputs whose
values can be driven externally (by other components) and outputs whose
values can be accessed by other components. Parameters are typically—but
not necessarily—product-oriented quantities (representing the physical
aspects of the product and/or its performance) and are defined on a per-instance
basis. Each use of the component has a different set of defined parameters
(not just different parameter values) based on the usage.
When applicable, some parameters can actually be predefined in the descriptor
for the component, in which case they will be defined for each instance.
Properties and parameters both have:
- Mode
Input, output, inout, or local (i.e., not exposed, used internally).
Properties are “local” by nature; therefore, mode does not apply
and is ignored.
- Structure
Scalar, array, or aggregate (a tree-like structure of possibly
mixed data types).
- Type
Real, integer, string, Boolean, file, or other user-specified
data type.
Optionally, properties and parameters can also have:
- Limits
Limitations on what the value can be, specified by upper/lower
values, ranges, or discrete sets.
- Units
Classification of what the value physically represents (mm, secs,
mph, etc).
You will see in later examples that because the difference between a parameter
and a property is the scope in which it is being used, programmatically
both are represented by the same “Variable” class and a “role”
attribute specifies it as a parameter or property.