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

odxtools/parameters/codedconstparameter.py

@@ -1,14 +1,19 @@
 # SPDX-License-Identifier: MIT
 import warnings
 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 ..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
-from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..exceptions import DecodeError, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 if TYPE_CHECKING:
@@ -21,10 +26,27 @@ class CodedConstParameter(Parameter):
     diag_coded_type: DiagCodedType
     coded_value: AtomicOdxType
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "CodedConstParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
+        diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, doc_frags)
+        coded_value = diag_coded_type.base_data_type.from_string(
+            odxrequire(et_element.findtext("CODED-VALUE")))
+
+        return CodedConstParameter(
+            diag_coded_type=diag_coded_type, coded_value=coded_value, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "CODED-CONST"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -32,12 +54,15 @@ class CodedConstParameter(Parameter):
 
         return result
 
+    @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)
 
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
 
@@ -46,13 +71,16 @@ class CodedConstParameter(Parameter):
         return self.diag_coded_type.base_data_type
 
     @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:
         if (self.short_name in encode_state.parameter_values and
                 encode_state.parameter_values[self.short_name] != self.coded_value):
@@ -62,13 +90,8 @@ class CodedConstParameter(Parameter):
         return self.diag_coded_type.convert_internal_to_bytes(
             self.coded_value, encode_state=encode_state, bit_position=bit_position_int)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
-        # Extract coded values
-        orig_cursor_pos = 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
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         coded_val = self.diag_coded_type.decode_from_pdu(decode_state)
 
         # Check if the coded value in the message is correct.
@@ -83,8 +106,6 @@ class CodedConstParameter(Parameter):
                 stacklevel=1,
             )
 
-        decode_state.cursor_byte_position = max(orig_cursor_pos, decode_state.cursor_byte_position)
-
         return coded_val
 
     @property

odxtools/parameters/createanyparameter.py

@@ -2,13 +2,9 @@
 from typing import List
 from xml.etree import ElementTree
 
-from ..createanydiagcodedtype import create_any_diag_coded_type_from_et
-from ..createsdgs import create_sdgs_from_et
-from ..element import NamedElement
-from ..exceptions import odxrequire
+from ..exceptions import odxraise
 from ..globals import xsi
-from ..odxlink import OdxDocFragment, OdxLinkId, OdxLinkRef
-from ..utils import dataclass_fields_asdict
+from ..odxlink import OdxDocFragment
 from .codedconstparameter import CodedConstParameter
 from .dynamicparameter import DynamicParameter
 from .lengthkeyparameter import LengthKeyParameter
@@ -27,203 +23,33 @@ from .valueparameter import ValueParameter
 def create_any_parameter_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")
-    byte_position_str = et_element.findtext("BYTE-POSITION")
-    byte_position = int(byte_position_str) if byte_position_str is not None else None
-    bit_position_str = et_element.findtext("BIT-POSITION")
-    bit_position = None
-    if bit_position_str is not None:
-        bit_position = int(bit_position_str)
     parameter_type = et_element.get(f"{xsi}type")
 
-    sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
-
     # Which attributes are set depends on the type of the parameter.
-    if parameter_type in ["VALUE", "PHYS-CONST", "SYSTEM", "LENGTH-KEY"]:
-        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"))
-
-        if dop_ref is None and dop_snref is None:
-            raise ValueError(
-                f"A parameter of type {parameter_type} must reference a DOP! {dop_ref}, {dop_snref}"
-            )
-
     if parameter_type == "VALUE":
-        physical_default_value_raw = (
-            et_element.findtext("PHYSICAL-DEFAULT-VALUE")
-            if et_element.find("PHYSICAL-DEFAULT-VALUE") is not None else None)
-
-        return ValueParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            physical_default_value_raw=physical_default_value_raw,
-            sdgs=sdgs,
-            **kwargs)
-
-    elif parameter_type == "PHYS-CONST":
-        physical_constant_value = odxrequire(et_element.findtext("PHYS-CONSTANT-VALUE"))
-
-        return PhysicalConstantParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            physical_constant_value_raw=physical_constant_value,
-            sdgs=sdgs,
-            **kwargs)
-
+        return ValueParameter.from_et(et_element, doc_frags)
     elif parameter_type == "CODED-CONST":
-        dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
-        diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, doc_frags)
-        coded_value = diag_coded_type.base_data_type.from_string(
-            odxrequire(et_element.findtext("CODED-VALUE")))
-
-        return CodedConstParameter(
-            semantic=semantic,
-            diag_coded_type=diag_coded_type,
-            coded_value=coded_value,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return CodedConstParameter.from_et(et_element, doc_frags)
+    elif parameter_type == "PHYS-CONST":
+        return PhysicalConstantParameter.from_et(et_element, doc_frags)
+    elif parameter_type == "SYSTEM":
+        return SystemParameter.from_et(et_element, doc_frags)
+    elif parameter_type == "LENGTH-KEY":
+        return LengthKeyParameter.from_et(et_element, doc_frags)
     elif parameter_type == "NRC-CONST":
-        diag_coded_type = create_any_diag_coded_type_from_et(
-            odxrequire(et_element.find("DIAG-CODED-TYPE")), doc_frags)
-        coded_values = [
-            diag_coded_type.base_data_type.from_string(odxrequire(val.text))
-            for val in et_element.iterfind("CODED-VALUES/CODED-VALUE")
-        ]
-
-        return NrcConstParameter(
-            semantic=semantic,
-            diag_coded_type=diag_coded_type,
-            coded_values=coded_values,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return NrcConstParameter.from_et(et_element, doc_frags)
     elif parameter_type == "RESERVED":
-        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-
-        return ReservedParameter(
-            bit_length=bit_length,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return ReservedParameter.from_et(et_element, doc_frags)
     elif parameter_type == "MATCHING-REQUEST-PARAM":
-        byte_length = int(odxrequire(et_element.findtext("BYTE-LENGTH")))
-        request_byte_pos = int(odxrequire(et_element.findtext("REQUEST-BYTE-POS")))
-
-        return MatchingRequestParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            request_byte_position=request_byte_pos,
-            byte_length=byte_length,
-            sdgs=sdgs,
-            **kwargs)
-
-    elif parameter_type == "SYSTEM":
-        sysparam = odxrequire(et_element.get("SYSPARAM"))
-
-        return SystemParameter(
-            sysparam=sysparam,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            sdgs=sdgs,
-            **kwargs)
-
-    elif parameter_type == "LENGTH-KEY":
-        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
-
-        return LengthKeyParameter(
-            odx_id=odx_id,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            sdgs=sdgs,
-            **kwargs)
-
+        return MatchingRequestParameter.from_et(et_element, doc_frags)
     elif parameter_type == "DYNAMIC":
-
-        return DynamicParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return DynamicParameter.from_et(et_element, doc_frags)
     elif parameter_type == "TABLE-STRUCT":
-        key_ref = OdxLinkRef.from_et(et_element.find("TABLE-KEY-REF"), doc_frags)
-        if (key_snref_elem := et_element.find("TABLE-KEY-SNREF")) is not None:
-            key_snref = odxrequire(key_snref_elem.get("SHORT-NAME"))
-        else:
-            key_snref = None
-
-        return TableStructParameter(
-            table_key_ref=key_ref,
-            table_key_snref=key_snref,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return TableStructParameter.from_et(et_element, doc_frags)
     elif parameter_type == "TABLE-KEY":
-
-        parameter_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
-        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags)
-        if (table_snref_elem := et_element.find("TABLE-SNREF")) is not None:
-            table_snref = odxrequire(table_snref_elem.get("SHORT-NAME"))
-        else:
-            table_snref = None
-
-        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags)
-        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"))
-        else:
-            table_row_snref = None
-
-        return TableKeyParameter(
-            table_ref=table_ref,
-            table_snref=table_snref,
-            table_row_snref=table_row_snref,
-            table_row_ref=table_row_ref,
-            odx_id=parameter_id,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            semantic=semantic,
-            sdgs=sdgs,
-            **kwargs)
-
+        return TableKeyParameter.from_et(et_element, doc_frags)
     elif parameter_type == "TABLE-ENTRY":
-        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,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            semantic=semantic,
-            sdgs=sdgs,
-            **kwargs)
+        return TableEntryParameter.from_et(et_element, doc_frags)
 
-    raise NotImplementedError(f"I don't know about parameters of type {parameter_type}")
+    odxraise(f"I don't know about parameters of type {parameter_type}", NotImplementedError)
+    return Parameter.from_et(et_element, doc_frags)

odxtools/parameters/dynamicparameter.py

@@ -1,29 +1,49 @@
 # 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 ..odxlink import OdxDocFragment
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
 @dataclass
 class DynamicParameter(Parameter):
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynamicParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        return DynamicParameter(**kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "DYNAMIC"
 
     @property
+    @override
     def is_required(self) -> bool:
         raise NotImplementedError(".is_required for a DynamicParameter")
 
     @property
+    @override
     def is_settable(self) -> bool:
         raise NotImplementedError(".is_settable for a DynamicParameter")
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         raise NotImplementedError("Encoding a DynamicParameter is not implemented yet.")
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         raise NotImplementedError("Decoding a DynamicParameter is not implemented yet.")

odxtools/parameters/lengthkeyparameter.py

@@ -1,12 +1,16 @@
 # 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 ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import 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
 
@@ -27,10 +31,23 @@ class LengthKeyParameter(ParameterWithDOP):
 
     odx_id: OdxLinkId
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "LengthKeyParameter":
+
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+
+        return LengthKeyParameter(odx_id=odx_id, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "LENGTH-KEY"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -38,23 +55,28 @@ class LengthKeyParameter(ParameterWithDOP):
 
         return result
 
+    @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)
 
     @property
+    @override
     def is_required(self) -> bool:
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         # length keys can be explicitly set, but they do not need to
         # be because they can be implicitly determined by the length
         # of the corresponding field
         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)
 
@@ -63,11 +85,13 @@ class LengthKeyParameter(ParameterWithDOP):
                          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)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        phys_val = super().decode_from_pdu(decode_state)
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        phys_val = super()._decode_positioned_from_pdu(decode_state)
 
         if not isinstance(phys_val, int):
             odxraise(f"The pysical type of length keys must be an integer, "

odxtools/parameters/matchingrequestparameter.py

@@ -1,11 +1,16 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import EncodeError
+from ..exceptions import EncodeError, odxrequire
+from ..odxlink import OdxDocFragment
 from ..odxtypes import DataType, ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
@@ -14,21 +19,39 @@ class MatchingRequestParameter(Parameter):
     request_byte_position: int
     byte_length: int
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "MatchingRequestParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        request_byte_position = int(odxrequire(et_element.findtext("REQUEST-BYTE-POS")))
+        byte_length = int(odxrequire(et_element.findtext("BYTE-LENGTH")))
+
+        return MatchingRequestParameter(
+            request_byte_position=request_byte_position, byte_length=byte_length, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "MATCHING-REQUEST-PARAM"
 
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         return 8 * self.byte_length
 
     @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:
         if not encode_state.triggering_request:
             raise EncodeError(f"Parameter '{self.short_name}' is of matching request type,"
@@ -37,16 +60,11 @@ class MatchingRequestParameter(Parameter):
                                                .request_byte_position:self.request_byte_position +
                                                self.byte_length]
 
-    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:
         result = decode_state.extract_atomic_value(
             bit_length=self.byte_length * 8,
             base_data_type=DataType.A_UINT32,
             is_highlow_byte_order=False)
 
-        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
-
         return result

odxtools/parameters/nrcconstparameter.py

@@ -2,13 +2,18 @@
 import warnings
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from xml.etree import ElementTree
 
+from typing_extensions import override
+
+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
-from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..exceptions import DecodeError, EncodeError, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 if TYPE_CHECKING:
@@ -29,10 +34,29 @@ class NrcConstParameter(Parameter):
     diag_coded_type: DiagCodedType
     coded_values: List[AtomicOdxType]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "NrcConstParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
+        diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, doc_frags)
+        coded_values = [
+            diag_coded_type.base_data_type.from_string(odxrequire(val.text))
+            for val in et_element.iterfind("CODED-VALUES/CODED-VALUE")
+        ]
+
+        return NrcConstParameter(
+            diag_coded_type=diag_coded_type, coded_values=coded_values, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "NRC-CONST"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -40,12 +64,15 @@ class NrcConstParameter(Parameter):
 
         return result
 
+    @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)
 
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
 
@@ -54,13 +81,16 @@ class NrcConstParameter(Parameter):
         return self.diag_coded_type.base_data_type
 
     @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:
         if self.short_name in encode_state.parameter_values:
             if encode_state.parameter_values[self.short_name] not in self.coded_values:
@@ -77,14 +107,9 @@ class NrcConstParameter(Parameter):
         return self.diag_coded_type.convert_internal_to_bytes(
             coded_value, encode_state, bit_position=bit_position_int)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
-        orig_cursor = decode_state.cursor_byte_position
-        if self.byte_position is not None:
-            # Update cursor position
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
-
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         # Extract coded values
-        decode_state.cursor_bit_position = self.bit_position or 0
         coded_value = self.diag_coded_type.decode_from_pdu(decode_state)
 
         # Check if the coded value in the message is correct.
@@ -99,8 +124,6 @@ class NrcConstParameter(Parameter):
                 stacklevel=1,
             )
 
-        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
-
         return coded_value
 
     def get_description_of_valid_values(self) -> str: