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

odxtools/parameters/parameter.py

@@ -1,14 +1,18 @@
 # SPDX-License-Identifier: MIT
-import abc
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
+from xml.etree import ElementTree
 
+from typing_extensions import final, override
+
+from ..createsdgs import create_sdgs_from_et
 from ..decodestate import DecodeState
 from ..element import NamedElement
 from ..encodestate import EncodeState
-from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..specialdatagroup import SpecialDataGroup
+from ..utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
     from ..diaglayer import DiagLayer
@@ -30,12 +34,42 @@ ParameterType = Literal[
 
 
 @dataclass
-class Parameter(NamedElement, abc.ABC):
+class Parameter(NamedElement):
+    """This class corresponds to POSITIONABLE-PARAM in the ODX
+    specification.
+
+    Be aware that, even though the ODX specification seems to make the
+    distinction of "positionable" and "normal" parameters, it does not
+    define any non-positionable parameter types.
+
+    """
     byte_position: Optional[int]
     bit_position: Optional[int]
     semantic: Optional[str]
     sdgs: List[SpecialDataGroup]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Parameter":
+
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        semantic = et_element.get("SEMANTIC")
+        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+
+        byte_position_str = et_element.findtext("BYTE-POSITION")
+        bit_position_str = et_element.findtext("BIT-POSITION")
+
+        byte_position = int(byte_position_str) if byte_position_str is not None else None
+        bit_position = int(bit_position_str) if bit_position_str is not None else None
+
+        return Parameter(
+            byte_position=byte_position,
+            bit_position=bit_position,
+            semantic=semantic,
+            sdgs=sdgs,
+            **kwargs)
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {}
 
@@ -53,9 +87,9 @@ class Parameter(NamedElement, abc.ABC):
             sdg._resolve_snrefs(diag_layer)
 
     @property
-    @abc.abstractmethod
     def parameter_type(self) -> ParameterType:
-        pass
+        raise NotImplementedError(
+            ".parameter_type is not implemented by the concrete parameter class")
 
     def get_static_bit_length(self) -> Optional[int]:
         return None
@@ -70,7 +104,7 @@ class Parameter(NamedElement, abc.ABC):
         specified.
 
         """
-        raise NotImplementedError
+        raise NotImplementedError(".is_required is not implemented by the concrete parameter class")
 
     @property
     def is_settable(self) -> bool:
@@ -81,44 +115,36 @@ class Parameter(NamedElement, abc.ABC):
         have a default value are settable but not required to be
         specified.
         """
-        raise NotImplementedError
+        raise NotImplementedError(".is_settable is not implemented by the concrete parameter class")
 
-    @abc.abstractmethod
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         """Get the coded value of the parameter given the encode state.
         Note that this method is called by `encode_into_pdu`.
         """
-        pass
+        raise NotImplementedError(
+            ".get_coded_value_as_bytes() is not implemented by the concrete parameter class")
 
-    @abc.abstractmethod
+    @final
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        """Decode the parameter value from the coded message.
+        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
 
-        If the parameter does have a byte position property, the coded bytes the parameter covers are extracted
-        at this byte position and the function parameter `default_byte_position` is ignored.
+        decode_state.cursor_bit_position = self.bit_position or 0
 
-        If the parameter does not have a byte position and a byte position is passed,
-        the bytes are extracted at the byte position given by the argument `default_byte_position`.
+        result = self._decode_positioned_from_pdu(decode_state)
 
-        If the parameter does not have a byte position and the argument `default_byte_position` is None,
-        this function throws a `DecodeError`.
+        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
+        decode_state.cursor_bit_position = 0
 
-        Parameters
-        ----------
-        decode_state : DecodeState
-            The decoding state containing
-            * the byte message to be decoded
-            * the parameter values that are already decoded
-            * the next byte position that is used iff the parameter does not specify a byte position
+        return result
 
-        Returns
-        -------
-        ParameterValuePair | List[ParameterValuePair]
-            the decoded parameter value (the type is defined by the DOP)
-        int
-            the next byte position after the extracted parameter
-        """
-        pass
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        """Method which actually decodes the parameter
+
+        Its location is managed by `Parameter`."""
+        raise NotImplementedError(
+            "Required method '_decode_positioned_from_pdu()' not implemented by child class")
 
     def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
         """Encode the value of a parameter into a binary blob and return it

odxtools/parameters/parameterwithdop.py

@@ -1,6 +1,9 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..dataobjectproperty import DataObjectProperty
 from ..decodestate import DecodeState
@@ -8,9 +11,10 @@ from ..dopbase import DopBase
 from ..dtcdop import DtcDop
 from ..encodestate import EncodeState
 from ..exceptions import odxassert, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from ..odxtypes import ParameterValue
 from ..physicaltype import PhysicalType
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter
 
 if TYPE_CHECKING:
@@ -22,14 +26,30 @@ class ParameterWithDOP(Parameter):
     dop_ref: Optional[OdxLinkRef]
     dop_snref: Optional[str]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "ParameterWithDOP":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        dop_ref = OdxLinkRef.from_et(et_element.find("DOP-REF"), doc_frags)
+        dop_snref = None
+        if (dop_snref_elem := et_element.find("DOP-SNREF")) is not None:
+            dop_snref = odxrequire(dop_snref_elem.get("SHORT-NAME"))
+
+        return ParameterWithDOP(dop_ref=dop_ref, dop_snref=dop_snref, **kwargs)
+
     def __post_init__(self) -> None:
         odxassert(self.dop_snref is not None or self.dop_ref is not None,
                   f"Param {self.short_name} without a DOP-(SN)REF should not exist!")
         self._dop: Optional[DopBase] = None
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
@@ -40,6 +60,7 @@ class ParameterWithDOP(Parameter):
             # (e.g., static and dynamic fields)
             self._dop = odxlinks.resolve_lenient(self.dop_ref)
 
+    @override
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
@@ -55,6 +76,7 @@ class ParameterWithDOP(Parameter):
             self._dop, "Specifying a data object property is mandatory but it "
             "could not be resolved")
 
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         if self._dop is not None:
             return self._dop.get_static_bit_length()
@@ -68,6 +90,7 @@ class ParameterWithDOP(Parameter):
         else:
             return None
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         dop = odxrequire(self.dop, "Reference to DOP is not resolved")
         physical_value = encode_state.parameter_values[self.short_name]
@@ -75,16 +98,6 @@ class ParameterWithDOP(Parameter):
         return dop.convert_physical_to_bytes(
             physical_value, encode_state, bit_position=bit_position_int)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        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.cursor_bit_position = self.bit_position or 0
-
-        # Use DOP to decode
-        phys_val = self.dop.decode_from_pdu(decode_state)
-
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
-
-        return phys_val
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        return self.dop.decode_from_pdu(decode_state)

odxtools/parameters/physicalconstantparameter.py

@@ -1,13 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict
+from typing import TYPE_CHECKING, Any, Dict, List
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..dataobjectproperty import DataObjectProperty
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, odxraise, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
@@ -20,16 +24,32 @@ class PhysicalConstantParameter(ParameterWithDOP):
 
     physical_constant_value_raw: str
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "PhysicalConstantParameter":
+
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+
+        physical_constant_value_raw = odxrequire(et_element.findtext("PHYS-CONSTANT-VALUE"))
+
+        return PhysicalConstantParameter(
+            physical_constant_value_raw=physical_constant_value_raw, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "PHYS-CONST"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
+    @override
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
@@ -44,13 +64,16 @@ class PhysicalConstantParameter(ParameterWithDOP):
         return self._physical_constant_value
 
     @property
+    @override
     def is_required(self) -> bool:
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         return False
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         dop = odxrequire(self.dop, "Reference to DOP is not resolved")
         if (self.short_name in encode_state.parameter_values and
@@ -63,9 +86,10 @@ class PhysicalConstantParameter(ParameterWithDOP):
         return dop.convert_physical_to_bytes(
             self.physical_constant_value, encode_state, bit_position=bit_position_int)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         # Decode value
-        phys_val = super().decode_from_pdu(decode_state)
+        phys_val = super()._decode_positioned_from_pdu(decode_state)
 
         # Check if decoded value matches expected value
         if phys_val != self.physical_constant_value:

odxtools/parameters/reservedparameter.py

@@ -1,10 +1,16 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional, cast
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..odxtypes import ParameterValue
+from ..exceptions import odxrequire
+from ..odxlink import OdxDocFragment
+from ..odxtypes import DataType, ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
@@ -12,35 +18,43 @@ from .parameter import Parameter, ParameterType
 class ReservedParameter(Parameter):
     bit_length: int
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "ReservedParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
+
+        return ReservedParameter(bit_length=bit_length, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "RESERVED"
 
     @property
+    @override
     def is_required(self) -> bool:
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         return False
 
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.bit_length
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return (0).to_bytes((self.bit_length + bit_position_int + 7) // 8, "big")
-
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        # move the cursor
-        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.cursor_byte_position += ((self.bit_position or 0) + self.bit_length + 7) // 8
-
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
-        decode_state.cursor_bit_position = 0
-
-        # ignore the value of the parameter data
-        return cast(int, None)
+        return (0).to_bytes(((self.bit_position or 0) + self.bit_length + 7) // 8, "big")
+
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        return decode_state.extract_atomic_value(
+            bit_length=self.bit_length,
+            base_data_type=DataType.A_UINT32,
+            is_highlow_byte_order=False)

odxtools/parameters/systemparameter.py

@@ -1,9 +1,16 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import List
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
+from ..exceptions import odxrequire
+from ..odxlink import OdxDocFragment
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
@@ -12,20 +19,36 @@ from .parameterwithdop import ParameterWithDOP
 class SystemParameter(ParameterWithDOP):
     sysparam: str
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "SystemParameter":
+
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+
+        sysparam = odxrequire(et_element.findtext("SYSPARAM"))
+
+        return SystemParameter(sysparam=sysparam, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "SYSTEM"
 
     @property
+    @override
     def is_required(self) -> bool:
         raise NotImplementedError("SystemParameter.is_required is not implemented yet.")
 
     @property
+    @override
     def is_settable(self) -> bool:
         raise NotImplementedError("SystemParameter.is_settable is not implemented yet.")
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         raise NotImplementedError("Encoding a SystemParameter is not implemented yet.")
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding a SystemParameter is not implemented yet.")
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        raise NotImplementedError("Decoding SystemParameter is not implemented yet.")

odxtools/parameters/tableentryparameter.py

@@ -1,32 +1,71 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, List
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..odxlink import OdxLinkRef
+from ..exceptions import odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
+if TYPE_CHECKING:
+    from ..tablerow import TableRow
+
 
 @dataclass
 class TableEntryParameter(Parameter):
     target: str
     table_row_ref: OdxLinkRef
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableEntryParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        target = odxrequire(et_element.findtext("TARGET"))
+        table_row_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags))
+
+        return TableEntryParameter(target=target, table_row_ref=table_row_ref, **kwargs)
+
+    @override
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        if TYPE_CHECKING:
+            self._table_row = odxlinks.resolve(self.table_row_ref, TableRow)
+        else:
+            self._table_row = odxlinks.resolve(self.table_row_ref)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "TABLE-ENTRY"
 
     @property
+    @override
     def is_required(self) -> bool:
-        raise NotImplementedError("TableKeyParameter.is_required is not implemented yet.")
+        raise NotImplementedError("TableEntryParameter.is_required is not implemented yet.")
 
     @property
+    @override
     def is_settable(self) -> bool:
-        raise NotImplementedError("TableKeyParameter.is_settable is not implemented yet.")
+        raise NotImplementedError("TableEntryParameter.is_settable is not implemented yet.")
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        raise NotImplementedError("Encoding a TableKeyParameter is not implemented yet.")
+        raise NotImplementedError("Encoding a TableEntryParameter is not implemented yet.")
+
+    @property
+    def table_row(self) -> "TableRow":
+        return self._table_row
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding a TableKeyParameter is not implemented yet.")
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        raise NotImplementedError("Decoding a TableEntryParameter is not implemented yet.")

odxtools/parameters/tablekeyparameter.py

@@ -1,12 +1,16 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 if TYPE_CHECKING:
@@ -24,6 +28,33 @@ class TableKeyParameter(Parameter):
     table_row_snref: Optional[str]
     table_row_ref: Optional[OdxLinkRef]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableKeyParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+
+        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags)
+        table_snref = None
+        if (table_snref_elem := et_element.find("TABLE-SNREF")) is not None:
+            table_snref = odxrequire(table_snref_elem.get("SHORT-NAME"))
+
+        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags)
+        table_row_snref = None
+        if (table_row_snref_elem := et_element.find("TABLE-ROW-SNREF")) is not None:
+            table_row_snref = odxrequire(table_row_snref_elem.get("SHORT-NAME"))
+
+        return TableKeyParameter(
+            odx_id=odx_id,
+            table_ref=table_ref,
+            table_snref=table_snref,
+            table_row_ref=table_row_ref,
+            table_row_snref=table_row_snref,
+            **kwargs)
+
     def __post_init__(self) -> None:
         self._table: "Table"
         self._table_row: Optional["TableRow"] = None
@@ -32,9 +63,11 @@ class TableKeyParameter(Parameter):
             odxraise("Either a table or a table row must be defined.")
 
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "TABLE-KEY"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -42,6 +75,7 @@ class TableKeyParameter(Parameter):
 
         return result
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
@@ -59,6 +93,7 @@ class TableKeyParameter(Parameter):
                 self._table_row = odxlinks.resolve(self.table_row_ref)
             self._table = self._table_row.table
 
+    @override
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
@@ -86,15 +121,18 @@ class TableKeyParameter(Parameter):
         return self._table_row
 
     @property
+    @override
     def is_required(self) -> bool:
         # TABLE-KEY parameters can be implicitly determined from the
         # corresponding TABLE-STRUCT
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         return True
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         tr_short_name = encode_state.parameter_values.get(self.short_name)
 
@@ -132,14 +170,12 @@ class TableKeyParameter(Parameter):
         bit_position = 0 if self.bit_position is None else self.bit_position
         return key_dop.convert_physical_to_bytes(tr.key, encode_state, bit_position=bit_position)
 
+    @override
     def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
         return super().encode_into_pdu(encode_state)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        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
-
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         if self.table_row is not None:
             # the table row to be used is statically specified -> no
             # need to decode anything!
@@ -147,7 +183,6 @@ class TableKeyParameter(Parameter):
         else:
             # Use DOP to decode
             key_dop = odxrequire(self.table.key_dop)
-            decode_state.cursor_bit_position = self.bit_position or 0
             key_dop_val = key_dop.decode_from_pdu(decode_state)
 
             table_row_candidates = [x for x in self.table.table_rows if x.key == key_dop_val]
@@ -162,6 +197,4 @@ class TableKeyParameter(Parameter):
             # update the decode_state's table key
             decode_state.table_keys[self.short_name] = table_row
 
-        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
-
         return phys_val