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

odxtools/multiplexer.py

@@ -3,6 +3,8 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .complexdop import ComplexDop
 from .decodestate import DecodeState
 from .encodestate import EncodeState
@@ -34,6 +36,7 @@ class Multiplexer(ComplexDop):
     is_visible_raw: Optional[bool]
 
     @staticmethod
+    @override
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Multiplexer":
         """Reads a Multiplexer from Diag Layer."""
         base_obj = ComplexDop.from_et(et_element, doc_frags)
@@ -67,50 +70,63 @@ class Multiplexer(ComplexDop):
 
     def _get_case_limits(self, case: MultiplexerCase) -> Tuple[AtomicOdxType, AtomicOdxType]:
         key_type = self.switch_key.dop.physical_type.base_data_type
-        lower_limit = key_type.make_from(case.lower_limit)
-        upper_limit = key_type.make_from(case.upper_limit)
+        lower_limit = key_type.make_from(case.lower_limit.value)
+        upper_limit = key_type.make_from(case.upper_limit.value)
         if not isinstance(lower_limit, type(upper_limit)) and not isinstance(
                 upper_limit, type(lower_limit)):
             odxraise("Upper and lower bounds of limits must compareable")
         return lower_limit, upper_limit
 
-    def convert_physical_to_bytes(self,
-                                  physical_value: ParameterValue,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
+    @override
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
 
-        if bit_position != 0:
-            raise EncodeError("Multiplexer must be aligned, i.e. bit_position=0, but "
-                              f"{self.short_name} was passed the bit position {bit_position}")
+        if encode_state.cursor_bit_position != 0:
+            raise EncodeError(f"Multiplexer must be aligned, i.e. bit_position=0, but "
+                              f"{self.short_name} was passed the bit position "
+                              f"{encode_state.cursor_bit_position}")
 
         if not isinstance(physical_value, dict) or len(physical_value) != 1:
             raise EncodeError("""Multiplexer should be defined as a dict
             with only one key equal to the desired case""")
 
+        orig_origin = encode_state.origin_byte_position
+        orig_cursor = encode_state.cursor_byte_position
+
+        encode_state.origin_byte_position = encode_state.cursor_byte_position
+
         case_name, case_value = next(iter(physical_value.items()))
-        case_pos = self.byte_position
 
         for mux_case in self.cases or []:
             if mux_case.short_name == case_name:
-                if mux_case._structure:
-                    case_bytes = mux_case._structure.convert_physical_to_bytes(
-                        case_value, encode_state, 0)
-                else:
-                    case_bytes = b''
-
                 key_value, _ = self._get_case_limits(mux_case)
-                key_bytes = self.switch_key.dop.convert_physical_to_bytes(
-                    key_value, encode_state, bit_position=self.switch_key.bit_position or 0)
 
-                mux_len = max(len(key_bytes), len(case_bytes) + case_pos)
-                mux_bytes = bytearray(mux_len)
-                mux_bytes[:len(key_bytes)] = key_bytes
-                mux_bytes[case_pos:case_pos + len(case_bytes)] = case_bytes
+                if self.switch_key.byte_position is not None:
+                    encode_state.cursor_byte_position = encode_state.origin_byte_position + self.switch_key.byte_position
+                encode_state.cursor_bit_position = self.switch_key.bit_position or 0
+
+                self.switch_key.dop.encode_into_pdu(
+                    physical_value=key_value, encode_state=encode_state)
+
+                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 = 0
+
+                if mux_case._structure is None:
+                    odxraise(f"Multiplexer case '{mux_case.short_name}' does not "
+                             f"reference a structure.")
+                    return
+
+                mux_case.structure.encode_into_pdu(
+                    physical_value=key_value, encode_state=encode_state)
 
-                return bytes(mux_bytes)
+                encode_state.origin_byte_position = orig_origin
+                encode_state.cursor_byte_position = max(orig_cursor,
+                                                        encode_state.cursor_byte_position)
+                return
 
         raise EncodeError(f"The case {case_name} is not found in Multiplexer {self.short_name}")
 
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
 
         # multiplexers are structures and thus the origin position
@@ -152,6 +168,7 @@ class Multiplexer(ComplexDop):
 
         return mux_value
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
@@ -161,6 +178,7 @@ class Multiplexer(ComplexDop):
 
         return odxlinks
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
@@ -172,6 +190,7 @@ class Multiplexer(ComplexDop):
             mux_case._mux_case_resolve_odxlinks(
                 odxlinks, key_physical_type=self.switch_key.dop.physical_type.base_data_type)
 
+    @override
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 

odxtools/multiplexercase.py

@@ -7,7 +7,7 @@ from .basicstructure import BasicStructure
 from .compumethods.limit import Limit
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType, DataType
 from .utils import dataclass_fields_asdict
 
@@ -60,7 +60,7 @@ class MultiplexerCase(NamedElement):
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         raise RuntimeError("Calling MultiplexerCase._resolve_odxlinks() is not allowed. "
-                           "Use ._mux_case_resolve_odxlinks()().")
+                           "Use ._mux_case_resolve_odxlinks().")
 
     def _mux_case_resolve_odxlinks(self, odxlinks: OdxLinkDatabase, *,
                                    key_physical_type: DataType) -> None:
@@ -73,7 +73,7 @@ class MultiplexerCase(NamedElement):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         if self.structure_snref:
             ddds = diag_layer.diag_data_dictionary_spec
-            self._structure = odxrequire(ddds.structures.get(self.structure_snref))
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
 
     def applies(self, value: AtomicOdxType) -> bool:
         return self.lower_limit.complies_to_lower(value) \

odxtools/multiplexerdefaultcase.py

@@ -6,7 +6,7 @@ from xml.etree import ElementTree
 from .basicstructure import BasicStructure
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -20,7 +20,7 @@ class MultiplexerDefaultCase(NamedElement):
     structure_snref: Optional[str]
 
     def __post_init__(self) -> None:
-        self._structure: Optional[BasicStructure] = None
+        self._structure: BasicStructure
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -46,4 +46,8 @@ class MultiplexerDefaultCase(NamedElement):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         if self.structure_snref:
             ddds = diag_layer.diag_data_dictionary_spec
-            self._structure = odxrequire(ddds.structures.get(self.structure_snref))
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
+
+    @property
+    def structure(self) -> BasicStructure:
+        return self._structure

odxtools/nameditemlist.py

@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: MIT
 import abc
+from copy import deepcopy
 from keyword import iskeyword
 from typing import (Any, Collection, Dict, Iterable, List, Optional, Protocol, SupportsIndex, Tuple,
                     TypeVar, Union, cast, overload, runtime_checkable)
@@ -175,6 +176,19 @@ class ItemAttributeList(List[T]):
     def __repr__(self) -> str:
         return f"{type(self).__name__}([{', '.join([repr(x) for x in self])}])"
 
+    def __copy__(self) -> Any:
+        return self.__class__(list(self))
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+        cls = self.__class__
+        result = cls.__new__(cls)
+        memo[id(self)] = result
+        result._item_dict = {}
+        for x in self:
+            result.append(deepcopy(x, memo))
+
+        return result
+
 
 class NamedItemList(ItemAttributeList[T]):
 

odxtools/odxlink.py

@@ -1,10 +1,11 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Type, TypeVar, overload
+from typing import Any, Dict, Iterable, List, Optional, Type, TypeVar, overload
 from xml.etree import ElementTree
 
-from .exceptions import OdxWarning, odxassert
+from .exceptions import OdxWarning, odxassert, odxraise
+from .nameditemlist import OdxNamed, TNamed
 
 
 @dataclass(frozen=True)
@@ -210,8 +211,10 @@ class OdxLinkDatabase:
 
                 return obj
 
-        raise KeyError(f"ODXLINK reference {ref} could not be resolved for any "
-                       f"of the document fragments {ref.ref_docs}")
+        odxraise(
+            f"ODXLINK reference {ref} could not be resolved for any "
+            f"of the document fragments {ref.ref_docs}", KeyError)
+        return None
 
     @overload
     def resolve_lenient(self, ref: OdxLinkRef, expected_type: None = None) -> Any:
@@ -270,3 +273,34 @@ class OdxLinkDatabase:
                     self._db[doc_frag] = {}
 
                 self._db[doc_frag][odx_id] = obj
+
+
+@overload
+def resolve_snref(target_short_name: str,
+                  items: Iterable[OdxNamed],
+                  expected_type: None = None) -> Any:
+    """Resolve a short name reference given a sequence of candidate objects"""
+    ...
+
+
+@overload
+def resolve_snref(target_short_name: str, items: Iterable[OdxNamed],
+                  expected_type: Type[TNamed]) -> TNamed:
+    ...
+
+
+def resolve_snref(target_short_name: str,
+                  items: Iterable[OdxNamed],
+                  expected_type: Any = None) -> Any:
+    candidates = [x for x in items if x.short_name == target_short_name]
+
+    if not candidates:
+        odxraise(f"Cannot resolve short name reference to '{target_short_name}'")
+        return None
+    elif len(candidates) > 1:
+        odxraise(f"Cannot uniquely resolve short name reference to '{target_short_name}'")
+    elif expected_type is not None and not isinstance(candidates[0], expected_type):
+        odxraise(f"Reference '{target_short_name}' points to a {type(candidates[0]).__name__}"
+                 f"object while expecting {expected_type.__name__}")
+
+    return candidates[0]

odxtools/odxtypes.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type, Union, overload
+from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, Optional, Tuple, Type, Union,
+                    overload)
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxraise, odxrequire
@@ -28,7 +29,7 @@ ParameterDict = Dict[str, Union["Parameter", "ParameterDict"]]
 # multiple items, so this can be a list of objects.
 TableStructParameterValue = Tuple[str, "ParameterValue"]
 ParameterValue = Union[AtomicOdxType, "ParameterValueDict", TableStructParameterValue,
-                       List["ParameterValue"], "DiagnosticTroubleCode"]
+                       Iterable["ParameterValue"], "DiagnosticTroubleCode"]
 ParameterValueDict = Dict[str, ParameterValue]
 
 
@@ -154,6 +155,19 @@ def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
              f"and {type(b).__name__}")
 
 
+# format specifiers for the data type using the bitstruct module
+_BITSTRUCT_FORMAT_LETTER_MAP__ = {
+    "A_INT32": "s",
+    "A_UINT32": "u",
+    "A_FLOAT32": "f",
+    "A_FLOAT64": "f",
+    "A_BYTEFIELD": "r",
+    "A_UNICODE2STRING": "r",  # UTF-16 strings must be converted explicitly
+    "A_ASCIISTRING": "r",
+    "A_UTF8STRING": "r",
+}
+
+
 class DataType(Enum):
     """Types for the physical and internal value.
 
@@ -181,6 +195,10 @@ class DataType(Enum):
     def python_type(self) -> Type[AtomicOdxType]:
         return _ODX_TYPE_TO_PYTHON_TYPE[self.value]
 
+    @property
+    def bitstruct_format_letter(self) -> str:
+        return _BITSTRUCT_FORMAT_LETTER_MAP__[self.value]
+
     def from_string(self, value: str) -> AtomicOdxType:
         return _PARSE_ODX_TYPE[self.value](value)
 

odxtools/parameterinfo.py

@@ -1,105 +1,191 @@
 # SPDX-License-Identifier: MIT
-import re
-from typing import Iterable, Union
+import textwrap
+from io import StringIO
+from typing import Iterable
 
 from .compumethods.identicalcompumethod import IdenticalCompuMethod
 from .compumethods.limit import IntervalType
 from .compumethods.linearcompumethod import LinearCompuMethod
 from .compumethods.texttablecompumethod import TexttableCompuMethod
 from .dataobjectproperty import DataObjectProperty
+from .dtcdop import DtcDop
+from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
+from .exceptions import odxrequire
+from .multiplexer import Multiplexer
 from .odxtypes import DataType
 from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.matchingrequestparameter import MatchingRequestParameter
+from .parameters.nrcconstparameter import NrcConstParameter
 from .parameters.parameter import Parameter
 from .parameters.parameterwithdop import ParameterWithDOP
 from .parameters.reservedparameter import ReservedParameter
+from .parameters.tablekeyparameter import TableKeyParameter
+from .parameters.tablestructparameter import TableStructParameter
+from .paramlengthinfotype import ParamLengthInfoType
+from .staticfield import StaticField
 
 
-def parameter_info(param_list: Iterable[Union[Parameter, EndOfPduField]]) -> str:
-    result = ""
+def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False) -> str:
+    q = "'" if quoted_names else ""
+    of = StringIO()
     for param in param_list:
         if isinstance(param, CodedConstParameter):
-            result += f"{param.short_name} : const = {param._coded_value_str}\n"
+            of.write(f"{q}{param.short_name}{q}: const = {param._coded_value_str}\n")
             continue
         elif isinstance(param, MatchingRequestParameter):
-            result += f"{param.short_name} : <matches request>\n"
+            of.write(f"{q}{param.short_name}{q}: <matches request>\n")
+            continue
+        elif isinstance(param, NrcConstParameter):
+            of.write(f"{q}{param.short_name}{q}: const; choices = {param.coded_values}\n")
             continue
         elif isinstance(param, ReservedParameter):
-            result += f"{param.short_name} : <reserved>\n"
+            of.write(f"{q}{param.short_name}{q}: <reserved>\n")
+            continue
+        elif isinstance(param, TableKeyParameter):
+            of.write(
+                f"{q}{param.short_name}{q}: <optional> table key; table = '{param.table.short_name}'; choices:\n"
+            )
+            for tr in param.table.table_rows:
+                of.write(f"  '{tr.short_name}',\n")
+
+            continue
+        elif isinstance(param, TableStructParameter):
+            of.write(
+                f"{q}{param.short_name}{q}: table struct; key = '{param.table_key.short_name}'; choices:\n"
+            )
+            for tr in param.table_key.table.table_rows:
+                of.write(f"  ('{tr.short_name}',\n")
+                of.write(f"   {{\n")
+                of.write(
+                    textwrap.indent(
+                        parameter_info(odxrequire(tr.structure).parameters, True), "    "))
+                of.write(f"   }}),\n")
+
             continue
         elif not isinstance(param, ParameterWithDOP):
-            result += f"{param.short_name} : <unhandled parameter type>\n"
+            of.write(
+                f"{q}{param.short_name}{q}: <unhandled parameter type '{type(param).__name__}'>\n")
             continue
 
         dop = param.dop
-
         if isinstance(dop, EndOfPduField):
-            result += f"{param.short_name} : <optional> list({{\n"
-            tmp = parameter_info(dop.structure.parameters).strip()
-            tmp = re.sub("^", "  ", tmp)
-            result += tmp + "\n"
-            result += f"}})\n"
+            of.write(f"{q}{param.short_name}{q}: list({{\n")
+            of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
+            of.write(f"}})\n")
+            continue
+        elif isinstance(dop, StaticField):
+            of.write(f"{q}{param.short_name}{q}: length={dop.fixed_number_of_items}; list({{\n")
+            of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
+            of.write(f"}})\n")
+            continue
+        elif isinstance(dop, DynamicLengthField):
+            of.write(f"{q}{param.short_name}{q}: list({{\n")
+            of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
+            of.write(f"}})\n")
+            continue
+        elif isinstance(dop, ParamLengthInfoType):
+            of.write(f"{q}{param.short_name}{q}: ")
+            of.write("<optional> ")
+            of.write(f"int; length_key='{dop.length_key.short_name}'\n")
+            continue
+        elif isinstance(dop, DtcDop):
+            of.write(f"{q}{param.short_name}{q}: ")
+            of.write(f"DTC; choices:\n")
+            for dtc in dop.dtcs:
+                if dtc.display_trouble_code is not None:
+                    dtc_desc = dtc.text and f"; \"{dtc.text}\""
+                    of.write(
+                        f"  '{dtc.display_trouble_code}' (0x{dtc.trouble_code:06x}{dtc_desc})\n")
+                else:
+                    dtc_desc = dtc.text and f" (\"{dtc.text}\")"
+                    of.write(f"  0x{dtc.trouble_code:06x}{dtc_desc}\n")
+            continue
+        elif isinstance(dop, Multiplexer):
+            of.write(f"{q}{param.short_name}{q}: ")
+            if dop.default_case is not None:
+                of.write(f"<optional>")
+            of.write(f"multiplexer; choices:\n")
+            for mux_case in dop.cases:
+                of.write(f"  ({repr(mux_case.short_name)}, {{\n")
+                of.write(
+                    textwrap.indent(parameter_info(mux_case.structure.parameters, True), "    "))
+                of.write(f"   }})\n")
             continue
 
-        result += f"{param.short_name}"
+        of.write(f"{q}{param.short_name}{q}")
 
         if dop is None:
-            result += ": <no DOP>\n"
+            of.write(": <no DOP>\n")
             continue
         elif not isinstance(dop, DataObjectProperty):
-            result += ": <unhandled DOP>\n"
+            of.write(f": <unhandled DOP '{type(dop).__name__}'>\n")
             continue
 
         if (cm := dop.compu_method) is None:
-            result += ": <no compu method>\n"
+            of.write(": <no compu method>\n")
             continue
 
         if isinstance(cm, TexttableCompuMethod):
-            result += f": enum; choices:\n"
+            of.write(f": enum; choices:\n")
             for scale in cm.internal_to_phys:
-                result += f"  '{str(scale.compu_const)}'\n"
+                val_str = ""
+                if scale.lower_limit is not None:
+                    val_str = f"({repr(scale.lower_limit.value)})"
+                of.write(f"  {repr(scale.compu_const)}{val_str}\n")
 
         elif isinstance(cm, IdenticalCompuMethod):
             bdt = dop.physical_type.base_data_type
             if bdt in (DataType.A_UTF8STRING, DataType.A_UNICODE2STRING, DataType.A_ASCIISTRING):
-                result += f": str"
-            elif bdt in (DataType.A_BYTEFIELD,):
-                result += f": bytes"
+                of.write(f": str")
+            elif bdt == DataType.A_BYTEFIELD:
+                of.write(f": bytes")
             elif bdt.name.startswith("A_FLOAT"):
-                result += f": float"
+                of.write(f": float")
             elif bdt.name.startswith("A_UINT"):
-                result += f": uint"
+                of.write(f": uint")
             elif bdt.name.startswith("A_INT"):
-                result += f": int"
+                of.write(f": int")
             else:
-                result += f": <unknown type>"
-
-            if (bl := dop.get_static_bit_length()) is not None:
-                result += f"{bl}"
+                of.write(f": <unknown type {{ bdt.name }}>")
 
-            result += "\n"
+            of.write("\n")
 
         elif isinstance(cm, LinearCompuMethod):
-            result += f": float\n"
+            bdt = dop.physical_type.base_data_type
+            if bdt in (DataType.A_UTF8STRING, DataType.A_UNICODE2STRING, DataType.A_ASCIISTRING):
+                of.write(f": str")
+            elif bdt in (DataType.A_BYTEFIELD,):
+                of.write(f": bytes")
+            elif bdt.name.startswith("A_FLOAT"):
+                of.write(f": float")
+            elif bdt.name.startswith("A_UINT"):
+                of.write(f": uint")
+            elif bdt.name.startswith("A_INT"):
+                of.write(f": int")
+            else:
+                of.write(f": <unknown type>")
+
             ll = cm.physical_lower_limit
             ul = cm.physical_upper_limit
-            if ll is None:
-                ll_str = "(inf"
+            if ll is None or ll.interval_type == IntervalType.INFINITE:
+                ll_str = "(-inf"
             else:
-                ll_delim = '[' if ll.interval_type == IntervalType.CLOSED else '('
+                ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
                 ll_str = f"{ll_delim}{ll._value!r}"
 
-            if ul is None:
+            if ul is None or ul.interval_type == IntervalType.INFINITE:
                 ul_str = "inf)"
             else:
-                ul_delim = ']' if ul.interval_type == IntervalType.CLOSED else ')'
+                ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
                 ul_str = f"{ul._value!r}{ul_delim}"
-            result += f" range: {ll_str}, {ul_str}\n"
+            of.write(f"; range: {ll_str}, {ul_str}")
 
             unit = dop.unit
             unit_str = unit.display_name if unit is not None else None
             if unit_str is not None:
-                result += f" unit: {unit_str}\n"
+                of.write(f"; unit: {unit_str}")
+
+            of.write("\n")
 
-    return result
+    return of.getvalue()

odxtools/parameters/codedconstparameter.py

@@ -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, 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
 
@@ -59,8 +59,9 @@ class CodedConstParameter(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]:
@@ -81,20 +82,23 @@ class CodedConstParameter(Parameter):
         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):
-            raise TypeError(f"The parameter '{self.short_name}' is constant {self._coded_value_str}"
-                            " and thus can not be changed.")
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return self.diag_coded_type.convert_internal_to_bytes(
-            self.coded_value, encode_state=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.coded_value:
+            odxraise(
+                f"Value for constant parameter `{self.short_name}` name can "
+                f"only be specified as {self.coded_value!r} (is: {physical_value!r})", EncodeError)
+
+        internal_value = self.coded_value
+
+        self.diag_coded_type.encode_into_pdu(
+            internal_value=internal_value, encode_state=encode_state)
 
     @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.
+        # Check if the coded value contained by the message is correct.
         if self.coded_value != coded_val:
             warnings.warn(
                 f"Coded constant parameter does not match! "

odxtools/parameters/dynamicparameter.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
@@ -41,9 +41,10 @@ class DynamicParameter(Parameter):
         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 _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        raise NotImplementedError("Encoding DynamicParameter is not implemented yet.")
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding a DynamicParameter is not implemented yet.")
+        raise NotImplementedError("Decoding DynamicParameter is not implemented yet.")