odxtools 5.3.0__py3-none-any.whl → 5.3.1__py3-none-any.whl

odxtools/determinenumberofitems.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from typing import List
+from xml.etree import ElementTree
+
+from .odxlink import OdxDocFragment
+from .positioneddataobjectproperty import PositionedDataObjectProperty
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class DetermineNumberOfItems(PositionedDataObjectProperty):
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DetermineNumberOfItems":
+        kwargs = dataclass_fields_asdict(
+            PositionedDataObjectProperty.from_et(et_element, doc_frags))
+        return DetermineNumberOfItems(**kwargs)

odxtools/diagdatadictionaryspec.py

@@ -9,6 +9,7 @@ from .createanystructure import create_any_structure_from_et
 from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .dtcdop import DtcDop
+from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
 from .environmentdata import EnvironmentData
 from .environmentdatadescription import EnvironmentDataDescription
@@ -31,6 +32,7 @@ class DiagDataDictionarySpec:
     data_object_props: NamedItemList[DataObjectProperty]
     structures: NamedItemList[BasicStructure]
     end_of_pdu_fields: NamedItemList[EndOfPduField]
+    dynamic_length_fields: NamedItemList[DynamicLengthField]
     tables: NamedItemList[Table]
     env_data_descs: NamedItemList[EnvironmentDataDescription]
     env_datas: NamedItemList[EnvironmentData]
@@ -44,6 +46,7 @@ class DiagDataDictionarySpec:
                 self.data_object_props,
                 self.structures,
                 self.end_of_pdu_fields,
+                self.dynamic_length_fields,
                 self.dtc_dops,
                 self.tables,
             ),)
@@ -67,6 +70,11 @@ class DiagDataDictionarySpec:
             for eofp_element in et_element.iterfind("END-OF-PDU-FIELDS/END-OF-PDU-FIELD")
         ]
 
+        dynamic_length_fields = [
+            DynamicLengthField.from_et(dl_element, doc_frags)
+            for dl_element in et_element.iterfind("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD")
+        ]
+
         dtc_dops = []
         for dtc_dop_elem in et_element.iterfind("DTC-DOPS/DTC-DOP"):
             dtc_dop = DtcDop.from_et(dtc_dop_elem, doc_frags)
@@ -123,6 +131,7 @@ class DiagDataDictionarySpec:
             data_object_props=NamedItemList(data_object_props),
             structures=NamedItemList(structures),
             end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
+            dynamic_length_fields=NamedItemList(dynamic_length_fields),
             dtc_dops=NamedItemList(dtc_dops),
             unit_spec=unit_spec,
             tables=NamedItemList(tables),
@@ -145,6 +154,7 @@ class DiagDataDictionarySpec:
                 self.sdgs,
                 self.structures,
                 self.end_of_pdu_fields,
+                self.dynamic_length_fields,
                 self.tables,
         ):
             odxlinks.update(obj._build_odxlinks())
@@ -157,8 +167,8 @@ class DiagDataDictionarySpec:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
 
         for obj in chain(self.data_object_props, self.dtc_dops, self.end_of_pdu_fields,
-                         self.env_data_descs, self.env_datas, self.muxs, self.sdgs, self.structures,
-                         self.tables):
+                         self.dynamic_length_fields, self.env_data_descs, self.env_datas, self.muxs,
+                         self.sdgs, self.structures, self.tables):
             obj._resolve_odxlinks(odxlinks)
 
         if self.unit_spec is not None:
@@ -166,8 +176,8 @@ class DiagDataDictionarySpec:
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         for obj in chain(self.data_object_props, self.dtc_dops, self.end_of_pdu_fields,
-                         self.env_data_descs, self.env_datas, self.muxs, self.sdgs, self.structures,
-                         self.tables):
+                         self.dynamic_length_fields, self.env_data_descs, self.env_datas, self.muxs,
+                         self.sdgs, self.structures, self.tables):
             obj._resolve_snrefs(diag_layer)
 
         if self.unit_spec is not None:

odxtools/diaglayer.py

@@ -10,24 +10,17 @@ from deprecation import deprecated
 
 from .additionalaudience import AdditionalAudience
 from .admindata import AdminData
-from .basicstructure import BasicStructure
 from .communicationparameterref import CommunicationParameterRef
 from .companydata import CompanyData
-from .dataobjectproperty import DataObjectProperty
 from .diagdatadictionaryspec import DiagDataDictionarySpec
 from .diaglayerraw import DiagLayerRaw
 from .diaglayertype import DiagLayerType
 from .diagservice import DiagService
-from .dtcdop import DtcDop
 from .ecuvariantpattern import EcuVariantPattern
-from .endofpdufield import EndOfPduField
-from .environmentdata import EnvironmentData
-from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import DecodeError, OdxWarning, odxassert
 from .functionalclass import FunctionalClass
 from .message import Message
-from .multiplexer import Multiplexer
-from .nameditemlist import NamedItemList
+from .nameditemlist import NamedItemList, OdxNamed
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .parentref import ParentRef
 from .request import Request
@@ -40,6 +33,7 @@ from .unitgroup import UnitGroup
 from .unitspec import UnitSpec
 
 T = TypeVar("T")
+TNamed = TypeVar("TNamed", bound=OdxNamed)
 
 PrefixTree = Dict[int, Union[List[DiagService], "PrefixTree"]]
 
@@ -154,47 +148,58 @@ class DiagLayer:
                 sdgs=[])
         ############
 
-        dops = NamedItemList(self._compute_available_data_object_props())
-        tables = NamedItemList(self._compute_available_tables())
-        dtc_dops: NamedItemList[DtcDop]
-        structures: NamedItemList[BasicStructure]
-        end_of_pdu_fields: NamedItemList[EndOfPduField]
-        env_data_descs: NamedItemList[EnvironmentDataDescription]
-        env_datas: NamedItemList[EnvironmentData]
-        muxs: NamedItemList[Multiplexer]
+        dops = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.data_object_props,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        structures = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.structures,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        dtc_dops = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.dtc_dops,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        end_of_pdu_fields = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.end_of_pdu_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,
+        )
+        env_data_descs = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.env_data_descs,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
+        env_datas = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.env_datas, lambda parent_ref: parent_ref.not_inherited_dops)
+        muxs = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.muxs, lambda parent_ref: parent_ref.not_inherited_dops)
+        tables = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.tables, lambda parent_ref: parent_ref.not_inherited_tables)
         ddds_sdgs: List[SpecialDataGroup]
         if self.diag_layer_raw.diag_data_dictionary_spec:
-            dtc_dops = self.diag_layer_raw.diag_data_dictionary_spec.dtc_dops
-            structures = self.diag_layer_raw.diag_data_dictionary_spec.structures
-            end_of_pdu_fields = self.diag_layer_raw.diag_data_dictionary_spec.end_of_pdu_fields
-            env_data_descs = self.diag_layer_raw.diag_data_dictionary_spec.env_data_descs
-            env_datas = self.diag_layer_raw.diag_data_dictionary_spec.env_datas
-            muxs = self.diag_layer_raw.diag_data_dictionary_spec.muxs
             ddds_sdgs = self.diag_layer_raw.diag_data_dictionary_spec.sdgs
         else:
-            dtc_dops = NamedItemList()
-            structures = NamedItemList()
-            end_of_pdu_fields = NamedItemList()
-            env_data_descs = NamedItemList()
-            env_datas = NamedItemList()
-            muxs = NamedItemList()
             ddds_sdgs = []
 
         # create a DiagDataDictionarySpec which includes all the
         # inherited objects. To me, this seems rather inelegant, but
         # hey, it's described like this in the standard.
-        self._diag_data_dictionary_spec = \
-            DiagDataDictionarySpec(
-                data_object_props=dops,
-                dtc_dops=dtc_dops,
-                structures=structures,
-                end_of_pdu_fields=end_of_pdu_fields,
-                tables=tables,
-                env_data_descs=env_data_descs,
-                env_datas=env_datas,
-                muxs=muxs,
-                unit_spec=unit_spec,
-                sdgs=ddds_sdgs)
+        self._diag_data_dictionary_spec = DiagDataDictionarySpec(
+            data_object_props=dops,
+            dtc_dops=dtc_dops,
+            structures=structures,
+            end_of_pdu_fields=end_of_pdu_fields,
+            dynamic_length_fields=dynamic_length_fields,
+            tables=tables,
+            env_data_descs=env_data_descs,
+            env_datas=env_datas,
+            muxs=muxs,
+            unit_spec=unit_spec,
+            sdgs=ddds_sdgs,
+        )
 
         #####
         # compute the communication parameters applicable to the
@@ -457,29 +462,19 @@ class DiagLayer:
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
 
-    def _compute_available_data_object_props(self) -> Iterable[DataObjectProperty]:
-
-        def get_local_objects_fn(dl):
-            if dl.diag_layer_raw.diag_data_dictionary_spec is None:
-                return []
-            return dl.diag_layer_raw.diag_data_dictionary_spec.data_object_props
-
-        def not_inherited_fn(parent_ref):
-            return parent_ref.not_inherited_dops
-
-        return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
-
-    def _compute_available_tables(self) -> Iterable[Table]:
+    def _compute_available_ddd_spec_items(
+        self,
+        include: Callable[[DiagDataDictionarySpec], Iterable[TNamed]],
+        exclude: Callable[["ParentRef"], List[str]],
+    ) -> NamedItemList[TNamed]:
 
-        def get_local_objects_fn(dl):
+        def get_local_objects_fn(dl: "DiagLayer"):
             if dl.diag_layer_raw.diag_data_dictionary_spec is None:
                 return []
-            return dl.diag_layer_raw.diag_data_dictionary_spec.tables
+            return include(dl.diag_layer_raw.diag_data_dictionary_spec)
 
-        def not_inherited_fn(parent_ref):
-            return parent_ref.not_inherited_tables
-
-        return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
+        found = self._compute_available_objects(get_local_objects_fn, exclude)
+        return NamedItemList(found)
 
     def _compute_available_functional_classes(self) -> Iterable[FunctionalClass]:
 

odxtools/dynamiclengthfield.py

@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List
+from xml.etree import ElementTree
+
+from .decodestate import DecodeState
+from .determinenumberofitems import DetermineNumberOfItems
+from .encodestate import EncodeState
+from .exceptions import odxrequire
+from .field import Field
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import ParameterValueDict
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .diaglayer import DiagLayer
+
+
+@dataclass
+class DynamicLengthField(Field):
+    """Array of structure with length field"""
+    offset: int
+    determine_number_of_items: DetermineNumberOfItems
+
+    @staticmethod
+    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)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+        odxlinks.update(self.determine_number_of_items._build_odxlinks())
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+        self.determine_number_of_items._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        super()._resolve_snrefs(diag_layer)
+        self.determine_number_of_items._resolve_snrefs(diag_layer)
+
+    def convert_physical_to_bytes(
+        self,
+        physical_value: List[ParameterValueDict],
+        encode_state: EncodeState,
+        bit_position: int = 0,
+    ) -> bytes:
+        raise NotImplementedError()
+
+    def convert_bytes_to_physical(self, decode_state: DecodeState, bit_position: int = 0):
+        raise NotImplementedError()

odxtools/element.py

@@ -2,11 +2,9 @@ from dataclasses import dataclass
 from typing import List, Optional
 from xml.etree import ElementTree
 
-from odxtools.exceptions import odxrequire
-from odxtools.utils import create_description_from_et
-
+from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkId
-from .utils import dataclass_fields_asdict
+from .utils import create_description_from_et, dataclass_fields_asdict
 
 
 @dataclass

odxtools/endofpdufield.py

@@ -1,62 +1,28 @@
 # SPDX-License-Identifier: MIT
 from copy import copy
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from typing import List, Optional
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
-from .createsdgs import create_sdgs_from_et
 from .decodestate import DecodeState
-from .dopbase import DopBase
-from .element import IdentifiableElement
 from .encodestate import EncodeState
 from .exceptions import odxassert
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
-from .odxtypes import ParameterValueDict, odxstr_to_bool
+from .field import Field
+from .odxlink import OdxDocFragment
+from .odxtypes import ParameterValueDict
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
-class EndOfPduField(DopBase):
+class EndOfPduField(Field):
     """End of PDU fields are structures that are repeated until the end of the PDU"""
-
-    structure_ref: Optional[OdxLinkRef]
-    structure_snref: Optional[str]
-    env_data_desc_ref: Optional[OdxLinkRef]
-    env_data_desc_snref: Optional[str]
     min_number_of_items: Optional[int]
     max_number_of_items: Optional[int]
 
-    def __post_init__(self) -> 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
-
-        odxassert(
-            num_struct_refs + num_edd_refs == 1,
-            "END-OF-PDU-FIELDs need to specify exactly one reference to a "
-            "structure or an environment data description")
-
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "EndOfPduField":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
-
-        structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), doc_frags)
-        structure_snref = None
-        if (edsnr_elem := et_element.find("BASIC-STRUCTURE-SNREF")) is not None:
-            structure_snref = edsnr_elem.get("SHORT-NAME")
-
-        env_data_desc_ref = OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags)
-        env_data_desc_snref = None
-        if (edsnr_elem := et_element.find("ENV-DATA-DESC-SNREF")) is not None:
-            env_data_desc_snref = edsnr_elem.get("SHORT-NAME")
+        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)
@@ -67,32 +33,13 @@ class EndOfPduField(DopBase):
         else:
             max_number_of_items = None
 
-        is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
         eopf = EndOfPduField(
-            sdgs=sdgs,
-            structure_ref=structure_ref,
-            structure_snref=structure_snref,
-            env_data_desc_ref=env_data_desc_ref,
-            env_data_desc_snref=env_data_desc_snref,
             min_number_of_items=min_number_of_items,
             max_number_of_items=max_number_of_items,
-            is_visible_raw=is_visible_raw,
             **kwargs)
 
         return eopf
 
-    @property
-    def structure(self) -> "BasicStructure":
-        """may be a Structure or a env-data-desc"""
-        return self._structure
-
-    @property
-    def bit_length(self):
-        return self.structure.bit_length
-
-    def convert_physical_to_internal(self, physical_value):
-        return self.structure.convert_physical_to_internal(physical_value)
-
     def convert_physical_to_bytes(
         self,
         physical_value: ParameterValueDict,
@@ -133,21 +80,3 @@ class EndOfPduField(DopBase):
             value.append(new_value)
 
         return value, next_byte_position
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        """Recursively resolve any odxlinks references"""
-        if self.structure_ref is not None:
-            self._structure = odxlinks.resolve(self.structure_ref)
-
-        if self.env_data_desc_ref is not None:
-            self._env_data_desc = odxlinks.resolve(self.env_data_desc_ref)
-
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        """Recursively resolve any short-name references"""
-        if self.structure_snref is not None:
-            structures = diag_layer.diag_data_dictionary_spec.structures
-            self._structure = structures[self.structure_snref]
-
-        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 = env_data_descs[self.env_data_desc_snref]

odxtools/field.py

@@ -0,0 +1,94 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+from xml.etree import ElementTree
+
+from .environmentdatadescription import EnvironmentDataDescription
+from .basicstructure import BasicStructure
+from .createsdgs import create_sdgs_from_et
+from .dopbase import DopBase
+from .element import IdentifiableElement
+from .exceptions import odxassert, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from .odxtypes import odxstr_to_bool
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .diaglayer import DiagLayer
+
+
+@dataclass
+class Field(DopBase):
+    structure_ref: Optional[OdxLinkRef]
+    structure_snref: Optional[str]
+    env_data_desc_ref: Optional[OdxLinkRef]
+    env_data_desc_snref: Optional[str]
+
+    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
+
+        odxassert(
+            num_struct_refs + num_edd_refs == 1,
+            "FIELDs need to specify exactly one reference to a "
+            "structure or an environment data description")
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Field":
+        kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, doc_frags))
+        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+
+        structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), doc_frags)
+        structure_snref = None
+        if (edsnr_elem := et_element.find("BASIC-STRUCTURE-SNREF")) is not None:
+            structure_snref = edsnr_elem.get("SHORT-NAME")
+
+        env_data_desc_ref = OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags)
+        env_data_desc_snref = None
+        if (edsnr_elem := et_element.find("ENV-DATA-DESC-SNREF")) is not None:
+            env_data_desc_snref = edsnr_elem.get("SHORT-NAME")
+
+        is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
+        return Field(
+            sdgs=sdgs,
+            structure_ref=structure_ref,
+            structure_snref=structure_snref,
+            env_data_desc_ref=env_data_desc_ref,
+            env_data_desc_snref=env_data_desc_snref,
+            is_visible_raw=is_visible_raw,
+            **kwargs)
+
+    @property
+    def structure(self) -> BasicStructure:
+        """may be a Structure or a env-data-desc"""
+        return odxrequire(self._structure, "EnvironmentDataDescription is not supported")
+
+    @property
+    def bit_length(self):
+        return self.structure.bit_length
+
+    def convert_physical_to_internal(self, physical_value):
+        return self.structure.convert_physical_to_internal(physical_value)
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        """Recursively resolve any odxlinks references"""
+        if self.structure_ref is not None:
+            self._structure = odxlinks.resolve(self.structure_ref, BasicStructure)
+
+        if self.env_data_desc_ref is not None:
+            self._env_data_desc = odxlinks.resolve(self.env_data_desc_ref,
+                                                   EnvironmentDataDescription)
+
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        """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))
+
+        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))

odxtools/multiplexer.py

@@ -63,7 +63,7 @@ class Multiplexer(DopBase):
         return None
 
     def _get_case_limits(self, case: MultiplexerCase):
-        key_type = self.switch_key._dop.physical_type.base_data_type
+        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)
         return lower_limit, upper_limit
@@ -80,7 +80,6 @@ class Multiplexer(DopBase):
             with only one key equal to the desired case""")
 
         case_name, case_value = next(iter(physical_value.items()))
-        key_pos = self.switch_key.byte_position
         case_pos = self.byte_position
 
         for case in self.cases or []:
@@ -92,14 +91,11 @@ class Multiplexer(DopBase):
                     case_bytes = bytes()
 
                 key_value, _ = self._get_case_limits(case)
-                sk_bit_position = self.switch_key.bit_position
-                sk_bit_position = sk_bit_position if sk_bit_position is not None else 0
-                key_bytes = self.switch_key._dop.convert_physical_to_bytes(
-                    key_value, encode_state, sk_bit_position)
+                key_bytes = self.switch_key.convert_physical_to_bytes(key_value, encode_state)
 
-                mux_len = max(len(key_bytes) + key_pos, len(case_bytes) + case_pos)
+                mux_len = max(len(key_bytes), len(case_bytes) + case_pos)
                 mux_bytes = bytearray(mux_len)
-                mux_bytes[key_pos:key_pos + len(key_bytes)] = key_bytes
+                mux_bytes[:len(key_bytes)] = key_bytes
                 mux_bytes[case_pos:case_pos + len(case_bytes)] = case_bytes
 
                 return bytes(mux_bytes)
@@ -111,17 +107,9 @@ class Multiplexer(DopBase):
         if bit_position != 0:
             raise DecodeError("Multiplexer must be aligned, i.e. bit_position=0, but "
                               f"{self.short_name} was passed the bit position {bit_position}")
-        byte_code = decode_state.coded_message[decode_state.next_byte_position:]
-        key_decode_state = DecodeState(
-            coded_message=byte_code[self.switch_key.byte_position:],
-            parameter_values=dict(),
-            next_byte_position=0,
-        )
-        bit_position_int = (
-            self.switch_key.bit_position if self.switch_key.bit_position is not None else 0)
-        key_value, key_next_byte = self.switch_key._dop.convert_bytes_to_physical(
-            key_decode_state, bit_position=bit_position_int)
+        key_value, key_next_byte = self.switch_key.convert_bytes_to_physical(decode_state)
 
+        byte_code = decode_state.coded_message[decode_state.next_byte_position:]
         case_decode_state = DecodeState(
             coded_message=byte_code[self.byte_position:],
             parameter_values=dict(),

odxtools/multiplexerswitchkey.py

@@ -1,53 +1,18 @@
-# SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import List
 from xml.etree import ElementTree
 
-from .dataobjectproperty import DataObjectProperty
-from .exceptions import odxrequire
-from .globals import logger
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .odxlink import OdxDocFragment
+from .positioneddataobjectproperty import PositionedDataObjectProperty
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
-class MultiplexerSwitchKey:
-    """This class represents a Switch Key, which is used to select one of the cases defined in the Multiplexer."""
-
-    byte_position: int
-    bit_position: Optional[int]
-    dop_ref: OdxLinkRef
-
-    def __post_init__(self):
-        self._dop: DataObjectProperty = None  # type: ignore
+class MultiplexerSwitchKey(PositionedDataObjectProperty):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerSwitchKey":
-        """Reads a Switch Key for a Multiplexer."""
-        byte_position = int(odxrequire(et_element.findtext("BYTE-POSITION", "0")))
-        bit_position_str = et_element.findtext("BIT-POSITION")
-        bit_position = int(bit_position_str) if bit_position_str is not None else None
-        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags))
-
-        return MultiplexerSwitchKey(
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-        )
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return {}
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        dop = odxlinks.resolve(self.dop_ref)
-        if isinstance(dop, DataObjectProperty):
-            self._dop = dop
-        else:
-            logger.warning(
-                f"DATA-OBJECT-PROP-REF '{self.dop_ref}' could not be resolved in SWITCH-KEY.")
-
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        pass
+        kwargs = dataclass_fields_asdict(
+            PositionedDataObjectProperty.from_et(et_element, doc_frags))
+        return MultiplexerSwitchKey(**kwargs)

odxtools/odxtypes.py

@@ -6,7 +6,7 @@ from xml.etree import ElementTree
 from .exceptions import odxassert, odxraise, odxrequire
 
 if TYPE_CHECKING:
-    from odxtools.parameters.parameter import Parameter
+    from .parameters.parameter import Parameter
 
 
 def bytefield_to_bytearray(bytefield: str) -> bytearray: