General 0.5.X architecture.

[qg020]

First question is regarding the underlying architecture of 0.5.x. It finally hit me this morning that if I know the XML elements I need in the output ARXML, I can search elements.py for the XML tag to find the objects I need to instantiate.

For instance, here are a P-PORT and R-PORT definition generated with ver 0.4:

        <P-PORT-PROTOTYPE>
          <SHORT-NAME>PPort_xevPOC2CmdSpdPerc</SHORT-NAME>
          <PROVIDED-COM-SPECS>
            <NONQUEUED-SENDER-COM-SPEC>
              <DATA-ELEMENT-REF DEST="VARIABLE-DATA-PROTOTYPE">/xevpoc2_IF/xevPOCCmdSpdPerc/xevPOCCmdSpdPerc</DATA-ELEMENT-REF>
              <USES-END-TO-END-PROTECTION>false</USES-END-TO-END-PROTECTION>
            </NONQUEUED-SENDER-COM-SPEC>
          </PROVIDED-COM-SPECS>
          <PROVIDED-INTERFACE-TREF DEST="SENDER-RECEIVER-INTERFACE">/xevpoc2_IF/xevPOCCmdSpdPerc</PROVIDED-INTERFACE-TREF>
        </P-PORT-PROTOTYPE>
        <R-PORT-PROTOTYPE>
          <SHORT-NAME>RPort_DCDCUnitEnabled</SHORT-NAME>
          <REQUIRED-COM-SPECS>
            <NONQUEUED-RECEIVER-COM-SPEC>
              <DATA-ELEMENT-REF DEST="VARIABLE-DATA-PROTOTYPE">/xevpoc2_IF/DCDCUnitEnabled/DCDCUnitEnabled</DATA-ELEMENT-REF>
              <USES-END-TO-END-PROTECTION>false</USES-END-TO-END-PROTECTION>
              <ALIVE-TIMEOUT>0</ALIVE-TIMEOUT>
              <ENABLE-UPDATE>false</ENABLE-UPDATE>
              <FILTER>
                <DATA-FILTER-TYPE>ALWAYS</DATA-FILTER-TYPE>
              </FILTER>
              <HANDLE-NEVER-RECEIVED>false</HANDLE-NEVER-RECEIVED>
            </NONQUEUED-RECEIVER-COM-SPEC>
          </REQUIRED-COM-SPECS>
          <REQUIRED-INTERFACE-TREF DEST="SENDER-RECEIVER-INTERFACE">/xevpoc2_IF/DCDCUnitEnabled</REQUIRED-INTERFACE-TREF>
        </R-PORT-PROTOTYPE>

From this and element.py I know I need to instantiate:

ProvidePortPrototype (P-PORT-PROTOTYPE)
RequirePortPrototype (R-PORT-PROTOTYPE)
ProvidePortComSpec (PROVIDED-COM-SPECS - and passed into port constructors as a list of ProvidePortComSpec objects)
RequirePortComSpec (REQUIRED-COM-SPECS - and passed into port constructors as a list of RequirePortComSpec objects)
NonqueuedSenderComSpec (NONQUEUED-SENDER-COM-SPEC - and the data element necessary)
NonqueuedReceiverComSpec (NONQUEUED-RECEIVER-COM-SPEC - and the data element necessary)
PortInterfaceRef (for both PROVIDED-INTERFACE-TREF and REQUIRED-INTERFACE_TREF)
etc.

Correct?

If so, then I can easily see from the ARXML examples I need to generate what I need to create for all elements. I can also see what is currently supported and what will need to wait for later releases.

[cogu]

Short answer: Yes, you can most often search for an XML tag in element.py and find the corresponding Python class name.

Long answer: When I implement an element in element.py I try to document all the possible XML-tags it can have in the class description using the title tag-variants:. Sometimes you find one tag there, other times several and in some rare cases I was too lazy and just typed "Too many to list" when it truly was too many to list.

The true source of this information is the AUTOSAR XML Schema file. I'm currently using AUTOSAR_00051.xsd as reference which you can download from autosar.org.

In the schema file there are two kinds of elements called called Complex Type and Group.

Complex Types are elements which can have an XML tag but the actual tag name depends on its direct ancestor (parent XML element).

Groups are elements which cannot be created but are acting as a sort of base class for various complex types. Any complex type can inherit any number of groups. The hierarchies can be seen in the schema. It also uses multiple inheritance which I so far have been able to avoid while porting it to Python.

Even the CHANGELOG is written from XML schema perspective. All the text-strings prefixed with AR: are search terms you can use to find references in the schema file.

The Python class names themselves are also from the schema file. Each group and complex-type has a camel-case name which I believe comes from the Enterprise Architect model which is the origin to the schema file. They can be found amongst the annotation-text attached to each element. I try to use those when I define a Python class.

Only in some rare occasions have I deviated from the camel-cased name. For example, in some instances I have merged two groups or two complex-types together into a single Python class. These merges are documented in element.py.