odxtools 7.0.0__py3-none-any.whl → 7.1.1__py3-none-any.whl

odxtools/basicstructure.py

@@ -23,7 +23,6 @@ from .parameters.parameter import Parameter
 from .parameters.parameterwithdop import ParameterWithDOP
 from .parameters.physicalconstantparameter import PhysicalConstantParameter
 from .parameters.tablekeyparameter import TableKeyParameter
-from .parameters.tablestructparameter import TableStructParameter
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -307,7 +306,4 @@ class BasicStructure(ComplexDop):
         super()._resolve_snrefs(diag_layer)
 
         for param in self.parameters:
-            if isinstance(param, TableStructParameter):
-                param._table_struct_resolve_snrefs(diag_layer, param_list=self.parameters)
-            else:
-                param._resolve_snrefs(diag_layer)
+            param._parameter_resolve_snrefs(diag_layer, param_list=self.parameters)

odxtools/diagcomm.py

@@ -11,7 +11,7 @@ from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
 from .functionalclass import FunctionalClass
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
 from .specialdatagroup import SpecialDataGroup
 from .state import State
@@ -211,5 +211,13 @@ class DiagComm(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(diag_layer)
 
-        self._protocols = NamedItemList(
-            [diag_layer.protocols[prot_snref] for prot_snref in self.protocol_snrefs])
+        if TYPE_CHECKING:
+            self._protocols = NamedItemList([
+                resolve_snref(prot_snref, diag_layer.protocols, DiagLayer)
+                for prot_snref in self.protocol_snrefs
+            ])
+        else:
+            self._protocols = NamedItemList([
+                resolve_snref(prot_snref, diag_layer.protocols)
+                for prot_snref in self.protocol_snrefs
+            ])

odxtools/diagdatadictionaryspec.py

@@ -10,6 +10,7 @@ from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .dopbase import DopBase
 from .dtcdop import DtcDop
+from .dynamicendmarkerfield import DynamicEndmarkerField
 from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
 from .environmentdata import EnvironmentData
@@ -37,7 +38,7 @@ class DiagDataDictionarySpec:
     structures: NamedItemList[BasicStructure]
     static_fields: NamedItemList[StaticField]
     dynamic_length_fields: NamedItemList[DynamicLengthField]
-    #dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField]
+    dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField]
     end_of_pdu_fields: NamedItemList[EndOfPduField]
     muxs: NamedItemList[Multiplexer]
     env_datas: NamedItemList[EnvironmentData]
@@ -54,7 +55,7 @@ class DiagDataDictionarySpec:
                 self.structures,
                 self.static_fields,
                 self.dynamic_length_fields,
-                #self.dynamic_endmarker_fields,
+                self.dynamic_endmarker_fields,
                 self.end_of_pdu_fields,
                 self.muxs,
                 self.env_datas,
@@ -99,11 +100,10 @@ class DiagDataDictionarySpec:
             for dl_element in et_element.iterfind("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD")
         ]
 
-        # TODO: dynamic endmarker fields
-        #dynamic_endmarker_fields = [
-        #    DynamicEndmarkerField.from_et(dl_element, doc_frags)
-        #    for dl_element in et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
-        #]
+        dynamic_endmarker_fields = [
+            DynamicEndmarkerField.from_et(dl_element, doc_frags) for dl_element in
+            et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
+        ]
 
         end_of_pdu_fields = [
             EndOfPduField.from_et(eofp_element, doc_frags)
@@ -145,7 +145,7 @@ class DiagDataDictionarySpec:
             structures=NamedItemList(structures),
             static_fields=NamedItemList(static_fields),
             dynamic_length_fields=NamedItemList(dynamic_length_fields),
-            #dynamic_endmarker_fields=NamedItemList(dynamic_endmarker_fields),
+            dynamic_endmarker_fields=NamedItemList(dynamic_endmarker_fields),
             end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
             muxs=NamedItemList(muxs),
             env_datas=NamedItemList(env_datas),
@@ -172,8 +172,8 @@ class DiagDataDictionarySpec:
             odxlinks.update(static_field._build_odxlinks())
         for dynamic_length_field in self.dynamic_length_fields:
             odxlinks.update(dynamic_length_field._build_odxlinks())
-        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-        #    odxlinks.update(dynamic_endmarker_field._build_odxlinks())
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            odxlinks.update(dynamic_endmarker_field._build_odxlinks())
         for end_of_pdu_field in self.end_of_pdu_fields:
             odxlinks.update(end_of_pdu_field._build_odxlinks())
         for mux in self.muxs:
@@ -204,8 +204,8 @@ class DiagDataDictionarySpec:
             static_field._resolve_odxlinks(odxlinks)
         for dynamic_length_field in self.dynamic_length_fields:
             dynamic_length_field._resolve_odxlinks(odxlinks)
-        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-        #    dynamic_endmarker_field._resolve_odxlinks(odxlinks)
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            dynamic_endmarker_field._resolve_odxlinks(odxlinks)
         for end_of_pdu_field in self.end_of_pdu_fields:
             end_of_pdu_field._resolve_odxlinks(odxlinks)
         for mux in self.muxs:
@@ -234,8 +234,8 @@ class DiagDataDictionarySpec:
             static_field._resolve_snrefs(diag_layer)
         for dynamic_length_field in self.dynamic_length_fields:
             dynamic_length_field._resolve_snrefs(diag_layer)
-        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-        #    dynamic_endmarker_field._resolve_snrefs(diag_layer)
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            dynamic_endmarker_field._resolve_snrefs(diag_layer)
         for end_of_pdu_field in self.end_of_pdu_fields:
             end_of_pdu_field._resolve_snrefs(diag_layer)
         for mux in self.muxs:

odxtools/diaglayer.py

@@ -15,6 +15,7 @@ from .admindata import AdminData
 from .companydata import CompanyData
 from .comparaminstance import ComparamInstance
 from .comparamspec import ComparamSpec
+from .comparamsubset import ComparamSubset
 from .diagcomm import DiagComm
 from .diagdatadictionaryspec import DiagDataDictionarySpec
 from .diaglayerraw import DiagLayerRaw
@@ -216,6 +217,10 @@ class DiagLayer:
             lambda ddd_spec: ddd_spec.end_of_pdu_fields,
             lambda parent_ref: parent_ref.not_inherited_dops,
         )
+        dynamic_endmarker_fields = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.dynamic_endmarker_fields,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
         dynamic_length_fields = self._compute_available_ddd_spec_items(
             lambda ddd_spec: ddd_spec.dynamic_length_fields,
             lambda parent_ref: parent_ref.not_inherited_dops,
@@ -246,6 +251,7 @@ class DiagLayer:
             structures=structures,
             static_fields=NamedItemList(),
             end_of_pdu_fields=end_of_pdu_fields,
+            dynamic_endmarker_fields=dynamic_endmarker_fields,
             dynamic_length_fields=dynamic_length_fields,
             tables=tables,
             env_data_descs=env_data_descs,
@@ -351,7 +357,7 @@ class DiagLayer:
         return self.diag_layer_raw.prot_stack_snref
 
     @property
-    def comparam_spec(self) -> Optional[ComparamSpec]:
+    def comparam_spec(self) -> Optional[Union[ComparamSpec, ComparamSubset]]:
         return self.diag_layer_raw.comparam_spec
 
     @property

odxtools/diaglayerraw.py

@@ -9,6 +9,7 @@ from .admindata import AdminData
 from .companydata import CompanyData
 from .comparaminstance import ComparamInstance
 from .comparamspec import ComparamSpec
+from .comparamsubset import ComparamSubset
 from .createsdgs import create_sdgs_from_et
 from .diagcomm import DiagComm
 from .diagdatadictionaryspec import DiagDataDictionarySpec
@@ -19,7 +20,7 @@ from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
 from .functionalclass import FunctionalClass
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .parentref import ParentRef
 from .protstack import ProtStack
 from .request import Request
@@ -243,7 +244,10 @@ class DiagLayerRaw(IdentifiableElement):
         """Recursively resolve all references."""
 
         if self.comparam_spec_ref is not None:
-            self._comparam_spec = odxlinks.resolve(self.comparam_spec_ref, ComparamSpec)
+            spec = odxlinks.resolve(self.comparam_spec_ref)
+            if not isinstance(spec, (ComparamSubset, ComparamSpec)):
+                odxraise(f"Type {type(spec).__name__} is not allowed for comparam specs")
+            self._comparam_spec = spec
 
         # do ODXLINK reference resolution
         if self.admin_data is not None:
@@ -281,8 +285,10 @@ class DiagLayerRaw(IdentifiableElement):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         self._prot_stack: Optional[ProtStack] = None
         if self.prot_stack_snref is not None:
-            self._prot_stack = odxrequire(
-                odxrequire(self.comparam_spec).prot_stacks.get(self.prot_stack_snref))
+            cp_spec = self.comparam_spec
+            if isinstance(cp_spec, ComparamSpec):
+                self._prot_stack = resolve_snref(self.prot_stack_snref, cp_spec.prot_stacks,
+                                                 ProtStack)
 
         # do short-name reference resolution
         if self.admin_data is not None:
@@ -292,8 +298,8 @@ class DiagLayerRaw(IdentifiableElement):
 
         for company_data in self.company_datas:
             company_data._resolve_snrefs(diag_layer)
-        for functional_classe in self.functional_classes:
-            functional_classe._resolve_snrefs(diag_layer)
+        for functional_class in self.functional_classes:
+            functional_class._resolve_snrefs(diag_layer)
         for diag_comm in self.diag_comms:
             if isinstance(diag_comm, OdxLinkRef):
                 continue
@@ -318,7 +324,7 @@ class DiagLayerRaw(IdentifiableElement):
             comparam._resolve_snrefs(diag_layer)
 
     @property
-    def comparam_spec(self) -> Optional[ComparamSpec]:
+    def comparam_spec(self) -> Optional[Union[ComparamSpec, ComparamSubset]]:
         return self._comparam_spec
 
     @property

odxtools/dynamicendmarkerfield.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Sequence
+from xml.etree import ElementTree
+
+from typing_extensions import override
+
+from .dataobjectproperty import DataObjectProperty
+from .decodestate import DecodeState
+from .dynenddopref import DynEndDopRef
+from .encodestate import EncodeState
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .field import Field
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import AtomicOdxType, ParameterValue
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .diaglayer import DiagLayer
+
+
+@dataclass
+class DynamicEndmarkerField(Field):
+    """Array of a structure with variable length determined by a termination sequence"""
+
+    dyn_end_dop_ref: DynEndDopRef
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynamicEndmarkerField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+
+        dyn_end_dop_ref = DynEndDopRef.from_et(
+            odxrequire(et_element.find("DYN-END-DOP-REF")), doc_frags)
+
+        return DynamicEndmarkerField(dyn_end_dop_ref=dyn_end_dop_ref, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        self._dyn_end_dop = odxlinks.resolve(self.dyn_end_dop_ref, DataObjectProperty)
+
+        tv_string = self.dyn_end_dop_ref.termination_value_raw
+        tv_physical = self._dyn_end_dop.diag_coded_type.base_data_type.from_string(tv_string)
+
+        self._termination_value = tv_physical
+
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        super()._resolve_snrefs(diag_layer)
+
+    @property
+    def dyn_end_dop(self) -> DataObjectProperty:
+        return self._dyn_end_dop
+
+    @property
+    def termination_value(self) -> AtomicOdxType:
+        return self._termination_value
+
+    @override
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+
+        odxassert(encode_state.cursor_bit_position == 0,
+                  "No bit position can be specified for dynamic endmarker fields!")
+        if not isinstance(physical_value, Sequence):
+            odxraise(
+                f"Expected a sequence of values for dynamic endmarker field {self.short_name}, "
+                f"got {type(physical_value).__name__}", EncodeError)
+            return
+
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+        for i, item in enumerate(physical_value):
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+            self.structure.encode_into_pdu(item, encode_state)
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+        if not encode_state.is_end_of_pdu:
+            # only add an endmarker if we are not at the end of the PDU
+            self.dyn_end_dop.encode_into_pdu(self.termination_value, encode_state)
+
+    @override
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+
+        odxassert(decode_state.cursor_bit_position == 0,
+                  "No bit position can be specified for dynamic endmarker fields!")
+
+        orig_origin = decode_state.origin_byte_position
+        orig_cursor = decode_state.cursor_byte_position
+        decode_state.origin_byte_position = decode_state.cursor_byte_position
+
+        result: List[ParameterValue] = []
+        while True:
+            # check if we're at the end of the PDU
+            if decode_state.cursor_byte_position == len(decode_state.coded_message):
+                break
+
+            # check if the cursor currently points to a termination
+            # value
+            tmp_cursor = decode_state.cursor_byte_position
+            try:
+                tv_candidate = self.dyn_end_dop.decode_from_pdu(decode_state)
+                if tv_candidate == self.termination_value:
+                    break
+            except DecodeError:
+                pass
+            decode_state.cursor_byte_position = tmp_cursor
+
+            result.append(self.structure.decode_from_pdu(decode_state))
+
+        decode_state.origin_byte_position = orig_origin
+        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
+
+        return result

odxtools/dynamiclengthfield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -55,7 +55,7 @@ class DynamicLengthField(Field):
         odxassert(encode_state.cursor_bit_position == 0,
                   "No bit position can be specified for dynamic length fields!")
 
-        if not isinstance(physical_value, list):
+        if not isinstance(physical_value, Sequence):
             odxraise(
                 f"Expected a list of values for dynamic length field {self.short_name}, "
                 f"got {type(physical_value)}", EncodeError)
@@ -77,8 +77,14 @@ class DynamicLengthField(Field):
         encode_state.cursor_byte_position = encode_state.origin_byte_position + self.offset
         encode_state.cursor_bit_position = 0
 
-        for value in physical_value:
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+        for i, value in enumerate(physical_value):
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
             self.structure.encode_into_pdu(value, encode_state)
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
 
         # ensure the correct message size if the field is empty
         if len(physical_value) == 0:

odxtools/dynenddopref.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, overload
+from xml.etree import ElementTree
+
+from .exceptions import odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkRef
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class DynEndDopRef(OdxLinkRef):
+    termination_value_raw: str
+
+    @staticmethod
+    @overload
+    def from_et(et_element: None, source_doc_frags: List[OdxDocFragment]) -> None:
+        ...
+
+    @staticmethod
+    @overload
+    def from_et(et_element: ElementTree.Element,
+                source_doc_frags: List[OdxDocFragment]) -> "DynEndDopRef":
+        ...
+
+    @staticmethod
+    def from_et(et_element: Optional[ElementTree.Element],
+                source_doc_frags: List[OdxDocFragment]) -> Optional["DynEndDopRef"]:
+
+        if et_element is None:
+            odxraise("Mandatory DYN-END-DOP-REF tag is missing")
+            return None
+
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, source_doc_frags))
+
+        termination_value_raw = odxrequire(et_element.findtext("TERMINATION-VALUE"))
+
+        return DynEndDopRef(termination_value_raw=termination_value_raw, **kwargs)

odxtools/encodestate.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass, field
-from typing import Dict, Optional
+from typing import Dict, Optional, SupportsBytes
 
 from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
 from .odxtypes import AtomicOdxType, DataType
@@ -83,13 +83,13 @@ class EncodeState:
 
         # Check that bytes and strings actually fit into the bit length
         if base_data_type == DataType.A_BYTEFIELD:
-            if not isinstance(internal_value, bytes):
+            if not isinstance(internal_value, (bytes, bytearray, SupportsBytes)):
                 odxraise()
             if 8 * len(internal_value) > bit_length:
                 raise EncodeError(f"The bytefield {internal_value.hex()} is too large "
                                   f"({len(internal_value)} bytes)."
                                   f" The maximum length is {bit_length//8}.")
-            raw_value = internal_value
+            raw_value = bytes(internal_value)
         elif base_data_type == DataType.A_ASCIISTRING:
             if not isinstance(internal_value, str):
                 odxraise()

odxtools/endofpdufield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List, Optional, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -46,21 +46,35 @@ class EndOfPduField(Field):
                         encode_state: EncodeState) -> None:
         odxassert(not encode_state.cursor_bit_position,
                   "No bit position can be specified for end-of-pdu fields!")
+        odxassert(encode_state.is_end_of_pdu,
+                  "End-of-pdu fields can only be located at the end of PDUs!")
 
-        if not isinstance(physical_value, list):
+        if not isinstance(physical_value, Sequence):
             odxraise(
                 f"Invalid type {type(physical_value).__name__} of physical "
                 f"value for end-of-pdu field, expected a list", EncodeError)
             return
 
-        for value in physical_value:
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+
+        for i, value in enumerate(physical_value):
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
             self.structure.encode_into_pdu(value, encode_state)
 
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         odxassert(not decode_state.cursor_bit_position,
                   "No bit position can be specified for end-of-pdu fields!")
 
+        orig_origin = decode_state.origin_byte_position
+        orig_cursor = decode_state.cursor_byte_position
+        decode_state.origin_byte_position = decode_state.cursor_byte_position
+
         result: List[ParameterValue] = []
         while decode_state.cursor_byte_position < len(decode_state.coded_message):
             # ATTENTION: the ODX specification is very misleading
@@ -69,4 +83,7 @@ class EndOfPduField(Field):
             # repeated are identical, not their values
             result.append(self.structure.decode_from_pdu(decode_state))
 
+        decode_state.origin_byte_position = orig_origin
+        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
+
         return result

odxtools/environmentdata.py

@@ -11,7 +11,14 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class EnvironmentData(BasicStructure):
-    """This class represents Environment Data that describes the circumstances in which the error occurred."""
+    """This class represents Environment Data that describes the
+    circumstances in which the error occurred.
+
+    This is one of the many multiplexer mechanisms specified by the
+    ODX standard, because an environment data parameter must only be
+    used if a DTC parameter has a certain set of values. (In this
+    sense, it is quite similar to NRC-CONST parameters.)
+    """
 
     all_value: Optional[bool]
     dtc_values: List[int]

odxtools/environmentdatadescription.py

@@ -20,8 +20,14 @@ if TYPE_CHECKING:
 
 @dataclass
 class EnvironmentDataDescription(ComplexDop):
-    """This class represents Environment Data Description, which is a complex DOP
-    that is used to define the interpretation of environment data."""
+    """This class represents environment data descriptions
+
+    An environment data description provides a list of all environment
+    data objects that are potentially applicable to decode a given
+    response. (If a given environment data object is applicable
+    depends on the value of the DtcDOP that is associated with it.)
+
+    """
 
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not

odxtools/field.py

@@ -6,7 +6,7 @@ from .basicstructure import BasicStructure
 from .complexdop import ComplexDop
 from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxassert, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
 from .utils import dataclass_fields_asdict
 
@@ -84,8 +84,9 @@ class Field(ComplexDop):
         """Recursively resolve any short-name references"""
         if self.structure_snref is not None:
             structures = diag_layer.diag_data_dictionary_spec.structures
-            self._structure = odxrequire(structures.get(self.structure_snref))
+            self._structure = resolve_snref(self.structure_snref, structures, BasicStructure)
 
         if self.env_data_desc_snref is not None:
             env_data_descs = diag_layer.diag_data_dictionary_spec.env_data_descs
-            self._env_data_desc = odxrequire(env_data_descs.get(self.env_data_desc_snref))
+            self._env_data_desc = resolve_snref(self.env_data_desc_snref, env_data_descs,
+                                                EnvironmentDataDescription)

odxtools/matchingparameter.py

@@ -32,8 +32,8 @@ class MatchingParameter:
                 doc_frags: List[OdxDocFragment]) -> "MatchingParameter":
 
         expected_value = odxrequire(et_element.findtext("EXPECTED-VALUE"))
-        diag_com_snref_el = odxrequire(et_element.find("DIAG-COMM-SNREF"))
-        diag_comm_snref = odxrequire(diag_com_snref_el.get("SHORT-NAME"))
+        diag_comm_snref_el = odxrequire(et_element.find("DIAG-COMM-SNREF"))
+        diag_comm_snref = odxrequire(diag_comm_snref_el.get("SHORT-NAME"))
         out_param_snref_el = et_element.find("OUT-PARAM-IF-SNREF")
         out_param_snpathref_el = et_element.find("OUT-PARAM-IF-SNPATHREF")
         out_param_if = None

odxtools/multiplexercase.py

@@ -7,7 +7,7 @@ from .basicstructure import BasicStructure
 from .compumethods.limit import Limit
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType, DataType
 from .utils import dataclass_fields_asdict
 
@@ -73,7 +73,7 @@ class MultiplexerCase(NamedElement):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         if self.structure_snref:
             ddds = diag_layer.diag_data_dictionary_spec
-            self._structure = odxrequire(ddds.structures.get(self.structure_snref))
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
 
     def applies(self, value: AtomicOdxType) -> bool:
         return self.lower_limit.complies_to_lower(value) \

odxtools/multiplexerdefaultcase.py

@@ -6,7 +6,7 @@ from xml.etree import ElementTree
 from .basicstructure import BasicStructure
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -20,7 +20,7 @@ class MultiplexerDefaultCase(NamedElement):
     structure_snref: Optional[str]
 
     def __post_init__(self) -> None:
-        self._structure: Optional[BasicStructure] = None
+        self._structure: BasicStructure
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -46,4 +46,8 @@ class MultiplexerDefaultCase(NamedElement):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         if self.structure_snref:
             ddds = diag_layer.diag_data_dictionary_spec
-            self._structure = odxrequire(ddds.structures.get(self.structure_snref))
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
+
+    @property
+    def structure(self) -> BasicStructure:
+        return self._structure