odxtools 9.4.1__py3-none-any.whl → 9.6.0__py3-none-any.whl

odxtools/dynamicendmarkerfield.py

@@ -23,6 +23,14 @@ class DynamicEndmarkerField(Field):
 
     dyn_end_dop_ref: DynEndDopRef
 
+    @property
+    def dyn_end_dop(self) -> DataObjectProperty:
+        return self._dyn_end_dop
+
+    @property
+    def termination_value(self) -> AtomicOdxType:
+        return self._termination_value
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DynamicEndmarkerField":
@@ -52,14 +60,6 @@ class DynamicEndmarkerField(Field):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
-    @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:
 

odxtools/dynamiclengthfield.py

@@ -26,11 +26,13 @@ class DynamicLengthField(Field):
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DynamicLengthField":
         kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+
         offset = int(odxrequire(et_element.findtext('OFFSET')))
         determine_number_of_items = DetermineNumberOfItems.from_et(
             odxrequire(et_element.find('DETERMINE-NUMBER-OF-ITEMS')),
             doc_frags,
         )
+
         return DynamicLengthField(
             offset=offset, determine_number_of_items=determine_number_of_items, **kwargs)
 

odxtools/dyndefinedspec.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
 from .diagcomm import DiagClassType, DiagComm
-from .exceptions import odxraise, odxrequire
+from .exceptions import odxassert, odxraise, odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
@@ -50,17 +50,20 @@ class DynIdDefModeInfo:
 
         clear_dyn_def_message_ref = OdxLinkRef.from_et(
             et_element.find("CLEAR-DYN-DEF-MESSAGE-REF"), doc_frags)
+        clear_dyn_def_message_snref = None
         if (snref_elem := et_element.find("CLEAR-DYN-DEF-MESSAGE-SNREF")) is not None:
-            clear_dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+            clear_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
         read_dyn_def_message_ref = OdxLinkRef.from_et(
             et_element.find("READ-DYN-DEF-MESSAGE-REF"), doc_frags)
+        read_dyn_def_message_snref = None
         if (snref_elem := et_element.find("READ-DYN-DEF-MESSAGE-SNREF")) is not None:
-            read_dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+            read_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
         dyn_def_message_ref = OdxLinkRef.from_et(et_element.find("DYN-DEF-MESSAGE-REF"), doc_frags)
+        dyn_def_message_snref = None
         if (snref_elem := et_element.find("DYN-DEF-MESSAGE-SNREF")) is not None:
-            dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+            dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
         supported_dyn_ids = [
             bytes.fromhex(odxrequire(x.text))
@@ -89,14 +92,23 @@ class DynIdDefModeInfo:
             selection_table_refs=selection_table_refs,
         )
 
+    def __post_init__(self) -> None:
+        odxassert(
+            self.clear_dyn_def_message_ref is not None or
+            self.clear_dyn_def_message_snref is not None,
+            "A CLEAR-DYN-DEF-MESSAGE must be specified")
+        odxassert(
+            self.read_dyn_def_message_ref is not None or
+            self.read_dyn_def_message_snref is not None, "A READ-DYN-DEF-MESSAGE must be specified")
+        odxassert(self.dyn_def_message_ref is not None or self.dyn_def_message_snref is not None,
+                  "A DYN-DEF-MESSAGE must be specified")
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result: Dict[OdxLinkId, Any] = {}
 
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._selection_tables = NamedItemList[Table]()
-
         if self.clear_dyn_def_message_ref is not None:
             self._clear_dyn_def_message = odxlinks.resolve(self.clear_dyn_def_message_ref, DiagComm)
 
@@ -106,7 +118,8 @@ class DynIdDefModeInfo:
         if self.dyn_def_message_ref is not None:
             self._dyn_def_message = odxlinks.resolve(self.dyn_def_message_ref, DiagComm)
 
-        # resolve the selection tables referenced using ODXLINK
+        # resolve the selection tables that are referenced via ODXLINK
+        self._selection_tables = NamedItemList[Table]()
         for x in self.selection_table_refs:
             if isinstance(x, OdxLinkRef):
                 self._selection_tables.append(odxlinks.resolve(x, Table))
@@ -141,9 +154,9 @@ class DynIdDefModeInfo:
                      f"DYN-DEF-MESSAGE)")
 
         # resolve the remaining selection tables that are referenced via SNREF
+        ddd_spec = odxrequire(diag_layer.diag_data_dictionary_spec)
         for i, x in enumerate(self.selection_table_refs):
             if isinstance(x, str):
-                ddd_spec = odxrequire(diag_layer.diag_data_dictionary_spec)
                 self._selection_tables.insert(i, resolve_snref(x, ddd_spec.tables, Table))
 
 

odxtools/ecuvariantpattern.py

@@ -1,27 +1,38 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import List, Union
 from xml.etree import ElementTree
 
-from .exceptions import odxassert, odxrequire
+from typing_extensions import override
+
+from .exceptions import odxassert
+from .matchingbasevariantparameter import MatchingBaseVariantParameter
 from .matchingparameter import MatchingParameter
 from .odxlink import OdxDocFragment
+from .variantpattern import VariantPattern
 
 
 @dataclass
-class EcuVariantPattern:
+class EcuVariantPattern(VariantPattern):
+    """ECU variant patterns are variant patterns used to identify the
+    concrete variant of an ECU.
+    """
     matching_parameters: List[MatchingParameter]
 
+    @override
+    def get_matching_parameters(
+            self) -> Union[List[MatchingParameter], List[MatchingBaseVariantParameter]]:
+        return self.matching_parameters
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "EcuVariantPattern":
 
-        mp_collection_el = odxrequire(et_element.find("MATCHING-PARAMETERS"))
-
-        matching_params = [
+        matching_parameters = [
             MatchingParameter.from_et(mp_el, doc_frags)
-            for mp_el in mp_collection_el.iterfind("MATCHING-PARAMETER")
+            for mp_el in et_element.iterfind("MATCHING-PARAMETERS/"
+                                             "MATCHING-PARAMETER")
         ]
 
-        odxassert(len(matching_params) > 0)  # required by ISO 22901-1 Figure 141
-        return EcuVariantPattern(matching_params)
+        odxassert(len(matching_parameters) > 0)  # required by ISO 22901-1 Figure 141
+        return EcuVariantPattern(matching_parameters=matching_parameters)

odxtools/encodestate.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, List, Optional, SupportsBytes, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from .encoding import Encoding, get_string_encoding
 from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
-from .odxtypes import AtomicOdxType, DataType, ParameterValue
+from .odxtypes import AtomicOdxType, BytesTypes, DataType, ParameterValue
 
 try:
     import bitstruct.c as bitstruct
@@ -97,7 +97,7 @@ class EncodeState:
 
         # Deal with raw byte fields, ...
         if base_data_type == DataType.A_BYTEFIELD:
-            if not isinstance(internal_value, (bytes, bytearray, SupportsBytes)):
+            if not isinstance(internal_value, BytesTypes):
                 odxraise(f"{internal_value!r} is not a bytefield", EncodeError)
                 return
 

odxtools/endofpdufield.py

@@ -17,30 +17,28 @@ from .utils import dataclass_fields_asdict
 @dataclass
 class EndOfPduField(Field):
     """End of PDU fields are structures that are repeated until the end of the PDU"""
-    min_number_of_items: Optional[int]
     max_number_of_items: Optional[int]
+    min_number_of_items: Optional[int]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "EndOfPduField":
         kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
 
-        if (min_n_str := et_element.findtext("MIN-NUMBER-OF-ITEMS")) is not None:
-            min_number_of_items = int(min_n_str)
-        else:
-            min_number_of_items = None
         if (max_n_str := et_element.findtext("MAX-NUMBER-OF-ITEMS")) is not None:
             max_number_of_items = int(max_n_str)
         else:
             max_number_of_items = None
+        if (min_n_str := et_element.findtext("MIN-NUMBER-OF-ITEMS")) is not None:
+            min_number_of_items = int(min_n_str)
+        else:
+            min_number_of_items = None
 
-        eopf = EndOfPduField(
-            min_number_of_items=min_number_of_items,
+        return EndOfPduField(
             max_number_of_items=max_number_of_items,
+            min_number_of_items=min_number_of_items,
             **kwargs)
 
-        return eopf
-
     @override
     def encode_into_pdu(self, physical_value: Optional[ParameterValue],
                         encode_state: EncodeState) -> None:

odxtools/environmentdatadescription.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -44,18 +44,6 @@ class EnvironmentDataDescription(ComplexDop):
     env_datas: NamedItemList[EnvironmentData]
     env_data_refs: List[OdxLinkRef]
 
-    @property
-    def param(self) -> Parameter:
-        # the parameter referenced via SNREF cannot be resolved here
-        # because the relevant list of parameters depends on the
-        # concrete codec object processed, whilst an environment data
-        # description object can be featured in an arbitrary number of
-        # responses. Instead, lookup of the appropriate parameter is
-        # done within the encode and decode methods.
-        odxraise("The parameter of ENV-DATA-DESC objects cannot be resolved "
-                 "because it depends on the context")
-        return cast(None, Parameter)
-
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "EnvironmentDataDescription":
@@ -74,20 +62,20 @@ class EnvironmentDataDescription(ComplexDop):
         # situation is reversed. This means that we will create one
         # empty and one non-empty list here. (Which is which depends
         # on the version of the standard used by the file.)
-        env_data_refs = [
-            odxrequire(OdxLinkRef.from_et(env_data_ref, doc_frags))
-            for env_data_ref in et_element.iterfind("ENV-DATA-REFS/ENV-DATA-REF")
-        ]
         env_datas = NamedItemList([
             EnvironmentData.from_et(env_data_elem, doc_frags)
             for env_data_elem in et_element.iterfind("ENV-DATAS/ENV-DATA")
         ])
+        env_data_refs = [
+            odxrequire(OdxLinkRef.from_et(env_data_ref, doc_frags))
+            for env_data_ref in et_element.iterfind("ENV-DATA-REFS/ENV-DATA-REF")
+        ]
 
         return EnvironmentDataDescription(
             param_snref=param_snref,
             param_snpathref=param_snpathref,
-            env_data_refs=env_data_refs,
             env_datas=env_datas,
+            env_data_refs=env_data_refs,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -103,7 +91,8 @@ class EnvironmentDataDescription(ComplexDop):
         # ODX 2.0 specifies environment data objects here, ODX 2.2
         # uses references
         if self.env_data_refs:
-            self.env_datas = NamedItemList([odxlinks.resolve(x) for x in self.env_data_refs])
+            self.env_datas = NamedItemList(
+                [odxlinks.resolve(x, EnvironmentData) for x in self.env_data_refs])
         else:
             for ed in self.env_datas:
                 ed._resolve_odxlinks(odxlinks)
@@ -221,7 +210,7 @@ class EnvironmentDataDescription(ComplexDop):
             if not isinstance(dop, (DataObjectProperty, DtcDop)):
                 odxraise(f"The DOP of the parameter referenced by environment data descriptions "
                          f"must use either be DataObjectProperty or a DtcDop (encountered "
-                         f"{type(param).__name__} for parameter '{self.param.short_name}' "
+                         f"{type(param).__name__} for parameter '{param.short_name}' "
                          f"of ENV-DATA-DESC '{self.short_name}')")
                 return 0
 

odxtools/field.py

@@ -21,19 +21,14 @@ class Field(ComplexDop):
     env_data_desc_snref: Optional[str]
     is_visible_raw: Optional[bool]
 
-    def __post_init__(self) -> None:
-        self._structure: Optional[BasicStructure] = None
-        self._env_data_desc: Optional[EnvironmentDataDescription] = None
-        num_struct_refs = 0 if self.structure_ref is None else 1
-        num_struct_refs += 0 if self.structure_snref is None else 1
-
-        num_edd_refs = 0 if self.env_data_desc_ref is None else 1
-        num_edd_refs += 0 if self.env_data_desc_snref is None else 1
+    @property
+    def structure(self) -> BasicStructure:
+        """may be a Structure or a env-data-desc"""
+        return odxrequire(self._structure, "EnvironmentDataDescription is not supported")
 
-        odxassert(
-            num_struct_refs + num_edd_refs == 1,
-            "FIELDs need to specify exactly one reference to a "
-            "structure or an environment data description")
+    @property
+    def is_visible(self) -> bool:
+        return self.is_visible_raw in (None, True)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Field":
@@ -58,17 +53,19 @@ class Field(ComplexDop):
             is_visible_raw=is_visible_raw,
             **kwargs)
 
-    @property
-    def is_visible(self) -> bool:
-        return self.is_visible_raw in (None, True)
+    def __post_init__(self) -> None:
+        self._structure: Optional[BasicStructure] = None
+        self._env_data_desc: Optional[EnvironmentDataDescription] = None
+        num_struct_refs = 0 if self.structure_ref is None else 1
+        num_struct_refs += 0 if self.structure_snref is None else 1
 
-    @property
-    def structure(self) -> BasicStructure:
-        """may be a Structure or a env-data-desc"""
-        return odxrequire(self._structure, "EnvironmentDataDescription is not supported")
+        num_edd_refs = 0 if self.env_data_desc_ref is None else 1
+        num_edd_refs += 0 if self.env_data_desc_snref is None else 1
 
-    def get_static_bit_length(self) -> Optional[int]:
-        return None
+        odxassert(
+            num_struct_refs + num_edd_refs == 1,
+            "FIELDs need to specify exactly one reference to a "
+            "structure or an environment data description")
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         """Recursively resolve any odxlinks references"""
@@ -89,3 +86,6 @@ class Field(ComplexDop):
         if self.env_data_desc_snref is not None:
             self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddds.env_data_descs,
                                                 EnvironmentDataDescription)
+
+    def get_static_bit_length(self) -> Optional[int]:
+        return None

odxtools/inputparam.py

@@ -15,25 +15,35 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class InputParam(NamedElement):
+    physical_default_value: Optional[str]
     dop_base_ref: OdxLinkRef
     oid: Optional[str]
     semantic: Optional[str]
-    physical_default_value: Optional[str]
+
+    @property
+    def dop(self) -> DopBase:
+        """The data object property describing this parameter."""
+        return self._dop
+
+    @deprecated(details="use .dop")  # type: ignore[misc]
+    def dop_base(self) -> DopBase:
+        return self._dop
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "InputParam":
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
-        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
+
         physical_default_value = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
+        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
 
-        semantic = et_element.get("SEMANTIC")
         oid = et_element.get("OID")
+        semantic = et_element.get("SEMANTIC")
 
         return InputParam(
-            dop_base_ref=dop_base_ref,
             physical_default_value=physical_default_value,
-            semantic=semantic,
+            dop_base_ref=dop_base_ref,
             oid=oid,
+            semantic=semantic,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -44,12 +54,3 @@ class InputParam(NamedElement):
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def dop(self) -> DopBase:
-        """The data object property describing this parameter."""
-        return self._dop
-
-    @deprecated(details="use .dop")  # type: ignore[misc]
-    def dop_base(self) -> DopBase:
-        return self._dop

odxtools/leadinglengthinfotype.py

@@ -23,6 +23,10 @@ class LeadingLengthInfoType(DiagCodedType):
     #: object.
     bit_length: int
 
+    @property
+    def dct_type(self) -> DctType:
+        return "LEADING-LENGTH-INFO-TYPE"
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -46,10 +50,6 @@ class LeadingLengthInfoType(DiagCodedType):
             f"A leading length info type cannot have the base data type {self.base_data_type.name}."
         )
 
-    @property
-    def dct_type(self) -> DctType:
-        return "LEADING-LENGTH-INFO-TYPE"
-
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 

odxtools/matchingbasevariantparameter.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .matchingparameter import MatchingParameter
+from .odxlink import OdxDocFragment
+from .odxtypes import odxstr_to_bool
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class MatchingBaseVariantParameter(MatchingParameter):
+    """A description of a parameter used for base variant matching.
+
+    This is very similar to `MatchingParameter` for ECU variant
+    matching, but `MatchingBaseVariantParameter` features the
+    additional subtag `USE-PHYSICAL-ADDRESSING`.
+    """
+
+    use_physical_addressing_raw: Optional[bool]
+
+    @property
+    def use_physical_addressing(self) -> bool:
+        return self.use_physical_addressing_raw in [None, True]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "MatchingBaseVariantParameter":
+
+        kwargs = dataclass_fields_asdict(MatchingParameter.from_et(et_element, doc_frags))
+
+        use_physical_addressing_raw = odxstr_to_bool(et_element.findtext("USE-PHYSICAL-ADDRESSING"))
+
+        return MatchingBaseVariantParameter(
+            use_physical_addressing_raw=use_physical_addressing_raw,
+            **kwargs,
+        )

odxtools/matchingparameter.py

@@ -1,58 +1,138 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
-from .exceptions import odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment
-from .utils import is_short_name, is_short_name_path
+from .diaglayers.diaglayer import DiagLayer
+from .diagnostictroublecode import DiagnosticTroubleCode
+from .diagservice import DiagService
+from .exceptions import odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxtypes import BytesTypes, ParameterValue, ParameterValueDict
+from .snrefcontext import SnRefContext
 
 
 @dataclass
 class MatchingParameter:
-    """According to ISO 22901, a MatchingParameter contains a string value identifying
-    the active ECU variant. Moreover, it references a DIAG-COMM via snref and one of its
-    positive response's OUT-PARAM-IF via snref or snpathref.
+    """According to ISO 22901, a MatchingParameter contains a string
+    value identifying the active ECU or base variant. Moreover, it
+    references a DIAG-COMM via snref and one of its positive
+    response's OUT-PARAM-IF via snref or snpathref.
+
+    Unlike other parameters defined in the `parameters` package, a
+    MatchingParameter is not transferred over the network.
 
-    Unlike other parameters defined in the `parameters` package, a MatchingParameter is
-    not transferred over the network.
     """
 
-    # datatype according to ISO 22901-1 Figure 141
     expected_value: str
     diag_comm_snref: str
-    out_param_if: str
 
-    def __post_init__(self) -> None:
-        odxassert(is_short_name(self.diag_comm_snref))
-        odxassert(is_short_name_path(self.out_param_if))
+    # be aware that the checker rules 23 and 110 contradict each other
+    # here: the first specifies that the referenced parameter must be
+    # present in *all* positive responses of the referenced service,
+    # whilst the latter mandates it to be present least one positive
+    # or negative response. What it probably actually wants to say is
+    # that any response that can possibly be received shall exhibit
+    # the referenced parameter.
+    out_param_if_snref: Optional[str]
+    out_param_if_snpathref: Optional[str]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MatchingParameter":
 
         expected_value = odxrequire(et_element.findtext("EXPECTED-VALUE"))
-        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
-        if out_param_snref_el is not None:
-            out_param_if = out_param_snref_el.get("SHORT-NAME")
-        elif out_param_snpathref_el is not None:
-            out_param_if = out_param_snpathref_el.get("SHORT-NAME-PATH")
-        if out_param_if is None:
-            odxraise("Output parameter must not left unspecified")
+        diag_comm_snref = odxrequire(
+            odxrequire(et_element.find("DIAG-COMM-SNREF")).get("SHORT-NAME"))
+
+        out_param_if_snref = None
+        out_param_if_snpathref = None
+        if (out_param_snref_el := et_element.find("OUT-PARAM-IF-SNREF")) is not None:
+            out_param_if_snref = odxrequire(out_param_snref_el.get("SHORT-NAME"))
+        elif (out_param_snpathref_el := et_element.find("OUT-PARAM-IF-SNPATHREF")) is not None:
+            out_param_if_snpathref = odxrequire(out_param_snpathref_el.get("SHORT-NAME-PATH"))
+        else:
+            odxraise("Output parameter must not be left unspecified")
 
         return MatchingParameter(
             expected_value=expected_value,
             diag_comm_snref=diag_comm_snref,
-            out_param_if=out_param_if,
+            out_param_if_snref=out_param_if_snref,
+            out_param_if_snpathref=out_param_if_snpathref,
         )
 
-    def is_match(self, ident_value: str) -> bool:
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # note that we do not resolve the SNREF to the diag layer here
+        # because it is a component which changes depending on the
+        # execution context and for variant patterns the execution
+        # context is highly volatile w.r.t. the diag layer in question
+        pass
+
+    def get_ident_service(self, diag_layer: DiagLayer) -> DiagService:
+        return resolve_snref(self.diag_comm_snref, diag_layer.services, DiagService)
+
+    def matches(self, param_dict: ParameterValueDict) -> bool:
         """
         Returns true iff the provided identification value matches this MatchingParameter's
         expected value.
         """
-        return self.expected_value == ident_value
+
+        if self.out_param_if_snref is not None:
+            snpath_chunks = [self.out_param_if_snref]
+        elif self.out_param_if_snpathref is not None:
+            snpath_chunks = self.out_param_if_snpathref.split(".")
+        else:
+            odxraise("no out_param_if specified")
+            return False
+
+        return self.__matches(param_dict, snpath_chunks)
+
+    def __matches(self, param_dict: ParameterValue, snpath_chunks: List[str]) -> bool:
+        if len(snpath_chunks) == 0:
+            parameter_value = param_dict
+            if isinstance(parameter_value, dict):
+                odxraise(f"Parameter must not be a structure")
+                return False
+
+            if isinstance(parameter_value, float):
+                # allow a slight tolerance if the expected value is
+                # floating point
+                return abs(float(self.expected_value) - parameter_value) < 1e-8
+            elif isinstance(parameter_value, BytesTypes):
+                return parameter_value.hex().upper() == self.expected_value.upper()
+            elif isinstance(parameter_value, DiagnosticTroubleCode):
+                # TODO: what happens if non-numerical DTCs like
+                # "U123456" are specified? Is specifying DTCs even
+                # allowed in variant patterns?
+                return hex(parameter_value.trouble_code).upper() == self.expected_value.upper()
+            else:
+                return self.expected_value == str(parameter_value)
+
+        if not isinstance(param_dict, dict):
+            odxraise(f"Parameter {snpath_chunks[0]} must be a structure")
+            return False
+
+        sub_value = param_dict.get(snpath_chunks[0])
+        if sub_value is None:
+            return False
+
+        if isinstance(sub_value, tuple) and len(sub_value) == 2:
+            # table struct parameter
+            sub_value = sub_value[1]
+
+        if isinstance(sub_value, list):
+            # the spec mandates that if any item of a field matches,
+            # the parameter as a whole matches
+            for x in sub_value:
+                if self.__matches(x, snpath_chunks[1:]):
+                    return True
+
+            return False
+
+        return self.__matches(cast(ParameterValue, sub_value), snpath_chunks[1:])