odxtools 6.6.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/library.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, cast
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement
+from .exceptions import odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class Library(IdentifiableElement):
+    """
+    A library defines a shared library used for single ECU jobs etc.
+
+    It this is basically equivalent to ProgCode.
+    """
+
+    code_file: str
+    encryption: Optional[str]
+    syntax: str
+    revision: str
+    entrypoint: Optional[str]
+
+    @property
+    def code(self) -> bytes:
+        return self._code
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Library":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        code_file = odxrequire(et_element.findtext("CODE-FILE"))
+        encryption = et_element.findtext("ENCRYPTION")
+        syntax = odxrequire(et_element.findtext("SYNTAX"))
+        revision = odxrequire(et_element.findtext("REVISION"))
+        entrypoint = et_element.findtext("ENTRYPOINT")
+
+        return Library(
+            code_file=code_file,
+            encryption=encryption,
+            syntax=syntax,
+            revision=revision,
+            entrypoint=entrypoint,
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {self.odx_id: self}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        aux_file = odxrequire(context.database).auxiliary_files.get(self.code_file)
+
+        if aux_file is None:
+            odxraise(f"Reference to auxiliary file '{self.code_file}' "
+                     f"could not be resolved")
+            self._code: bytes = cast(bytes, None)
+            return
+
+        self._code = aux_file.read()
+        aux_file.seek(0)

odxtools/loadfile.py

@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: MIT
+import os
+from pathlib import Path
+from typing import Union
+
+from .database import Database
+
+
+def load_pdx_file(pdx_file: Union[str, Path]) -> Database:
+    db = Database()
+    db.add_pdx_file(str(pdx_file))
+    db.refresh()
+    return db
+
+
+def load_odx_d_file(odx_d_file_name: Union[str, Path]) -> Database:
+    db = Database()
+    db.add_odx_file(str(odx_d_file_name))
+    db.refresh()
+
+    return db
+
+
+def load_file(file_name: Union[str, Path]) -> Database:
+    if str(file_name).lower().endswith(".pdx"):
+        return load_pdx_file(str(file_name))
+    elif str(file_name).lower().endswith(".odx-d"):
+        return load_odx_d_file(str(file_name))
+    else:
+        raise RuntimeError(f"Could not guess the file format of file '{file_name}'!")
+
+
+def load_files(*file_names: Union[str, Path]) -> Database:
+    db = Database()
+    for file_name in file_names:
+        p = Path(file_name)
+        if p.suffix.lower() == ".pdx":
+            db.add_pdx_file(str(file_name))
+        elif p.suffix.lower().startswith(".odx"):
+            db.add_odx_file(str(file_name))
+        elif p.name.lower() != "index.xml":
+            db.add_auxiliary_file(str(file_name))
+
+    db.refresh()
+    return db
+
+
+def load_directory(dir_name: Union[str, Path]) -> Database:
+    db = Database()
+    for file_name in os.listdir(str(dir_name)):
+        p = Path(dir_name) / file_name
+
+        if not p.is_file():
+            continue
+
+        if p.suffix.lower() == ".pdx":
+            db.add_pdx_file(str(p))
+        elif p.suffix.lower().startswith(".odx"):
+            db.add_odx_file(str(p))
+        elif p.name.lower() != "index.xml":
+            db.add_auxiliary_file(p.name, open(str(p), "rb"))
+
+    db.refresh()
+    return db

odxtools/matchingparameter.py

@@ -12,7 +12,7 @@ from .utils import is_short_name, is_short_name_path
 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
-    positiv response's OUT-PARAM-IF via snref or snpathref.
+    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.
@@ -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/message.py

@@ -2,8 +2,6 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Union
 
-from deprecation import deprecated
-
 from .odxtypes import ParameterValue, ParameterValueDict
 
 if TYPE_CHECKING:
@@ -29,8 +27,3 @@ class Message:
 
     def __getitem__(self, key: str) -> ParameterValue:
         return self.param_dict[key]
-
-    @property
-    @deprecated("use .coding_object")
-    def structure(self) -> Union["Request", "Response"]:
-        return self.coding_object

odxtools/minmaxlengthtype.py

@@ -1,12 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxassert, odxraise
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -15,6 +20,25 @@ class MinMaxLengthType(DiagCodedType):
     max_length: Optional[int]
     termination: str
 
+    @property
+    def dct_type(self) -> DctType:
+        return "MIN-MAX-LENGTH-TYPE"
+
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "MinMaxLengthType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+
+        min_length = int(odxrequire(et_element.findtext("MIN-LENGTH")))
+        max_length = None
+        if et_element.find("MAX-LENGTH") is not None:
+            max_length = int(odxrequire(et_element.findtext("MAX-LENGTH")))
+        termination = odxrequire(et_element.get("TERMINATION"))
+
+        return MinMaxLengthType(
+            min_length=min_length, max_length=max_length, termination=termination, **kwargs)
+
     def __post_init__(self) -> None:
         odxassert(self.max_length is None or self.min_length <= self.max_length)
         odxassert(
@@ -30,10 +54,6 @@ class MinMaxLengthType(DiagCodedType):
             "END-OF-PDU",
         ], f"A min-max length type cannot have the termination {self.termination}")
 
-    @property
-    def dct_type(self) -> DctType:
-        return "MIN-MAX-LENGTH-TYPE"
-
     def __termination_sequence(self) -> bytes:
         """Returns the termination byte sequence if it isn't defined."""
         # The termination sequence is actually not specified by ASAM
@@ -51,9 +71,10 @@ class MinMaxLengthType(DiagCodedType):
                 termination_sequence = bytes([0xFF, 0xFF])
         return termination_sequence
 
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
-        if not isinstance(internal_value, (bytes, str)):
+    @override
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
+
+        if not isinstance(internal_value, (bytes, str, bytearray)):
             odxraise("MinMaxLengthType is currently only implemented for strings and byte arrays",
                      EncodeError)
 
@@ -62,20 +83,24 @@ class MinMaxLengthType(DiagCodedType):
         else:
             data_length = len(internal_value)
 
-        value_bytes = bytearray(
-            self._encode_internal_value(
-                internal_value,
-                bit_position=0,
-                bit_length=8 * data_length,
-                base_data_type=self.base_data_type,
-                is_highlow_byte_order=self.is_highlow_byte_order,
-            ))
+        orig_cursor = encode_state.cursor_byte_position
+        encode_state.emplace_atomic_value(
+            internal_value=internal_value,
+            used_mask=None,
+            bit_length=8 * data_length,
+            base_data_type=self.base_data_type,
+            is_highlow_byte_order=self.is_highlow_byte_order,
+        )
+        value_len = encode_state.cursor_byte_position - orig_cursor
 
         # TODO: ensure that the termination delimiter is not
         # encountered within the encoded value.
 
-        odxassert(self.termination != "END-OF-PDU" or encode_state.is_end_of_pdu)
-        if encode_state.is_end_of_pdu or len(value_bytes) == self.max_length:
+        odxassert(
+            self.termination != "END-OF-PDU" or encode_state.is_end_of_pdu,
+            "Encountered a MIN-MAX-LENGTH type with END-OF-PDU termination "
+            "which is not located at the end of the PDU")
+        if encode_state.is_end_of_pdu or value_len == self.max_length:
             # All termination types may be ended by the end of the PDU
             # or once reaching the maximum length. In this case, we
             # must not add the termination sequence
@@ -85,20 +110,23 @@ class MinMaxLengthType(DiagCodedType):
 
             # ensure that we don't try to encode an odd-length
             # value when using a two-byte terminator
-            odxassert(len(value_bytes) % len(termination_sequence) == 0)
-
-            value_bytes.extend(termination_sequence)
-
-        if len(value_bytes) < self.min_length:
-            raise EncodeError(f"Encoded value for MinMaxLengthType "
-                              f"must be at least {self.min_length} bytes long. "
-                              f"(Is: {len(value_bytes)} bytes.)")
-        elif self.max_length is not None and len(value_bytes) > self.max_length:
-            raise EncodeError(f"Encoded value for MinMaxLengthType "
-                              f"must not be longer than {self.max_length} bytes. "
-                              f"(Is: {len(value_bytes)} bytes.)")
-
-        return value_bytes
+            odxassert(value_len % len(termination_sequence) == 0)
+
+            value_len += len(termination_sequence)
+            encode_state.emplace_bytes(termination_sequence)
+
+        if value_len < self.min_length:
+            odxraise(
+                f"Encoded value for MinMaxLengthType "
+                f"must be at least {self.min_length} bytes long. "
+                f"(Is: {value_len} bytes.)", EncodeError)
+            return
+        elif self.max_length is not None and value_len > self.max_length:
+            odxraise(
+                f"Encoded value for MinMaxLengthType "
+                f"must not be longer than {self.max_length} bytes. "
+                f"(Is: {value_len} bytes.)", EncodeError)
+            return
 
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         odxassert(decode_state.cursor_bit_position == 0,

odxtools/modification.py

@@ -1,12 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -27,5 +25,5 @@ class Modification:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/multiplexer.py

@@ -1,22 +1,23 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .complexdop import ComplexDop
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .multiplexercase import MultiplexerCase
 from .multiplexerdefaultcase import MultiplexerDefaultCase
 from .multiplexerswitchkey import MultiplexerSwitchKey
+from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, ParameterValue, odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Multiplexer(ComplexDop):
@@ -30,13 +31,15 @@ class Multiplexer(ComplexDop):
     byte_position: int
     switch_key: MultiplexerSwitchKey
     default_case: Optional[MultiplexerDefaultCase]
-    cases: List[MultiplexerCase]
+    cases: NamedItemList[MultiplexerCase]
     is_visible_raw: Optional[bool]
 
     @staticmethod
+    @override
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Multiplexer":
         """Reads a Multiplexer from Diag Layer."""
-        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
+        base_obj = ComplexDop.from_et(et_element, doc_frags)
+        kwargs = dataclass_fields_asdict(base_obj)
 
         byte_position = int(et_element.findtext("BYTE-POSITION", "0"))
         switch_key = MultiplexerSwitchKey.from_et(
@@ -46,9 +49,8 @@ class Multiplexer(ComplexDop):
         if (dc_elem := et_element.find("DEFAULT-CASE")) is not None:
             default_case = MultiplexerDefaultCase.from_et(dc_elem, doc_frags)
 
-        cases = []
-        if (cases_elem := et_element.find("CASES")) is not None:
-            cases = [MultiplexerCase.from_et(el, doc_frags) for el in cases_elem.iterfind("CASE")]
+        cases = NamedItemList(
+            [MultiplexerCase.from_et(el, doc_frags) for el in et_element.iterfind("CASES/CASE")])
 
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 
@@ -66,88 +68,143 @@ class Multiplexer(ComplexDop):
 
     def _get_case_limits(self, case: MultiplexerCase) -> Tuple[AtomicOdxType, AtomicOdxType]:
         key_type = self.switch_key.dop.physical_type.base_data_type
-        lower_limit = key_type.make_from(case.lower_limit)
-        upper_limit = key_type.make_from(case.upper_limit)
+        lower_limit = key_type.make_from(case.lower_limit.value)
+        upper_limit = key_type.make_from(case.upper_limit.value)
         if not isinstance(lower_limit, type(upper_limit)) and not isinstance(
                 upper_limit, type(lower_limit)):
             odxraise("Upper and lower bounds of limits must compareable")
         return lower_limit, upper_limit
 
-    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
-
-        if bit_position != 0:
-            raise EncodeError("Multiplexer must be aligned, i.e. bit_position=0, but "
-                              f"{self.short_name} was passed the bit position {bit_position}")
-
-        if not isinstance(physical_value, dict) or len(physical_value) != 1:
-            raise EncodeError("""Multiplexer should be defined as a dict
-            with only one key equal to the desired case""")
-
-        case_name, case_value = next(iter(physical_value.items()))
-        case_pos = self.byte_position
-
-        for mux_case in self.cases or []:
-            if mux_case.short_name == case_name:
-                if mux_case._structure:
-                    case_bytes = mux_case._structure.convert_physical_to_bytes(
-                        case_value, encode_state, 0)
-                else:
-                    case_bytes = b''
-
+    @override
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+
+        if encode_state.cursor_bit_position != 0:
+            raise EncodeError(f"Multiplexer parameters must be aligned, i.e. bit_position=0, but "
+                              f"{self.short_name} was passed the bit position "
+                              f"{encode_state.cursor_bit_position}")
+
+        orig_origin = encode_state.origin_byte_position
+        encode_state.origin_byte_position = encode_state.cursor_byte_position
+
+        if isinstance(physical_value, (list, tuple)) and len(physical_value) == 2:
+            case_spec, case_value = physical_value
+        elif isinstance(physical_value, dict) and len(physical_value) == 1:
+            case_spec, case_value = next(iter(physical_value.items()))
+        else:
+            raise EncodeError(
+                f"Values of multiplexer parameters must be defined as a "
+                f"(case_name, content_value) tuple instead of as '{physical_value!r}'")
+
+        mux_case: Union[MultiplexerCase, MultiplexerDefaultCase]
+        applicable_cases: List[Union[MultiplexerCase, MultiplexerDefaultCase]]
+
+        if isinstance(case_spec, str):
+            applicable_cases = [x for x in self.cases if x.short_name == case_spec]
+            if not applicable_cases and self.default_case:
+                applicable_cases.append(self.default_case)
+            if len(applicable_cases) == 0:
+                raise EncodeError(
+                    f"Multiplexer {self.short_name} does not know any case called {case_spec}")
+
+            odxassert(len(applicable_cases) == 1)
+            mux_case = applicable_cases[0]
+            if isinstance(mux_case, MultiplexerCase):
                 key_value, _ = self._get_case_limits(mux_case)
-                key_bytes = self.switch_key.dop.convert_physical_to_bytes(
-                    key_value, encode_state, bit_position=self.switch_key.bit_position or 0)
-
-                mux_len = max(len(key_bytes), len(case_bytes) + case_pos)
-                mux_bytes = bytearray(mux_len)
-                mux_bytes[:len(key_bytes)] = key_bytes
-                mux_bytes[case_pos:case_pos + len(case_bytes)] = case_bytes
-
-                return bytes(mux_bytes)
-
-        raise EncodeError(f"The case {case_name} is not found in Multiplexer {self.short_name}")
-
+            else:
+                key_value = 0
+        elif isinstance(case_spec, int):
+            applicable_cases = []
+            for x in self.cases:
+                lower, upper = cast(Tuple[int, int], self._get_case_limits(x))
+                if lower <= case_spec and case_spec <= upper:
+                    applicable_cases.append(x)
+
+            if len(applicable_cases) == 0:
+                if self.default_case is None:
+                    raise EncodeError(
+                        f"Multiplexer {self.short_name} does not know any case called {case_spec}")
+                mux_case = self.default_case
+                key_value = case_spec
+            else:
+                mux_case = applicable_cases[0]
+                key_value = case_spec
+        elif isinstance(case_spec, MultiplexerCase):
+            mux_case = case_spec
+            key_value, _ = self._get_case_limits(mux_case)
+        elif case_spec is None:
+            if self.default_case is None:
+                raise EncodeError(f"Multiplexer {self.short_name} does not define a default case")
+            key_value = 0
+        else:
+            raise EncodeError(f"Illegal case specification '{case_spec}' for "
+                              f"multiplexer {self.short_name}")
+
+        # the byte position of the switch key is relative to
+        # the multiplexer's position
+        encode_state.cursor_byte_position = encode_state.origin_byte_position + self.switch_key.byte_position
+        encode_state.cursor_bit_position = self.switch_key.bit_position or 0
+        self.switch_key.dop.encode_into_pdu(physical_value=key_value, encode_state=encode_state)
+        encode_state.cursor_bit_position = 0
+
+        if mux_case.structure is not None:
+            # the byte position of the content is specified by the
+            # BYTE-POSITION attribute of the multiplexer
+            encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
+            mux_case.structure.encode_into_pdu(physical_value=case_value, encode_state=encode_state)
+
+        encode_state.origin_byte_position = orig_origin
+
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-
-        # multiplexers are structures and thus the origin position
-        # must be moved to the start of the multiplexer
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
-        if self.byte_position is not None:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
+        # Decode the switch key. Its BYTE-POSITION is relative to the
+        # that of the multiplexer.
+        if self.switch_key.byte_position is not None:
+            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.switch_key.byte_position
+        decode_state.cursor_bit_position = self.switch_key.bit_position or 0
         key_value = self.switch_key.dop.decode_from_pdu(decode_state)
+        decode_state.cursor_bit_position = 0
 
         if not isinstance(key_value, int):
             odxraise(f"Multiplexer keys must be integers (is '{type(key_value).__name__}'"
                      f" for multiplexer '{self.short_name}')")
 
-        case_value: Optional[ParameterValue] = None
-        for case in self.cases or []:
-            lower, upper = self._get_case_limits(case)
+        # "If a matching CASE is found, the referenced STRUCTURE is
+        # analyzed at the BYTE-POSITION (child element of MUX)
+        # relatively to the byte position of the MUX."
+        decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
+
+        applicable_case: Optional[Union[MultiplexerCase, MultiplexerDefaultCase]] = None
+        for mux_case in self.cases:
+            lower, upper = self._get_case_limits(mux_case)
             if lower <= key_value and key_value <= upper:  # type: ignore[operator]
-                if case._structure:
-                    case_value = case._structure.decode_from_pdu(decode_state)
+                applicable_case = mux_case
                 break
 
-        if case_value is None and self.default_case is not None:
-            if self.default_case._structure:
-                case_value = self.default_case._structure.decode_from_pdu(decode_state)
+        if applicable_case is None:
+            applicable_case = self.default_case
+
+        if applicable_case is None:
+            odxraise(
+                f"Cannot find an applicable case for value {key_value} in "
+                f"multiplexer {self.short_name}", DecodeError)
+            decode_state.origin_byte_position = orig_origin
+            return (None, None)
 
-        if case_value is None:
-            odxraise(f"Failed to find a matching case in {self.short_name} for value {key_value!r}",
-                     DecodeError)
+        if applicable_case.structure is not None:
+            case_value = applicable_case.structure.decode_from_pdu(decode_state)
+        else:
+            case_value = {}
 
-        mux_value = (case.short_name, case_value)
+        result = (applicable_case.short_name, case_value)
 
-        # go back to the original origin
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
-        return mux_value
+        return result
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
@@ -157,6 +214,7 @@ class Multiplexer(ComplexDop):
 
         return odxlinks
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
@@ -164,15 +222,17 @@ class Multiplexer(ComplexDop):
         if self.default_case is not None:
             self.default_case._resolve_odxlinks(odxlinks)
 
-        for case in self.cases:
-            case._resolve_odxlinks(odxlinks)
+        for mux_case in self.cases:
+            mux_case._mux_case_resolve_odxlinks(
+                odxlinks, key_physical_type=self.switch_key.dop.physical_type.base_data_type)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    @override
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
-        self.switch_key._resolve_snrefs(diag_layer)
+        self.switch_key._resolve_snrefs(context)
         if self.default_case is not None:
-            self.default_case._resolve_snrefs(diag_layer)
+            self.default_case._resolve_snrefs(context)
 
-        for case in self.cases:
-            case._resolve_snrefs(diag_layer)
+        for mux_case in self.cases:
+            mux_case._resolve_snrefs(context)