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

odxtools/parameters/lengthkeyparameter.py

@@ -1,17 +1,17 @@
 # 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
-from .parameter import ParameterType
+from .parameter import Parameter, ParameterType
 from .parameterwithdop import ParameterWithDOP
 
 if TYPE_CHECKING:
@@ -60,8 +60,9 @@ class LengthKeyParameter(ParameterWithDOP):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
     @property
     @override
@@ -77,17 +78,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
@@ -69,8 +75,9 @@ class NrcConstParameter(Parameter):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
     @override
     def get_static_bit_length(self) -> Optional[int]:
@@ -91,21 +98,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

@@ -82,7 +82,13 @@ class Parameter(NamedElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
+    @final
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        raise RuntimeError("Calling _resolve_snrefs() is not allowed for parameters. "
+                           "Use _parameter_resolve_snrefs() instead.")
+
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List["Parameter"]) -> None:
         for sdg in self.sdgs:
             sdg._resolve_snrefs(diag_layer)
 
@@ -117,12 +123,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 +173,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
@@ -11,8 +11,8 @@ from ..dopbase import DopBase
 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 ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..odxtypes import AtomicOdxType, ParameterValue
 from ..physicaltype import PhysicalType
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter
@@ -43,7 +43,7 @@ class ParameterWithDOP(Parameter):
     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
+        self._dop: DopBase
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -55,26 +55,22 @@ class ParameterWithDOP(Parameter):
 
         if self.dop_ref is not None:
             odxassert(self.dop_snref is None)
-            # TODO: do not do lenient resolves here. The problem is
-            # that currently not all kinds of DOPs are internalized
-            # (e.g., static and dynamic fields)
-            self._dop = odxlinks.resolve_lenient(self.dop_ref)
+            self._dop = odxlinks.resolve(self.dop_ref)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
         if self.dop_snref:
-            ddds = diag_layer.diag_data_dictionary_spec
-            self._dop = odxrequire(ddds.all_data_object_properties.get(self.dop_snref))
+            all_dops = diag_layer.diag_data_dictionary_spec.all_data_object_properties
+            self._dop = resolve_snref(self.dop_snref, all_dops, DopBase)
 
     @property
     def dop(self) -> DopBase:
-        """may be a DataObjectProperty, a Structure or None"""
+        """This is usually a DataObjectProperty or a Structure object"""
 
-        return odxrequire(
-            self._dop, "Specifying a data object property is mandatory but it "
-            "could not be resolved")
+        return self._dop
 
     @override
     def get_static_bit_length(self) -> Optional[int]:
@@ -91,12 +87,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,11 +8,11 @@ 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
-from .parameter import ParameterType
+from .parameter import Parameter, ParameterType
 from .parameterwithdop import ParameterWithDOP
 
 if TYPE_CHECKING:
@@ -50,8 +50,9 @@ class PhysicalConstantParameter(ParameterWithDOP):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
         dop = odxrequire(self.dop)
         if not isinstance(dop, DataObjectProperty):
@@ -74,17 +75,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 +98,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