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

odxtools/parameters/lengthkeyparameter.py

@@ -1,13 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from typing_extensions import override
+from typing_extensions import final, override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import odxraise, odxrequire
+from ..exceptions import EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
@@ -77,17 +77,65 @@ class LengthKeyParameter(ParameterWithDOP):
         return True
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        physical_value = encode_state.parameter_values.get(self.short_name, 0)
-
-        bit_pos = self.bit_position or 0
-        dop = odxrequire(super().dop,
-                         f"A DOP is required for length key parameter {self.short_name}")
-        return dop.convert_physical_to_bytes(physical_value, encode_state, bit_position=bit_pos)
-
-    @override
-    def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
-        return super().encode_into_pdu(encode_state)
+    @final
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        # if you get this exception, you ought to use
+        # `.encode_placeholder_into_pdu()` followed by (after the
+        # value of the length key has been determined)
+        # `.encode_value_into_pdu()`.
+        raise RuntimeError("_encode_positioned_into_pdu() cannot be called for length keys.")
+
+    def encode_placeholder_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+
+        if physical_value is not None:
+            if not self.dop.is_valid_physical_value(physical_value):
+                odxraise(f"Invalid explicitly specified physical value '{physical_value!r}' "
+                         f"for length key '{self.short_name}'.")
+
+            lkv = encode_state.length_keys.get(self.short_name)
+            if lkv is not None and lkv != physical_value:
+                odxraise(f"Got conflicting values for length key {self.short_name}: "
+                         f"{lkv} and {physical_value!r}")
+
+            if not isinstance(physical_value, int):
+                odxraise(
+                    f"Value of length key {self.short_name} is of type {type(physical_value).__name__} "
+                    f"instead of int")
+
+            encode_state.length_keys[self.short_name] = physical_value
+
+        orig_cursor = encode_state.cursor_byte_position
+        pos = encode_state.cursor_byte_position
+        if self.byte_position is not None:
+            pos = encode_state.origin_byte_position + self.byte_position
+        encode_state.key_pos[self.short_name] = pos
+        encode_state.cursor_byte_position = pos
+        encode_state.cursor_bit_position = self.bit_position or 0
+
+        # emplace a value of zero into the encode state, but pretend the bits not to be used
+        n = odxrequire(self.dop.get_static_bit_length()) + encode_state.cursor_bit_position
+        tmp_val = b'\x00' * ((n + 7) // 8)
+        encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
+
+        encode_state.cursor_byte_position = max(encode_state.cursor_byte_position, orig_cursor)
+        encode_state.cursor_bit_position = 0
+
+    def encode_value_into_pdu(self, encode_state: EncodeState) -> None:
+
+        if self.short_name not in encode_state.length_keys:
+            odxraise(
+                f"Length key {self.short_name} has not been defined before "
+                f"it is required.", EncodeError)
+            return
+        else:
+            physical_value = encode_state.length_keys[self.short_name]
+
+        encode_state.cursor_byte_position = encode_state.key_pos[self.short_name]
+        encode_state.cursor_bit_position = self.bit_position or 0
+
+        self.dop.encode_into_pdu(encode_state=encode_state, physical_value=physical_value)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/parameters/matchingrequestparameter.py

@@ -7,7 +7,7 @@ from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import EncodeError, odxrequire
+from ..exceptions import EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
@@ -52,19 +52,31 @@ class MatchingRequestParameter(Parameter):
         return False
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        if not encode_state.triggering_request:
-            raise EncodeError(f"Parameter '{self.short_name}' is of matching request type,"
-                              " but no original request has been specified.")
-        return encode_state.triggering_request[self
-                                               .request_byte_position:self.request_byte_position +
-                                               self.byte_length]
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        if encode_state.triggering_request is None:
+            odxraise(
+                f"Parameter '{self.short_name}' is of matching request type,"
+                f" but no original request has been specified.", EncodeError)
+            return
+
+        rq_pos = self.request_byte_position
+        rq_len = self.byte_length
+
+        if len(encode_state.triggering_request) < rq_pos + rq_len:
+            odxraise(
+                f"Specified triggering request 0x{encode_state.triggering_request.hex()} "
+                f"is not long enough to encode matching request parameter "
+                f"'{self.short_name}': Have {len(encode_state.triggering_request)} "
+                f"bytes, need at least {rq_pos + rq_len} bytes", EncodeError)
+            return
+
+        encode_state.emplace_bytes(encode_state.triggering_request[rq_pos:rq_pos + rq_len],
+                                   self.short_name)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        result = decode_state.extract_atomic_value(
+        return decode_state.extract_atomic_value(
             bit_length=self.byte_length * 8,
             base_data_type=DataType.A_UINT32,
             is_highlow_byte_order=False)
-
-        return result

odxtools/parameters/nrcconstparameter.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -10,9 +10,9 @@ from ..createanydiagcodedtype import create_any_diag_coded_type_from_et
 from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError, EncodeError, odxrequire
+from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-from ..odxtypes import AtomicOdxType, DataType
+from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
@@ -22,13 +22,19 @@ if TYPE_CHECKING:
 
 @dataclass
 class NrcConstParameter(Parameter):
-    """A param of type NRC-CONST defines a set of values to be matched.
+    """A param of type NRC-CONST defines a set of values to be matched for a negative response to apply.
 
-    An NRC-CONST can only be used in a negative response.
-    Its encoding behaviour is similar to a VALUE parameter with a TEXTTABLE.
-    However, an NRC-CONST is used for matching a response (similar to a CODED-CONST).
+    The behaviour of NRC-CONST parameters is similar to CODED-CONST
+    parameters in that they allow to specify which coding objects
+    apply to a binary string, but in contrast to CODED-CONST
+    parameters they allow to specify multiple values. Thus, the value
+    of a CODED-CONST parameter is usually set using an overlapping
+    VALUE parameter. Since NRC-CONST parameters can only be specified
+    for negative responses, they can thus be regarded as a multiplexer
+    mechanism that is specific to negative responses.
 
     See ASAM MCD-2 D (ODX), p. 77-79.
+
     """
 
     diag_coded_type: DiagCodedType
@@ -91,21 +97,34 @@ class NrcConstParameter(Parameter):
         return False
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        if self.short_name in encode_state.parameter_values:
-            if encode_state.parameter_values[self.short_name] not in self.coded_values:
-                raise EncodeError(f"The parameter '{self.short_name}' must have"
-                                  f" one of the constant values {self.coded_values}")
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        coded_value: ParameterValue
+        if physical_value is not None:
+            if physical_value not in self.coded_values:
+                odxraise(
+                    f"The value of parameter '{self.short_name}' must "
+                    f" be one of {self.coded_values} (is: {physical_value!r})", EncodeError)
+                coded_value = self.coded_values[0]
             else:
-                coded_value = encode_state.parameter_values[self.short_name]
+                coded_value = physical_value
         else:
-            # If the user does not select one, just select any.
-            # I think it does not matter ...
-            coded_value = self.coded_values[0]
-
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return self.diag_coded_type.convert_internal_to_bytes(
-            coded_value, encode_state, bit_position=bit_position_int)
+            # If the user did not select a value, the value of the
+            # this parameter is set by another parameter which
+            # overlaps with it. We thus just move the cursor.
+            bit_pos = encode_state.cursor_bit_position
+            bit_len = self.diag_coded_type.get_static_bit_length()
+
+            if bit_len is None:
+                odxraise("The diag coded type of NRC-CONST parameters must "
+                         "exhibit a static size")
+                return
+
+            encode_state.cursor_byte_position += (bit_pos + bit_len + 7) // 8
+            encode_state.cursor_bit_position = 0
+            return
+
+        self.diag_coded_type.encode_into_pdu(cast(AtomicOdxType, coded_value), encode_state)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:

odxtools/parameters/parameter.py

@@ -117,12 +117,35 @@ class Parameter(NamedElement):
         """
         raise NotImplementedError(".is_settable is not implemented by the concrete parameter class")
 
-    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`.
+    @final
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        """Convert a physical value into its encoded form and place it into the PDU
+
+        Also, adapt the `encode_state` so that it points to where the next
+        parameter is located (if the parameter does not explicitly specify a
+        position)
         """
+
+        orig_cursor = encode_state.cursor_byte_position
+        if self.byte_position is not None:
+            encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
+
+        encode_state.cursor_bit_position = self.bit_position or 0
+
+        self._encode_positioned_into_pdu(physical_value, encode_state)
+
+        encode_state.cursor_byte_position = max(encode_state.cursor_byte_position, orig_cursor)
+        encode_state.cursor_bit_position = 0
+
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        """Method which actually encodes the parameter
+
+        Its location is managed by `Parameter`."""
         raise NotImplementedError(
-            ".get_coded_value_as_bytes() is not implemented by the concrete parameter class")
+            f"Required method '_encode_positioned_into_pdu()' not implemented by "
+            f"child class {type(self).__name__}")
 
     @final
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -144,41 +167,5 @@ class Parameter(NamedElement):
 
         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
-
-        If the byte position of the parameter is not defined,
-        the byte code is appended to the blob.
-
-        Technical note for subclasses: The default implementation
-        tries to compute the coded value via
-        `self.get_coded_value_as_bytes(encoded_state)` and inserts it
-        into the PDU. Thus it usually suffices to overwrite
-        `get_coded_value_as_bytes()` instead of `encode_into_pdu()`.
-
-        Parameters:
-        ----------
-        encode_state: EncodeState, i.e. a named tuple with attributes
-            * coded_message: bytes, the message encoded so far
-            * parameter_values: List[ParameterValuePairs]
-            * triggering_coded_request: bytes
-
-        Returns:
-        -------
-        bytes
-            the message's blob after adding the encoded parameter into it
-
-        """
-        msg_blob = encode_state.coded_message
-        param_blob = self.get_coded_value_as_bytes(encode_state)
-
-        if self.byte_position is not None:
-            byte_position = self.byte_position
-        else:
-            byte_position = len(msg_blob)
-
-        encode_state.emplace_atomic_value(param_blob, self.short_name, byte_position)
-
-        return encode_state.coded_message
+            f"Required method '_decode_positioned_from_pdu()' not implemented by "
+            f"child class {type(self).__name__}")

odxtools/parameters/parameterwithdop.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -12,7 +12,7 @@ from ..dtcdop import DtcDop
 from ..encodestate import EncodeState
 from ..exceptions import odxassert, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from ..odxtypes import ParameterValue
+from ..odxtypes import AtomicOdxType, ParameterValue
 from ..physicaltype import PhysicalType
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter
@@ -91,12 +91,9 @@ class ParameterWithDOP(Parameter):
             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]
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return dop.convert_physical_to_bytes(
-            physical_value, encode_state, bit_position=bit_position_int)
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        self.dop.encode_into_pdu(cast(AtomicOdxType, physical_value), encode_state)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/parameters/physicalconstantparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,7 +8,7 @@ from typing_extensions import override
 from ..dataobjectproperty import DataObjectProperty
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError, odxraise, odxrequire
+from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
@@ -74,17 +74,15 @@ class PhysicalConstantParameter(ParameterWithDOP):
         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
-                encode_state.parameter_values[self.short_name] != self.physical_constant_value):
-            raise TypeError(
-                f"The parameter '{self.short_name}' is constant {self.physical_constant_value!r}"
-                f" and thus can not be changed.")
-
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return dop.convert_physical_to_bytes(
-            self.physical_constant_value, encode_state, bit_position=bit_position_int)
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        if physical_value is not None and physical_value != self.physical_constant_value:
+            odxraise(
+                f"Value for constant parameter `{self.short_name}` name can "
+                f"only be specified as {self.physical_constant_value!r} (is: {physical_value!r})",
+                EncodeError)
+
+        self.dop.encode_into_pdu(self.physical_constant_value, encode_state)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -99,4 +97,5 @@ class PhysicalConstantParameter(ParameterWithDOP):
                 f"{self.physical_constant_value!r} but got {phys_val!r} "
                 f"at byte position {decode_state.cursor_byte_position} "
                 f"in coded message {decode_state.coded_message.hex()}.", DecodeError)
+
         return phys_val

odxtools/parameters/reservedparameter.py

@@ -49,8 +49,11 @@ class ReservedParameter(Parameter):
         return self.bit_length
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        return (0).to_bytes(((self.bit_position or 0) + self.bit_length + 7) // 8, "big")
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        raw_data = (0).to_bytes((encode_state.cursor_bit_position + self.bit_length + 7) // 8,
+                                "big")
+        encode_state.emplace_bytes(raw_data, self.short_name)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/parameters/systemparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -46,7 +46,8 @@ class SystemParameter(ParameterWithDOP):
         raise NotImplementedError("SystemParameter.is_settable is not implemented yet.")
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
         raise NotImplementedError("Encoding a SystemParameter is not implemented yet.")
 
     @override

odxtools/parameters/tableentryparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -59,7 +59,8 @@ class TableEntryParameter(Parameter):
         raise NotImplementedError("TableEntryParameter.is_settable is not implemented yet.")
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
         raise NotImplementedError("Encoding a TableEntryParameter is not implemented yet.")
 
     @property

odxtools/parameters/tablekeyparameter.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from typing_extensions import override
+from typing_extensions import final, override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
@@ -133,46 +133,95 @@ class TableKeyParameter(Parameter):
         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)
-
-        if tr_short_name is None:
-            # the table key has not been defined explicitly yet, but
-            # it is most likely implicitly defined by the associated
-            # TABLE-STRUCT parameters. Use all-zeros as a standin for
-            # the real data...
+    @final
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        # if you get this exception, you ought to use
+        # `.encode_placeholder_into_pdu()` followed by (after the
+        # value of the table key has been determined)
+        # `.encode_value_into_pdu()`.
+        raise RuntimeError("_encode_positioned_into_pdu() cannot be called for table keys.")
+
+    def encode_placeholder_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+
+        if physical_value is not None:
             key_dop = self.table.key_dop
             if key_dop is None:
-                raise EncodeError(f"Table '{self.table.short_name}' does not define "
-                                  f"a KEY-DOP, but is used in TABLE-KEY parameter "
-                                  f"'{self.short_name}'")
+                odxraise(
+                    f"Table '{self.table.short_name}' does not define "
+                    f"a KEY-DOP, but is used by TABLE-KEY parameter "
+                    f"'{self.short_name}'", EncodeError)
+                return
+
+            if not isinstance(physical_value, str):
+                odxraise(f"Invalid type for for table key '{self.short_name}' specified. "
+                         f"(expect name of table row.)")
+
+            tkv = encode_state.table_keys.get(self.short_name)
+            if tkv is not None and tkv != physical_value:
+                odxraise(f"Got conflicting values for table key {self.short_name}: "
+                         f"{tkv} and {physical_value!r}")
+
+            encode_state.table_keys[self.short_name] = physical_value
+
+        orig_pos = encode_state.cursor_byte_position
+        pos = encode_state.cursor_byte_position
+        if self.byte_position is not None:
+            pos = encode_state.origin_byte_position + self.byte_position
+        encode_state.key_pos[self.short_name] = pos
+        encode_state.cursor_byte_position = pos
+        encode_state.cursor_bit_position = self.bit_position or 0
 
-            byte_len = (odxrequire(key_dop.get_static_bit_length()) + 7) // 8
-            if self.bit_position is not None and self.bit_position > 0:
-                byte_len += 1
+        key_dop = self.table.key_dop
+        if key_dop is None:
+            odxraise(f"No KEY-DOP specified for table {self.table.short_name}")
+            return
+
+        sz = key_dop.get_static_bit_length()
+        if sz is None:
+            odxraise("The DOP of table key {self.short_name} must exhibit a fixed size.",
+                     EncodeError)
+            return
+
+        # emplace a value of zero into the encode state, but pretend the bits not to be used
+        n = sz + encode_state.cursor_bit_position
+        tmp_val = b'\x00' * ((n + 7) // 8)
+        encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
+
+        encode_state.cursor_byte_position = max(orig_pos, encode_state.cursor_byte_position)
+        encode_state.cursor_bit_position = 0
+
+    def encode_value_into_pdu(self, encode_state: EncodeState) -> None:
 
-            return bytes([0] * byte_len)
+        key_dop = self.table.key_dop
+        if key_dop is None:
+            odxraise(
+                f"Table '{self.table.short_name}' does not define "
+                f"a KEY-DOP, but is used by TABLE-KEY parameter "
+                f"'{self.short_name}'", EncodeError)
+            return
+
+        if self.short_name not in encode_state.table_keys:
+            odxraise(f"Table key {self.short_name} has not been defined before "
+                     f"it is required.", EncodeError)
+            return
+        else:
+            tr_short_name = encode_state.table_keys[self.short_name]
 
-        # the table key is known. We need to encode the associated DOP
-        # into the PDU.
+        # We need to encode the table key using the associated DOP into the PDU.
         tr_candidates = [x for x in self.table.table_rows if x.short_name == tr_short_name]
         if len(tr_candidates) == 0:
-            raise EncodeError(f"No table row with short name '{tr_short_name}' found")
+            odxraise(f"No table row with short name '{tr_short_name}' found", EncodeError)
+            return
         elif len(tr_candidates) > 1:
-            raise EncodeError(f"Multiple rows exhibiting short name '{tr_short_name}'")
+            odxraise(f"Multiple rows exhibiting short name '{tr_short_name}'", EncodeError)
         tr = tr_candidates[0]
 
-        key_dop = self.table.key_dop
-        if key_dop is None:
-            raise EncodeError(f"Table '{self.table.short_name}' does not define "
-                              f"a KEY-DOP, but is used in TABLE-KEY parameter "
-                              f"'{self.short_name}'")
-        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)
+        encode_state.cursor_byte_position = encode_state.key_pos[self.short_name]
+        encode_state.cursor_bit_position = self.bit_position or 0
 
-    @override
-    def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
-        return super().encode_into_pdu(encode_state)
+        key_dop.encode_into_pdu(encode_state=encode_state, physical_value=odxrequire(tr.key))
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue: