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

odxtools/environmentdatadescription.py

@@ -1,36 +1,60 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .complexdop import ComplexDop
+from .dataobjectproperty import DataObjectProperty
 from .decodestate import DecodeState
+from .dtcdop import DtcDop
 from .encodestate import EncodeState
 from .environmentdata import EnvironmentData
-from .exceptions import DecodeError, EncodeError, odxrequire
+from .exceptions import odxraise, odxrequire
+from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .odxtypes import ParameterValue
+from .odxtypes import DataType, ParameterValue, ParameterValueDict
+from .parameters.codedconstparameter import CodedConstParameter
+from .parameters.parameter import Parameter
+from .parameters.parameterwithdop import ParameterWithDOP
+from .parameters.physicalconstantparameter import PhysicalConstantParameter
+from .parameters.valueparameter import ValueParameter
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class EnvironmentDataDescription(ComplexDop):
-    """This class represents Environment Data Description, which is a complex DOP
-    that is used to define the interpretation of environment data."""
+    """This class represents environment data descriptions
+
+    An environment data description provides a list of all environment
+    data objects that are potentially applicable to decode a given
+    response. (If a given environment data object is applicable
+    depends on the value of the DtcDOP that is associated with it.)
+
+    """
+
+    param_snref: Optional[str]
+    param_snpathref: Optional[str]
 
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not
     # present
-    env_datas: List[EnvironmentData]
+    env_datas: NamedItemList[EnvironmentData]
     env_data_refs: List[OdxLinkRef]
-    param_snref: Optional[str]
-    param_snpathref: Optional[str]
 
-    def __post_init__(self) -> None:
-        self.bit_length = None
+    @property
+    def param(self) -> Parameter:
+        # the parameter referenced via SNREF cannot be resolved here
+        # because the relevant list of parameters depends on the
+        # concrete codec object processed, whilst an environment data
+        # description object can be featured in an arbitrary number of
+        # responses. Instead, lookup of the appropriate parameter is
+        # done within the encode and decode methods.
+        odxraise("The parameter of ENV-DATA-DESC objects cannot be resolved "
+                 "because it depends on the context")
+        return cast(None, Parameter)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -44,16 +68,20 @@ class EnvironmentDataDescription(ComplexDop):
         param_snpathref = None
         if (param_snpathref_elem := et_element.find("PARAM-SNPATHREF")) is not None:
             param_snpathref = odxrequire(param_snpathref_elem.get("SHORT-NAME-PATH"))
+
+        # ODX 2.0 mandates ENV-DATA-DESC to contain a list of
+        # ENV-DATAS and no ENV-DATA-REFS while for ODX 2.2 the
+        # situation is reversed. This means that we will create one
+        # empty and one non-empty list here. (Which is which depends
+        # on the version of the standard used by the file.)
         env_data_refs = [
             odxrequire(OdxLinkRef.from_et(env_data_ref, doc_frags))
             for env_data_ref in et_element.iterfind("ENV-DATA-REFS/ENV-DATA-REF")
         ]
-
-        # ODX 2.0.0 says ENV-DATA-DESC could contain a list of ENV-DATAS
-        env_datas = [
+        env_datas = NamedItemList([
             EnvironmentData.from_et(env_data_elem, doc_frags)
             for env_data_elem in et_element.iterfind("ENV-DATAS/ENV-DATA")
-        ]
+        ])
 
         return EnvironmentDataDescription(
             param_snref=param_snref,
@@ -65,8 +93,9 @@ class EnvironmentDataDescription(ComplexDop):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
-        for ed in self.env_datas:
-            odxlinks.update(ed._build_odxlinks())
+        if not self.env_data_refs:
+            for ed in self.env_datas:
+                odxlinks.update(ed._build_odxlinks())
 
         return odxlinks
 
@@ -74,33 +103,166 @@ class EnvironmentDataDescription(ComplexDop):
         # ODX 2.0 specifies environment data objects here, ODX 2.2
         # uses references
         if self.env_data_refs:
-            self.env_datas = [odxlinks.resolve(x) for x in self.env_data_refs]
+            self.env_datas = NamedItemList([odxlinks.resolve(x) for x in self.env_data_refs])
         else:
             for ed in self.env_datas:
                 ed._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         # ODX 2.0 specifies environment data objects here, ODX 2.2
         # uses references
         if self.env_data_refs:
             for ed in self.env_datas:
-                ed._resolve_snrefs(diag_layer)
-
-    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
-        """Convert the physical value into bytes.
+                ed._resolve_snrefs(context)
 
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an EncodeError exception.
+    @override
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        """Convert a physical value into bytes and emplace them into a PDU.
         """
-        raise EncodeError("EnvironmentDataDescription DOPs cannot be encoded or decoded")
 
-    def convert_bytes_to_physical(self,
-                                  decode_state: DecodeState,
-                                  bit_position: int = 0) -> Tuple[ParameterValue, int]:
-        """Extract the bytes from the PDU and convert them to the physical value.
+        # retrieve the DTC as a numerical value from the referenced
+        # parameter (which must be located somewhere before the
+        # parameter using the environment data description)
+        if self.param_snref is None:
+            odxraise("Specifying the DTC parameter for environment data "
+                     "descriptions via SNPATHREF is not supported yet")
+            return None
+
+        numerical_dtc_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(encode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                numerical_dtc_value = self._get_numerical_dtc_from_parameter(
+                    prev_param, prev_param_value)
+                break
+
+        if numerical_dtc_value is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced parameter.")
+            return
+
+        # deal with the "all value" environment data. This holds
+        # parameters that are common to all DTCs. Be aware that the
+        # specification mandates that there is at most one such
+        # environment data object
+        for env_data in self.env_datas:
+            if env_data.all_value:
+                tmp = encode_state.allow_unknown_parameters
+                encode_state.allow_unknown_parameters = True
+                env_data.encode_into_pdu(physical_value, encode_state)
+                encode_state.allow_unknown_parameters = tmp
+                break
+
+        # find the environment data corresponding to the given trouble
+        # code
+        for env_data in self.env_datas:
+            if numerical_dtc_value in env_data.dtc_values:
+                tmp = encode_state.allow_unknown_parameters
+                encode_state.allow_unknown_parameters = True
+                env_data.encode_into_pdu(physical_value, encode_state)
+                encode_state.allow_unknown_parameters = tmp
+                break
 
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an DecodeError exception.
+    @override
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        """Extract the bytes from a PDU and convert them to a physical value.
         """
-        raise DecodeError("EnvironmentDataDescription DOPs cannot be encoded or decoded")
+
+        # retrieve the DTC as a numerical value from the referenced
+        # parameter (which must be located somewhere before the
+        # parameter using the environment data description)
+        if self.param_snref is None:
+            odxraise("Specifying the DTC parameter for environment data "
+                     "descriptions via SNPATHREF is not supported yet")
+            return None
+
+        numerical_dtc_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(decode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                numerical_dtc_value = self._get_numerical_dtc_from_parameter(
+                    prev_param, prev_param_value)
+                break
+
+        if numerical_dtc_value is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced parameter.")
+            return
+
+        result: ParameterValueDict = {}
+
+        # deal with the "all value" environment data. This holds
+        # parameters that are common to all DTCs. Be aware that the
+        # specification mandates that there is at most one such
+        # environment data object
+        for env_data in self.env_datas:
+            if env_data.all_value:
+                tmp = env_data.decode_from_pdu(decode_state)
+                if not isinstance(tmp, dict):
+                    odxraise()
+                result.update(tmp)
+                break
+
+        # find the environment data corresponding to the given trouble
+        # code
+        for env_data in self.env_datas:
+            if numerical_dtc_value in env_data.dtc_values:
+                tmp = env_data.decode_from_pdu(decode_state)
+                if not isinstance(tmp, dict):
+                    odxraise()
+                result.update(tmp)
+                break
+
+        return result
+
+    def _get_numerical_dtc_from_parameter(self, param: Parameter,
+                                          param_value: Optional[ParameterValue]) -> int:
+        if isinstance(param, ParameterWithDOP):
+            dop = param.dop
+            if not isinstance(dop, (DataObjectProperty, DtcDop)):
+                odxraise(f"The DOP of the parameter referenced by environment data descriptions "
+                         f"must use either be DataObjectProperty or a DtcDop (encountered "
+                         f"{type(param).__name__} for parameter '{self.param.short_name}' "
+                         f"of ENV-DATA-DESC '{self.short_name}')")
+                return 0
+
+            if dop.diag_coded_type.base_data_type != DataType.A_UINT32:
+                odxraise(f"The data type used by the DOP of the parameter referenced "
+                         f"by environment data descriptions must be A_UINT32 "
+                         f"(encountered '{dop.diag_coded_type.base_data_type.value}')")
+
+            if param_value is None:
+                if isinstance(param, ValueParameter):
+                    param_value = param.physical_default_value
+                elif isinstance(param, PhysicalConstantParameter):
+                    param_value = param.physical_constant_value
+                else:
+                    odxraise()  # make mypy happy...
+                    return
+
+            if isinstance(dop, DtcDop):
+                return dop.convert_to_numerical_trouble_code(odxrequire(param_value))
+            elif isinstance(dop, DataObjectProperty):
+                return int(dop.compu_method.convert_physical_to_internal(
+                    param_value))  # type: ignore[arg-type]
+
+            odxraise()  # not reachable...
+
+        elif isinstance(param, CodedConstParameter):
+            if param.diag_coded_type.base_data_type != DataType.A_UINT32:
+                odxraise(f"The data type used by the parameter referenced "
+                         f"by environment data descriptions must be A_UINT32 "
+                         f"(encountered '{param.diag_coded_type.base_data_type.value}')")
+
+                return param.coded_value
+
+            if not isinstance(param.coded_value, int):
+                odxraise()
+
+            return param.coded_value
+
+        else:
+            odxraise(f"The parameter referenced by environment data descriptions "
+                     f"must be a parameter that either specifies a DOP or a constant "
+                     f"(encountered {type(param).__name__} for reference '{self.param_snref}' of "
+                     f"ENV-DATA-DESC '{self.short_name}')")
+            return 0

odxtools/exceptions.py

@@ -9,13 +9,22 @@ class OdxError(Exception):
 
 
 class EncodeError(Warning, OdxError):
-    """Encoding of a message to raw data failed."""
+    """Encoding of a message to raw data failed"""
 
 
 class DecodeError(Warning, OdxError):
     """Decoding raw data failed."""
 
 
+class DecodeMismatch(DecodeError):
+    """Decoding failed because some parameters exhibit an incorrect value
+
+    This is can happen if NRC-CONST or environment data descriptions
+    are present.
+
+    """
+
+
 class OdxWarning(Warning):
     """Any warning that happens during interacting with diagnostic objects."""
 
@@ -40,7 +49,7 @@ def odxraise(message: Optional[str] = None, error_type: Type[Exception] = OdxErr
         else:
             raise error_type(message)
     elif message is not None:
-        logger.warn(message)
+        logger.warning(message)
 
 
 def odxassert(condition: bool,

odxtools/field.py

@@ -1,18 +1,17 @@
+# SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
 from .complexdop import ComplexDop
 from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxassert, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Field(ComplexDop):
@@ -80,12 +79,13 @@ class Field(ComplexDop):
             self._env_data_desc = odxlinks.resolve(self.env_data_desc_ref,
                                                    EnvironmentDataDescription)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         """Recursively resolve any short-name references"""
+        ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
+
         if self.structure_snref is not None:
-            structures = diag_layer.diag_data_dictionary_spec.structures
-            self._structure = odxrequire(structures.get(self.structure_snref))
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
 
         if self.env_data_desc_snref is not None:
-            env_data_descs = diag_layer.diag_data_dictionary_spec.env_data_descs
-            self._env_data_desc = odxrequire(env_data_descs.get(self.env_data_desc_snref))
+            self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddds.env_data_descs,
+                                                EnvironmentDataDescription)

odxtools/functionalclass.py

@@ -1,15 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class FunctionalClass(IdentifiableElement):
@@ -31,5 +29,5 @@ class FunctionalClass(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/inputparam.py

@@ -1,19 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from deprecation import deprecated
-
 from .dopbase import DopBase
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class InputParam(NamedElement):
@@ -44,15 +40,10 @@ class InputParam(NamedElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop_base = odxlinks.resolve(self.dop_base_ref, DopBase)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property
     def dop_base(self) -> DopBase:
         """The data object property describing this parameter."""
         return self._dop_base
-
-    @property
-    @deprecated(details="use .dop_base")
-    def dop(self) -> DopBase:
-        return self._dop_base

odxtools/internalconstr.py

@@ -4,6 +4,7 @@ from typing import List, Optional
 from xml.etree import ElementTree
 
 from .compumethods.limit import Limit
+from .odxlink import OdxDocFragment
 from .odxtypes import DataType
 from .scaleconstr import ScaleConstr
 
@@ -19,16 +20,24 @@ class InternalConstr:
     upper_limit: Optional[Limit]
     scale_constrs: List[ScaleConstr]
 
+    value_type: DataType
+
     @staticmethod
-    def from_et(et_element: ElementTree.Element, internal_type: DataType) -> "InternalConstr":
+    def constr_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                       value_type: DataType) -> "InternalConstr":
 
-        lower_limit = Limit.from_et(et_element.find("LOWER-LIMIT"), internal_type=internal_type)
-        upper_limit = Limit.from_et(et_element.find("UPPER-LIMIT"), internal_type=internal_type)
+        lower_limit = Limit.limit_from_et(
+            et_element.find("LOWER-LIMIT"), doc_frags, value_type=value_type)
+        upper_limit = Limit.limit_from_et(
+            et_element.find("UPPER-LIMIT"), doc_frags, value_type=value_type)
 
         scale_constrs = [
-            ScaleConstr.from_et(sc_el, internal_type)
+            ScaleConstr.scale_constr_from_et(sc_el, doc_frags, value_type=value_type)
             for sc_el in et_element.iterfind("SCALE-CONSTRS/SCALE-CONSTR")
         ]
 
         return InternalConstr(
-            lower_limit=lower_limit, upper_limit=upper_limit, scale_constrs=scale_constrs)
+            lower_limit=lower_limit,
+            upper_limit=upper_limit,
+            scale_constrs=scale_constrs,
+            value_type=value_type)

odxtools/isotp_state_machine.py

@@ -55,10 +55,13 @@ class IsoTpStateMachine:
             return  # unknown CAN ID
 
         # decode the isotp segment
-        (frame_type,) = bitstruct.unpack("u4", data)
+        frame_type, _ = bitstruct.unpack("u4u4", data)
+        assert isinstance(frame_type, int)
+
         telegram_len = None
         if frame_type == IsoTp.FRAME_TYPE_SINGLE:
             frame_type, telegram_len = bitstruct.unpack("u4u4", data)
+            assert isinstance(telegram_len, int)
 
             self.on_single_frame(telegram_idx, data[1:1 + telegram_len])
             self.on_telegram_complete(telegram_idx, data[1:1 + telegram_len])
@@ -67,6 +70,7 @@ class IsoTpStateMachine:
 
         elif frame_type == IsoTp.FRAME_TYPE_FIRST:
             frame_type, telegram_len = bitstruct.unpack("u4u12", data)
+            assert isinstance(telegram_len, int)
 
             self._telegram_specified_len[telegram_idx] = telegram_len
             self._telegram_data[telegram_idx] = bytearray(data[2:])
@@ -76,11 +80,13 @@ class IsoTpStateMachine:
 
         elif frame_type == IsoTp.FRAME_TYPE_CONSECUTIVE:
             frame_type, rx_segment_idx = bitstruct.unpack("u4u4", data)
+            assert isinstance(rx_segment_idx, int)
 
             expected_segment_idx = (self._telegram_last_rx_fragment_idx[telegram_idx] + 1) % 16
             telegram_data = self._telegram_data[telegram_idx]
             assert isinstance(telegram_data, bytearray)
 
+            n = -1
             if expected_segment_idx == rx_segment_idx:
                 self._telegram_last_rx_fragment_idx[telegram_idx] = rx_segment_idx
                 telegram_data += data[1:]
@@ -102,6 +108,8 @@ class IsoTpStateMachine:
 
         elif frame_type == IsoTp.FRAME_TYPE_FLOW_CONTROL:
             frame_type, flow_control_flag = bitstruct.unpack("u4u4", data)
+            assert isinstance(flow_control_flag, int)
+
             self.on_flow_control_frame(telegram_idx, flow_control_flag)
         else:
             self.on_frame_type_error(telegram_idx, frame_type)
@@ -139,7 +147,7 @@ class IsoTpStateMachine:
                     return
 
                 if m := self.can_normal_frame_re.match(cur_line.strip()):
-                    #frame_interface = m.group(1)
+                    # frame_interface = m.group(1)
                     frame_id = int(m.group(2), 16)
 
                     frame_data_formatted = m.group(3).strip()
@@ -151,7 +159,7 @@ class IsoTpStateMachine:
                 elif (m := self.can_log_frame_re.match(
                         cur_line.strip())) or (m := self.can_fd_log_frame_re.match(
                             cur_line.strip())):
-                    #frame_interface = m.group(2)
+                    # frame_interface = m.group(2)
                     frame_id = int(m.group(2), 16)
 
                     frame_data_formatted = m.group(3).strip()
@@ -257,7 +265,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
     def on_single_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
         # send ACK
-        #rx_id = self.can_rx_id(telegram_idx)
+        # rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
         block_size = 0xFF
         min_separation_time = 0  # ms
@@ -276,7 +284,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
     def on_first_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
         # send ACK
-        #rx_id = self.can_rx_id(telegram_idx)
+        # rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
         block_size = 0xFF  # default value, can be overwritten later
         min_separation_time = 0  # ms
@@ -308,7 +316,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
         # send new ACK if necessary
         block_size = self._block_size[telegram_idx]
         if block_size is not None and num_received >= block_size:
-            #rx_id = self.can_rx_id(telegram_idx)
+            # rx_id = self.can_rx_id(telegram_idx)
             tx_id = self.can_tx_id(telegram_idx)
             min_separation_time = 0  # ms
             fc_payload = bitstruct.pack(

odxtools/leadinglengthinfotype.py

@@ -1,12 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import List
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import odxassert, odxraise
+from .exceptions import EncodeError, odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -18,6 +23,16 @@ class LeadingLengthInfoType(DiagCodedType):
     #: object.
     bit_length: int
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "LeadingLengthInfoType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+
+        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
+
+        return LeadingLengthInfoType(bit_length=bit_length, **kwargs)
+
     def __post_init__(self) -> None:
         odxassert(self.bit_length > 0,
                   "A Leading length info type with bit length == 0 does not make sense.")
@@ -35,36 +50,40 @@ class LeadingLengthInfoType(DiagCodedType):
     def dct_type(self) -> DctType:
         return "LEADING-LENGTH-INFO-TYPE"
 
-    def get_static_bit_length(self) -> Optional[int]:
-        # note that self.bit_length is just the length of the length
-        # specifier field. This is then followed by the same number of
-        # bytes as the value of this field, i.e., the length of this
-        # DCT is dynamic!
-        return None
+    @override
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 
-    def convert_internal_to_bytes(self, internal_value: Any, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+        if not isinstance(internal_value, (str, bytes)):
+            odxraise(
+                f"LEADING-LENGTH-INFO types can only be used for strings and byte fields, "
+                f"not {type(internal_value).__name__}", EncodeError)
+            return
 
         byte_length = self._minimal_byte_length_of(internal_value)
 
-        length_bytes = self._encode_internal_value(
-            byte_length,
-            bit_position=bit_position,
+        used_mask = None
+        bit_pos = encode_state.cursor_bit_position
+        if encode_state.cursor_bit_position != 0 or (bit_pos + self.bit_length) % 8 != 0:
+            used_mask = (1 << self.bit_length) - 1
+            used_mask <<= bit_pos
+
+        encode_state.emplace_atomic_value(
+            internal_value=byte_length,
+            used_mask=None,
             bit_length=self.bit_length,
             base_data_type=DataType.A_UINT32,
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
-        value_bytes = self._encode_internal_value(
-            internal_value,
-            bit_position=0,
+        encode_state.emplace_atomic_value(
+            internal_value=internal_value,
+            used_mask=None,
             bit_length=8 * byte_length,
             base_data_type=self.base_data_type,
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
-        return length_bytes + value_bytes
-
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
 
         # Extract length of the parameter value