The DaVinci Modeling Language (DML) provides abbreviations and comfort representations for some of the objects in the AUTOSAR model. The following is a complete list of all objects and features that have a simplified representation in the DaVinci Modeling Language:

notice

The generic representations are only mentioned to show how the comfort representations are mapped to the generic structure. Please always use the comfort notation in the DaVinci Modeling Language!

General Simplifications

The following are general simplifications which can be contained in different objects across the DML.

Comments

A comment is a description in the preferred language of the workbench preferences. The default is EN. If an object does contain a description in the preferred language, it will be displayed as a comment. If it does contain other descriptions but none is the preferred language, the first description will be displayed as a comment. A created comment will be stored as a description in the preferred language.

Comfort Representation

/* Description of an
* ARPackage */
ARPackage{
  descDE : "Beschreibung eines
            ARPackage"
  /* Object description */
  Object object {
    descDE : "Objectbeschreibung"
  }
}

Generic Representation

ARPackage{
  desc MultiLanguageOverviewParagraph {
    l2s [
      LOverviewParagraph {
        l : EN
        mixedContentForOverviewParagraphChildren [
          MixedTextItem {
            value : "Description of an
                     ARPackage"
          }
        ]
      }
      LOverviewParagraph {
        l : DE
        mixedContentForOverviewParagraphChildren [
          MixedTextItem {
            value : "Beschreibung eines
                     ARPackage"
          }
        ]
      }
    ]
  }
  Object object {
    desc MultiLanguageOverviewParagraph {
      l2s [
        LOverviewParagraph {
          l : EN
          mixedContentForOverviewParagraphChildren [
            MixedTextItem {
              value : "Object description"
            }
          ]
        }
        LOverviewParagraph {
          l : DE
            mixedContentForOverviewParagraphChildren [
              MixedTextItem {
                value : "Objectbeschreibung"
              }
            ]
        }
      ]
    }
  }
}

Description

The simplified description items are only available if there is exactly one MixedTextItem contained in each LOverviewParagraph. In all other cases the generic representation is used!

Comfort Representation

descEN : "Example description
          over multiple lines"
descDE : "Beispiel Beschreibung"

Generic Representation

desc MultiLanguageOverviewParagraph {
  l2s [
    LOverviewParagraph {
      l : EN
      mixedContentForOverviewParagraphChildren [
        MixedTextItem {
          value : "Example description
                   over multiple lines"
        }
      ]
    }
    LOverviewParagraph {
      l : DE
      mixedContentForOverviewParagraphChildren [
        MixedTextItem {
          value : "Beispiel Beschreibung"
        }
      ]
    }
  ]
}

 

Namespace

Comfort Representation

namespace : vector::example

Generic Representation

namespaces [
  SymbolProps ns0 {
    symbol : "vector"
  }
  SymbolProps ns1 {
    symbol : "example"
  }
]

 

ValueVariationPoints

Comfort Representation

initValue NumericalValueSpecification {
  value : 0.2
}

Generic Representation

initValue NumericalValueSpecification {
  value NumericalValueVariationPoint {
    formulaExpressionChildren [
      MixedTextItem {
        value : "0.2"
      }
    ]
  }
}

 

InstanceReferences

Comfort Representation

CompositionPPortToExecutablePPortMapping InstanceRef {
  executableProvidedPort => /vector/InstanceRef/executable/rootPrototype.contextPrototype1.contextPrototype2.targetPort
}

Generic Representation

CompositionPPortToExecutablePPortMapping InstanceRef {
  executableProvidedPort PPortPrototypeInExecutableInstanceRef {
    targetPPortPrototype -> /vector/ComponentTypes/compSwCompType2/targetPort
    contextComponentPrototypes [
      -> /vector/ComponentTypes/compSwCompType1/contextPrototype1
      -> /vector/ComponentTypes/compSwCompType2/contextPrototype2
    ]
    contextRootSwComponentPrototype -> /vector/InstanceRef/executable/rootPrototype
  }
}

 

Value Specifications

Comfort Representation

PersistencyKeyValueStorage keyValueStorage {
  keyValuePairs [
    PersistencyKeyValuePair textuals {
      initValue ArrayValueSpecification {
        textualValueSpecificationElements [
          "text1" , "text2"
        ]
      }
    }
    PersistencyKeyValuePair numerics {
      initValue ArrayValueSpecification {
        numericalValueSpecificationElements [
          false , true , 0 , 0.0 , "1+true"
        ]
      }
    }
    PersistencyKeyValuePair references {
      initValue ArrayValueSpecification {
        constantReferenceElements [
          -> /ref/Reference1
          -> /ref/Reference2
        ]
      }
    }
  ]
}

Generic Representation

PersistencyKeyValueStorage keyValueStorage {
  keyValuePairs [
    PersistencyKeyValuePair textuals {
      initValue ArrayValueSpecification {
        elements [
          TextValueSpecification {
            value : "text1"
          }
          TextValueSpecification {
            value : "text2"
          }
        ]
      }
    }
    PersistencyKeyValuePair numerics {
      initValue ArrayValueSpecification {
        elements [
          NumericalValueSpecification {
            value NumericalValueVariationPoint {
              formulaExpressionChildren [
                MixedTextItem {
                  value : "false"
                }
              ]
            }
          }
          NumericalValueSpecification {
            value NumericalValueVariationPoint {
              formulaExpressionChildren [
                MixedTextItem {
                  value : "true"
                }
              ]
            }
          }
          NumericalValueSpecification {
            value NumericalValueVariationPoint {
              formulaExpressionChildren [
                MixedTextItem {
                  value : "0"
                }
              ]
            }
          }
          NumericalValueSpecification {
            value NumericalValueVariationPoint {
              formulaExpressionChildren [
                MixedTextItem {
                  value : "0.0"
                }
              ]
            }
          }
          NumericalValueSpecification {
            value NumericalValueVariationPoint {
              formulaExpressionChildren [
                MixedTextItem {
                  value : "1+true"
                }
              ]
            }
          }
        ]
      }
    }
    PersistencyKeyValuePair references {
      initValue ArrayValueSpecification {
        elements [
          ConstantReference {
            constant -> /ref/Reference1
          }
          ConstantReference {
            constant -> /ref/Reference2
          }
        ]
      }
    }
  ]
}

Service Interfaces

Service interfaces contain simplifications for the display of events and methods.

Comfort Representation

ServiceInterface MyServiceInterface {
  events [
    Event /AUTOSAR/StdTypes/bool MyEvent {}
  ]
  methods [
    Method MyMethod {
      arguments [
        InArgument /AUTOSAR/StdTypes/int32_t inArg {}
        OutArgument /AUTOSAR/StdTypes/int32_t outArg {}
      ]
    }
  ]
}

Generic Representation

ServiceInterface MyServiceInterface {
  events [
    VariableDataPrototype /AUTOSAR/StdTypes/bool MyEvent {}
  ]
  methods [
    ClientServerOperation MyMethod {
      arguments [
        ArgumentDataPrototype /AUTOSAR/StdTypes/int32_t inArg {
          direction : IN
        }
        ArgumentDataPrototype /AUTOSAR/StdTypes/int32_t outArg {
          direction : OUT
        }
      ]
    }
  ]
}

C++ DataTypes

The following is an overview of all C++ data types comfort representations:

CppArray

Example of a C++ Array notation in the DML.

Comfort Representation

StdCppImplementationDataTypeArray MyArray {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/int32_t @inplace
  size : 16
}

Generic Representation

StdCppImplementationDataType MyArray {
  category : "ARRAY"
  templateArguments [
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/int32_t
    }
  ]
  arraySize PositiveIntegerValueVariationPoint {
    formulaExpressionChildren [
      MixedTextItem {
        value : "16"
      }
    ]
  }
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CppBitfield

Example of a C++ Bitfield notation in the DML.

Note: in the generic representation the has to be replaced by the correct path to the CompuMethod

Comfort Representation

StdCppImplementationDataTypeBitfield MyBitfield {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/uint16_t
  bitfieldEntries [
    CppBitfieldEntry MyBitfieldEntry {
      mask : 0b0
      value : 0b1000
    }
  ]
}

Generic Representation

StdCppImplementationDataType MyBitfield {
  category : "TYPE_REFERENCE"
  typeReference -> /AUTOSAR/StdTypes/uint16_t
  swDataDefProps SwDataDefProps {
    swDataDefPropsVariants [
      SwDataDefPropsConditional {
        compuMethod -> /<pathTo>/MyBitfield_CompuMethod
      }
    ]
  }
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}
CompuMethod MyBitfield_CompuMethod {
  category : "BITFIELD_TEXTTABLE"
  compuInternalToPhys Compu {
    compuContent CompuScales {
      compuScales [
        CompuScale {
          mask : 0
          symbol : "MyBitfieldEntry"
          upperLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
               value : "8"
              }
            ]
          }
          lowerLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "8"
              }
            ]
          }
        }
      ]
    }
  }
}

 

CppEnum

Example of a C++ Enum notation in the DML.

Note: in the generic representation the has to be replaced by the correct path to the CompuMethod

Comfort Representation

StdCppImplementationDataTypeEnum MyEnum {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/int8_t
  ON = 1
  OFF = 0
}

Generic Representation

StdCppImplementationDataType MyEnum {
  category : "TYPE_REFERENCE"
  typeReference -> /AUTOSAR/StdTypes/int8_t
  swDataDefProps SwDataDefProps {
    swDataDefPropsVariants [
      SwDataDefPropsConditional {
        compuMethod -> /<pathTo>/MyEnum_CompuMethod
      }
    ]
  }
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}
CompuMethod MyEnum_CompuMethod {
  category : "TEXTTABLE"
  compuInternalToPhys Compu {
    compuContent CompuScales {
      compuScales [
        CompuScale {
          symbol : "ON"
          upperLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "1"
              }
            ]
          }
          lowerLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "1"
              }
            ]
          }
        }
        CompuScale {
          symbol : "OFF"
          upperLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "0"
              }
            ]
          }
          lowerLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "0"
              }
            ]
          }
        }
      ]
    }
  }
}

 

CppMap

Example of a C++ Map notation in the DML.

Comfort Representation

StdCppImplementationDataTypeMap MyMap {
namespace : vector::example
  key : /AUTOSAR/StdTypes/double @inplace
  value : /AUTOSAR/StdTypes/float @inplace
  allocator : /path/to/MyAllocator
}

Generic Representation

StdCppImplementationDataType MyMap {
  category : "ASSOCIATIVE_MAP"
  templateArguments [
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/double
    }
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/float
    }
    CppTemplateArgument {
      allocator -> /path/to/MyAllocator
    }
  ]
  namespaces [
    SymbolProps ns0 {
    symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CppReference

Example of a C++ Reference notation in the DML.

Comfort Representation

StdCppImplementationDataTypeRef MyReference {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/uint64_t
}

Generic Representation

StdCppImplementationDataType MyReference {
  category : "TYPE_REFERENCE"
  typeReference -> /AUTOSAR/StdTypes/uint64_t
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CppString

Example of a C++ String notation in the DML.

Comfort Representation

StdCppImplementationDataTypeString MyString {
  namespace : vector::example
  allocator : /path/to/MyAllocator
}

Generic Representation

StdCppImplementationDataType MyString {
  category : "STRING"
  templateArguments [
    CppTemplateArgument {
      allocator -> /path/to/MyAllocator
    }
  ]
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CppStruct

Example of a C++ Struct notation in the DML.

Comfort Representation

StdCppImplementationDataTypeStruct MyStruct {
  namespace : vector::example
  X : /AUTOSAR/StdTypes/uint32_t @inplace @optional
  Y : /AUTOSAR/StdTypes/uint32_t @inplace @optional
}

Generic Representation

StdCppImplementationDataType MyStruct {
  category : "STRUCTURE"
  subElements [
    CppImplementationDataTypeElement X {
      isOptional : true
      typeReference CppImplementationDataTypeElementQualifier {
        inplace : true
        typeReference -> /AUTOSAR/StdTypes/uint32_t
      }
    }
    CppImplementationDataTypeElement Y {
      isOptional : true
      typeReference CppImplementationDataTypeElementQualifier {
        inplace : true
        typeReference -> /AUTOSAR/StdTypes/uint32_t
      }
    }
  ]
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CppValue

Example of a C++ Value notation in the DML.

Comfort Representation

StdCppImplementationDataTypeValue uint8_t {}

Generic Representation

StdCppImplementationDataType uint8_t {
  category : "VALUE"
}

 

CppVariant

Example of a C++ Variant notation in the DML.

Comfort Representation

StdCppImplementationDataTypeVariant MyVariant {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/int8_t @inplace
  type : /AUTOSAR/StdTypes/int16_t @inplace
}

Generic Representation

StdCppImplementationDataType MyVariant {
  category : "VARIANT"
  templateArguments [
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/int8_t
    }
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/int16_t
    }
  ]
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CppVector

Example of a C++ Vector notation in the DML.

Comfort Representation

StdCppImplementationDataTypeVector MyVector {
  namespace : vector::example
  maxSize : 64
  type : /AUTOSAR/StdTypes/uint32_t @inplace
}

Generic Representation

StdCppImplementationDataType MyVector {
  category : "VECTOR"
  templateArguments [
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/uint32_t
    }
  ]
  arraySize PositiveIntegerValueVariationPoint {
    formulaExpressionChildren [
      MixedTextItem {
        value : "64"
      }
    ]
  }
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

Custom C++ DataTypes

The following is an overview of all Custom C++ data types comfort representations:

CustomCppArray

Example of a Custom C++ Array notation in the DML.

Comfort Representation

CustomCppImplementationDataTypeArray MyCustomArray {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/int32_t @inplace
  size : 16
}

Generic Representation

CustomCppImplementationDataType MyCustomArray {
  category : "ARRAY"
  templateArguments [
    CppTemplateArgument {
      inplace : true
        templateType -> /AUTOSAR/StdTypes/int32_t
    }
  ]
  arraySize PositiveIntegerValueVariationPoint {
    formulaExpressionChildren [
      MixedTextItem {
        value : "16"
      }
    ]
  }
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CustomCppBitfield

Example of a Custom C++ Bitfield notation in the DML.

notice

In the generic representation the has to be replaced by the correct path to the CompuMethod

Comfort Representation

CustomCppImplementationDataTypeBitfield MyCustomBitfield {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/uint16_t
  bitfieldEntries [
    CppBitfieldEntry MyBitfieldEntry {
      mask : 0b0
      value : 0b1000
    }
  ]
}

Generic Representation

CustomCppImplementationDataType MyCustomBitfield {
  category : "TYPE_REFERENCE"
  typeReference -> /AUTOSAR/StdTypes/uint16_t
  swDataDefProps SwDataDefProps {
    swDataDefPropsVariants [
      SwDataDefPropsConditional {
        compuMethod -> /<pathTo>/MyCustomBitfield_CompuMethod
      }
    ]
  }
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}
CompuMethod MyCustomBitfield_CompuMethod {
  category : "BITFIELD_TEXTTABLE"
  compuInternalToPhys Compu {
    compuContent CompuScales {
      compuScales [
        CompuScale {
          mask : 0
          symbol : "MyBitfieldEntry"
          upperLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "8"
              }
            ]
          }
          lowerLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "8"
              }
            ]
          }
        }
      ]
    }
  }
}

 

CustomCppEnum

Example of a Custom C++ Enum notation in the DML.

notice

In the generic representation the has to be replaced by the correct path to the CompuMethod

Comfort Representation

CustomCppImplementationDataTypeEnum MyCustomEnum {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/int8_t
  ON = 1
  OFF = 0
}

Generic Representation

CustomCppImplementationDataType MyCustomEnum {
  category : "TYPE_REFERENCE"
  typeReference -> /AUTOSAR/StdTypes/int8_t
  swDataDefProps SwDataDefProps {
    swDataDefPropsVariants [
      SwDataDefPropsConditional {
        compuMethod -> /<pathTo>/MyCustomEnum_CompuMethod
      }
    ]
  }
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}
CompuMethod MyCustomEnum_CompuMethod {
  category : "TEXTTABLE"
  compuInternalToPhys Compu {
    compuContent CompuScales {
      compuScales [
        CompuScale {
          symbol : "ON"
          upperLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "1"
              }
            ]
          }
          lowerLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "1"
              }
            ]
          }
        }
        CompuScale {
          symbol : "OFF"
          upperLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "0"
              }
            ]
          }
          lowerLimit LimitValueVariationPoint {
            formulaExpressionChildren [
              MixedTextItem {
                value : "0"
              }
            ]
          }
        }
      ]
    }
  }
}

 

CustomCppMap

Example of a Custom C++ Map notation in the DML.

Comfort Representation

CustomCppImplementationDataTypeMap MyCustomMap {
  namespace : vector::example
  key : /AUTOSAR/StdTypes/double @inplace
  value : /AUTOSAR/StdTypes/float @inplace
  allocator : /path/to/MyAllocator
}

Generic Representation

CustomCppImplementationDataType MyCustomMap {
  category : "ASSOCIATIVE_MAP"
  templateArguments [
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/double
    }
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/float
    }
    CppTemplateArgument {
      allocator -> /path/to/MyAllocator
    }
  ]
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CustomCppReference

Example of a Custom C++ Reference notation in the DML.

Comfort Representation

CustomCppImplementationDataTypeRef MyCustomReference {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/uint64_t
}

Generic Representation

CustomCppImplementationDataType MyCustomReference {
  category : "TYPE_REFERENCE"
  typeReference -> /AUTOSAR/StdTypes/uint64_t
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CustomCppString

Example of a Custom C++ String notation in the DML.

Comfort Representation

CustomCppImplementationDataTypeString MyCustomString {
  namespace : vector::example
  allocator : /path/to/MyAllocator
}

Generic Representation

CustomCppImplementationDataType MyCustomString {
  category : "STRING"
  templateArguments [
    CppTemplateArgument {
      allocator -> /path/to/MyAllocator
    }
  ]
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CustomCppStruct

Example of a Custom C++ Struct notation in the DML.

Comfort Representation

CustomCppImplementationDataTypeStruct MyCustomStruct {
  namespace : vector::example
  X : /AUTOSAR/StdTypes/uint32_t @inplace @optional
  Y : /AUTOSAR/StdTypes/uint32_t @inplace @optional
}

Generic Representation

CustomCppImplementationDataType MyCustomStruct {
  category : "STRUCTURE"
  subElements [
    CppImplementationDataTypeElement X {
      isOptional : true
      typeReference CppImplementationDataTypeElementQualifier {
        inplace : true
        typeReference -> /AUTOSAR/StdTypes/uint32_t
      }
    }
    CppImplementationDataTypeElement Y {
      isOptional : true
      typeReference CppImplementationDataTypeElementQualifier {
        inplace : true
        typeReference -> /AUTOSAR/StdTypes/uint32_t
      }
    }
  ]
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CustomCppValue

Example of a Custom C++ Value notation in the DML.

Comfort Representation

CustomCppImplementationDataTypeValue uint16_t {}

Generic Representation

CustomCppImplementationDataType uint16_t {
  category : "VALUE"
}

 

CustomCppVariant

Example of a Custom C++ Variant notation in the DML.

Comfort Representation

CustomCppImplementationDataTypeVariant MyCustomVariant {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/int8_t @inplace
  type : /AUTOSAR/StdTypes/int16_t @inplace
}

Generic Representation

CustomCppImplementationDataType MyCustomVariant {
  category : "VARIANT"
  templateArguments [
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/int8_t
    }
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/int16_t
    }
  ]
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}

 

CustomCppVector

Example of a Custom C++ Vector notation in the DML.

Comfort Representation

CustomCppImplementationDataTypeVector MyCustomVector {
  namespace : vector::example
  type : /AUTOSAR/StdTypes/uint32_t @inplace
}

Generic Representation

CustomCppImplementationDataType MyCustomVector {
  category : "VECTOR"
  templateArguments [
    CppTemplateArgument {
      inplace : true
      templateType -> /AUTOSAR/StdTypes/uint32_t
    }
  ]
  namespaces [
    SymbolProps ns0 {
      symbol : "vector"
    }
    SymbolProps ns1 {
      symbol : "example"
    }
  ]
}