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

odxtools/{diaglayer.py → diaglayers/hierarchyelement.py}

@@ -1,82 +1,96 @@
 # SPDX-License-Identifier: MIT
 import re
 import warnings
+from copy import deepcopy
 from dataclasses import dataclass
 from functools import cached_property
-from itertools import chain
-from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, TypeVar, Union, cast
+from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Tuple, TypeVar,
+                    Union, cast)
 from xml.etree import ElementTree
 
-from deprecation import deprecated
-
-from .additionalaudience import AdditionalAudience
-from .admindata import AdminData
-from .companydata import CompanyData
-from .comparaminstance import ComparamInstance
-from .comparamspec import ComparamSpec
-from .diagcomm import DiagComm
-from .diagdatadictionaryspec import DiagDataDictionarySpec
-from .diaglayerraw import DiagLayerRaw
-from .diaglayertype import DiagLayerType
-from .diagservice import DiagService
-from .ecuvariantpattern import EcuVariantPattern
-from .exceptions import DecodeError, OdxWarning, odxassert
-from .functionalclass import FunctionalClass
-from .message import Message
-from .nameditemlist import NamedItemList, OdxNamed
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .parentref import ParentRef
-from .protstack import ProtStack
-from .request import Request
-from .response import Response
-from .servicebinner import ServiceBinner
-from .singleecujob import SingleEcuJob
-from .specialdatagroup import SpecialDataGroup
-from .statechart import StateChart
-from .table import Table
-from .unitgroup import UnitGroup
-from .unitspec import UnitSpec
-
-T = TypeVar("T")
-TNamed = TypeVar("TNamed", bound=OdxNamed)
+from ..additionalaudience import AdditionalAudience
+from ..admindata import AdminData
+from ..comparaminstance import ComparamInstance
+from ..diagcomm import DiagComm
+from ..diagdatadictionaryspec import DiagDataDictionarySpec
+from ..diagservice import DiagService
+from ..exceptions import OdxWarning, odxassert, odxraise
+from ..functionalclass import FunctionalClass
+from ..nameditemlist import NamedItemList, OdxNamed
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..parentref import ParentRef
+from ..response import Response
+from ..singleecujob import SingleEcuJob
+from ..snrefcontext import SnRefContext
+from ..specialdatagroup import SpecialDataGroup
+from ..statechart import StateChart
+from ..unitgroup import UnitGroup
+from ..unitspec import UnitSpec
+from .diaglayer import DiagLayer
+from .hierarchyelementraw import HierarchyElementRaw
+
+if TYPE_CHECKING:
+    from .database import Database
+    from .protocol import Protocol
 
-PrefixTree = Dict[int, Union[List[DiagService], "PrefixTree"]]
+TNamed = TypeVar("TNamed", bound=OdxNamed)
 
 
 @dataclass
-class DiagLayer:
-    """This class represents a "logical view" upon a diagnostic layer
-    according to the ODX standard.
-
-    i.e. it handles the value inheritance, communication parameters,
-    encoding/decoding of data, etc.
+class HierarchyElement(DiagLayer):
+    """This is the base class for diagnostic layers that may be involved in value inheritance
     """
 
-    diag_layer_raw: DiagLayerRaw
+    @property
+    def hierarchy_element_raw(self) -> HierarchyElementRaw:
+        return cast(HierarchyElementRaw, self.diag_layer_raw)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagLayer":
-        diag_layer_raw = DiagLayerRaw.from_et(et_element, doc_frags)
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "HierarchyElement":
+        hierarchy_element_raw = HierarchyElementRaw.from_et(et_element, doc_frags)
 
-        # Create DiagLayer
-        return DiagLayer(diag_layer_raw=diag_layer_raw)
+        return HierarchyElement(diag_layer_raw=hierarchy_element_raw)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        """Construct a mapping from IDs to all objects that are contained in this diagnostic layer."""
-        result = self.diag_layer_raw._build_odxlinks()
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
+        self._global_negative_responses: NamedItemList[Response]
 
-        # we want to get the full diag layer, not just the raw layer
-        # when referencing...
-        result[self.odx_id] = self
+        odxassert(
+            isinstance(self.diag_layer_raw, HierarchyElementRaw),
+            "The raw diagnostic layer passed to HierarchyElement "
+            "must be a HierarchyElementRaw")
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = super()._build_odxlinks()
 
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        """Recursively resolve all references."""
+        super()._resolve_odxlinks(odxlinks)
 
-        self.diag_layer_raw._resolve_odxlinks(odxlinks)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
-    def _finalize_init(self, odxlinks: OdxLinkDatabase) -> None:
+    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+        """Create a deep copy of the hierarchy element
+
+        Note that the copied diagnostic layer is not fully
+        initialized, so `_finalize_init()` should to be called on it
+        before it can be used normally.
+        """
+
+        new_he = super().__deepcopy__(memo)
+
+        # note that the self.hierarchy_element_raw object is *not*
+        # copied at this place because the attribute points to the
+        # same object as self.diag_layer_raw.
+        new_he.hierarchy_element_raw = deepcopy(self.hierarchy_element_raw)
+
+        return new_he
+
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
         """This method deals with everything inheritance related and
         -- after the final set of objects covered by the diagnostic
         layer is determined -- resolves any short name references in
@@ -96,27 +110,7 @@ class DiagLayer:
         # fill in all applicable objects that use value inheritance
         #####
 
-        # diagnostic communication objects with the ODXLINKs resolved
-        diag_comms = self._compute_available_diag_comms(odxlinks)
-        self._diag_comms = NamedItemList(diag_comms)
-
-        # filter the diag comms for services and single-ECU jobs
-        services = [dc for dc in diag_comms if isinstance(dc, DiagService)]
-        single_ecu_jobs = [dc for dc in diag_comms if isinstance(dc, SingleEcuJob)]
-        self._services = NamedItemList(services)
-        self._single_ecu_jobs = NamedItemList(single_ecu_jobs)
-
-        global_negative_responses = self._compute_available_global_neg_responses(odxlinks)
-        self._global_negative_responses = NamedItemList(global_negative_responses)
-
-        functional_classes = self._compute_available_functional_classes()
-        self._functional_classes = NamedItemList(functional_classes)
-
-        additional_audiences = self._compute_available_additional_audiences()
-        self._additional_audiences = NamedItemList(additional_audiences)
-
-        state_charts = self._compute_available_state_charts()
-        self._state_charts = NamedItemList(state_charts)
+        self._compute_value_inheritance(odxlinks)
 
         ############
         # create a new unit_spec object. This is necessary because
@@ -165,10 +159,18 @@ class DiagLayer:
             lambda ddd_spec: ddd_spec.dtc_dops,
             lambda parent_ref: parent_ref.not_inherited_dops,
         )
+        static_fields = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.static_fields,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
         end_of_pdu_fields = self._compute_available_ddd_spec_items(
             lambda ddd_spec: ddd_spec.end_of_pdu_fields,
             lambda parent_ref: parent_ref.not_inherited_dops,
         )
+        dynamic_endmarker_fields = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.dynamic_endmarker_fields,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
         dynamic_length_fields = self._compute_available_ddd_spec_items(
             lambda ddd_spec: ddd_spec.dynamic_length_fields,
             lambda parent_ref: parent_ref.not_inherited_dops,
@@ -183,20 +185,24 @@ class DiagLayer:
             lambda ddd_spec: ddd_spec.muxs, lambda parent_ref: parent_ref.not_inherited_dops)
         tables = self._compute_available_ddd_spec_items(
             lambda ddd_spec: ddd_spec.tables, lambda parent_ref: parent_ref.not_inherited_tables)
-        ddds_sdgs: List[SpecialDataGroup]
+
+        ddds_admin_data: Optional[AdminData] = None
+        ddds_sdgs: List[SpecialDataGroup] = []
         if self.diag_layer_raw.diag_data_dictionary_spec:
+            ddds_admin_data = self.diag_layer_raw.diag_data_dictionary_spec.admin_data
             ddds_sdgs = self.diag_layer_raw.diag_data_dictionary_spec.sdgs
-        else:
-            ddds_sdgs = []
 
         # create a DiagDataDictionarySpec which includes all the
         # inherited objects. To me, this seems rather inelegant, but
         # hey, it's described like this in the standard.
         self._diag_data_dictionary_spec = DiagDataDictionarySpec(
+            admin_data=ddds_admin_data,
             data_object_props=dops,
             dtc_dops=dtc_dops,
             structures=structures,
+            static_fields=static_fields,
             end_of_pdu_fields=end_of_pdu_fields,
+            dynamic_endmarker_fields=dynamic_endmarker_fields,
             dynamic_length_fields=dynamic_length_fields,
             tables=tables,
             env_data_descs=env_data_descs,
@@ -213,7 +219,7 @@ class DiagLayer:
         # scheme, cf the docstring of
         # _compute_available_commmunication_parameters().
         #####
-        self._comparams = NamedItemList(self._compute_available_commmunication_parameters())
+        self._comparam_refs = NamedItemList(self._compute_available_commmunication_parameters())
 
         #####
         # resolve all SNREFs. TODO: We allow SNREFS to objects that
@@ -221,177 +227,48 @@ class DiagLayer:
         # by the spec (So far, I haven't found any definitive
         # statement...)
         #####
-        self.diag_layer_raw._resolve_snrefs(self)
-
-    #####
-    # <convenience functionality>
-    #####
-    @cached_property
-    def service_groups(self) -> ServiceBinner:
-        return ServiceBinner(self.services)
-
-    #####
-    # </convenience functionality>
-    #####
-
-    #####
-    # <properties forwarded to the "raw" diag layer>
-    #####
-    @property
-    def variant_type(self) -> DiagLayerType:
-        return self.diag_layer_raw.variant_type
-
-    @property
-    def odx_id(self) -> OdxLinkId:
-        return self.diag_layer_raw.odx_id
-
-    @property
-    def short_name(self) -> str:
-        return self.diag_layer_raw.short_name
-
-    @property
-    def long_name(self) -> Optional[str]:
-        return self.diag_layer_raw.long_name
-
-    @property
-    def description(self) -> Optional[str]:
-        return self.diag_layer_raw.description
-
-    @property
-    def admin_data(self) -> Optional[AdminData]:
-        return self.diag_layer_raw.admin_data
-
-    @property
-    def company_datas(self) -> NamedItemList[CompanyData]:
-        return self.diag_layer_raw.company_datas
-
-    @property
-    def requests(self) -> NamedItemList[Request]:
-        return self.diag_layer_raw.requests
-
-    @property
-    def positive_responses(self) -> NamedItemList[Response]:
-        return self.diag_layer_raw.positive_responses
-
-    @property
-    def negative_responses(self) -> NamedItemList[Response]:
-        return self.diag_layer_raw.negative_responses
-
-    @property
-    def import_refs(self) -> List[OdxLinkRef]:
-        return self.diag_layer_raw.import_refs
-
-    @property
-    def sdgs(self) -> List[SpecialDataGroup]:
-        return self.diag_layer_raw.sdgs
-
-    @property
-    def parent_refs(self) -> List[ParentRef]:
-        return self.diag_layer_raw.parent_refs
-
-    @property
-    def ecu_variant_patterns(self) -> List[EcuVariantPattern]:
-        return self.diag_layer_raw.ecu_variant_patterns
-
-    @property
-    def comparam_spec_ref(self) -> Optional[OdxLinkRef]:
-        return self.diag_layer_raw.comparam_spec_ref
-
-    @property
-    def prot_stack_snref(self) -> Optional[str]:
-        return self.diag_layer_raw.prot_stack_snref
-
-    @property
-    def comparam_spec(self) -> Optional[ComparamSpec]:
-        return self.diag_layer_raw.comparam_spec
-
-    @property
-    def prot_stack(self) -> Optional[ProtStack]:
-        return self.diag_layer_raw.prot_stack
+        context = SnRefContext(database=database)
+        context.diag_layer = self
+        self._resolve_snrefs(context)
+        context.diag_layer = None
 
     #####
-    # </properties forwarded to the "raw" diag layer>
+    # <value inheritance mechanism helpers>
     #####
+    def _compute_value_inheritance(self, odxlinks: OdxLinkDatabase) -> None:
+        # diagnostic communication objects with the ODXLINKs resolved
+        diag_comms = self._compute_available_diag_comms(odxlinks)
+        self._diag_comms = NamedItemList[DiagComm](diag_comms)
 
-    #######
-    # <stuff subject to value inheritance>
-    #######
-    @property
-    def diag_comms(self) -> NamedItemList[DiagComm]:
-        """All diagnostic communication primitives applicable to this DiagLayer
-
-        Diagnostic communication primitives are diagnostic services as
-        well as single-ECU jobs. This list has all references
-        resolved.
-        """
-        return self._diag_comms
-
-    @property
-    def services(self) -> NamedItemList[DiagService]:
-        """All diagnostic services applicable to this DiagLayer
-
-        This is a subset of all diagnostic communication
-        primitives. All references are resolved in the list returned.
-        """
-        return self._services
-
-    @property
-    def single_ecu_jobs(self) -> NamedItemList[SingleEcuJob]:
-        """All single-ECU jobs applicable to this DiagLayer
-
-        This is a subset of all diagnostic communication
-        primitives. All references are resolved in the list returned.
-        """
-        return self._single_ecu_jobs
-
-    @property
-    def global_negative_responses(self) -> NamedItemList[Response]:
-        """All global negative responses applicable to this DiagLayer"""
-        return self._global_negative_responses
-
-    @property
-    @deprecated(details="use diag_data_dictionary_spec.tables")
-    def tables(self) -> NamedItemList[Table]:
-        return self.diag_data_dictionary_spec.tables
-
-    @property
-    def functional_classes(self) -> NamedItemList[FunctionalClass]:
-        """All functional classes applicable to this DiagLayer"""
-        return self._functional_classes
+        # filter the diag comms for services and single-ECU jobs
+        diag_services = [dc for dc in diag_comms if isinstance(dc, DiagService)]
+        single_ecu_jobs = [dc for dc in diag_comms if isinstance(dc, SingleEcuJob)]
+        self._diag_services = NamedItemList(diag_services)
+        self._single_ecu_jobs = NamedItemList(single_ecu_jobs)
 
-    @property
-    def state_charts(self) -> NamedItemList[StateChart]:
-        """All state charts applicable to this DiagLayer"""
-        return self._state_charts
+        global_negative_responses = self._compute_available_global_neg_responses(odxlinks)
+        self._global_negative_responses = NamedItemList(global_negative_responses)
 
-    @property
-    def additional_audiences(self) -> NamedItemList[AdditionalAudience]:
-        """All audiences applicable to this DiagLayer"""
-        return self._additional_audiences
+        functional_classes = self._compute_available_functional_classes()
+        self._functional_classes = NamedItemList(functional_classes)
 
-    @property
-    def diag_data_dictionary_spec(self) -> DiagDataDictionarySpec:
-        """The DiagDataDictionarySpec applicable to this DiagLayer"""
-        return self._diag_data_dictionary_spec
+        additional_audiences = self._compute_available_additional_audiences()
+        self._additional_audiences = NamedItemList(additional_audiences)
 
-    #######
-    # </stuff subject to value inheritance>
-    #######
+        state_charts = self._compute_available_state_charts()
+        self._state_charts = NamedItemList(state_charts)
 
-    #####
-    # <value inheritance mechanism helpers>
-    #####
     def _get_parent_refs_sorted_by_priority(self, reverse: bool = False) -> Iterable[ParentRef]:
         return sorted(
-            self.diag_layer_raw.parent_refs,
+            getattr(self.diag_layer_raw, "parent_refs", []),
             key=lambda pr: pr.layer.variant_type.inheritance_priority,
             reverse=reverse)
 
     def _compute_available_objects(
         self,
-        get_local_objects: Callable[["DiagLayer"], Iterable[T]],
+        get_local_objects: Callable[["DiagLayer"], Iterable[TNamed]],
         get_not_inherited: Callable[[ParentRef], Iterable[str]],
-    ) -> Iterable[T]:
+    ) -> Iterable[TNamed]:
         """Helper method to compute the set of all objects applicable
         to the DiagLayer if these objects are subject to the value
         inheritance mechanism
@@ -410,66 +287,72 @@ class DiagLayer:
 
         """
 
-        result_dict: Dict[str, T] = {}
+        local_objects = get_local_objects(self)
+        local_object_short_names = {x.short_name for x in local_objects}
+        result_dict: Dict[str, Tuple[TNamed, DiagLayer]] = {}
 
         # populate the result dictionary with the inherited objects
-        #
-        # TODO (?): make sure that there are no "illegal" collisions
-        # i.e., different objects with the same short name stemming
-        # from parent layers exhibiting the same priority that are not
-        # overwritten by a locally defined object. (IMO, this is quite
-        # a corner case.)
-        for parent_ref in self._get_parent_refs_sorted_by_priority():
+        for parent_ref in self._get_parent_refs_sorted_by_priority(reverse=True):
             parent_dl = parent_ref.layer
-            for dc in parent_dl._compute_available_objects(get_local_objects, get_not_inherited):
-                result_dict[dc.short_name] = dc  # type: ignore[attr-defined]
-
-            # remove the explictly not inherited objects
-            for sn in get_not_inherited(parent_ref):
-                if sn in result_dict:
-                    del result_dict[sn]
 
-        # consider the locally defined objects (override the
-        # inherited entries or add new ones)
-        for obj in get_local_objects(self):
-            result_dict[obj.short_name] = obj  # type: ignore[attr-defined]
+            # retrieve the set of short names of the objects which we
+            # are not supposed to inherit
+            not_inherited_short_names = set(get_not_inherited(parent_ref))
 
-        return result_dict.values()
-
-    def _get_local_diag_comms(self, odxlinks: OdxLinkDatabase) -> Iterable[DiagComm]:
-        """Return the list of locally defined diagnostic communications.
-
-        This is not completely trivial as it requires to resolving the
-        references specified in the <DIAG-COMMS> XML tag.
-        """
-        result_dict: Dict[str, DiagComm] = {}
-
-        # TODO (?): add objects from the import-refs
-
-        for dc_proxy in self.diag_layer_raw.diag_comms:
-            if isinstance(dc_proxy, OdxLinkRef):
-                dc = odxlinks.resolve(dc_proxy)
-            else:
-                dc = dc_proxy
-
-            odxassert(isinstance(dc, DiagComm))
-            odxassert(
-                dc.short_name not in result_dict,
-                f"Multiple definitions of DIAG-COMM '{dc.short_name}' in "
-                f"layer '{self.short_name}'")
-            result_dict[dc.short_name] = dc
-
-        return result_dict.values()
-
-    def _get_local_unit_groups(self) -> Iterable[UnitGroup]:
-        if self.diag_layer_raw.diag_data_dictionary_spec is None:
-            return []
-
-        unit_spec = self.diag_layer_raw.diag_data_dictionary_spec.unit_spec
-        if unit_spec is None:
-            return []
+            # compute the list of objects which we are supposed to
+            # inherit from this diagnostic layer
+            inherited_objects = [
+                x
+                for x in parent_dl._compute_available_objects(get_local_objects, get_not_inherited)
+                if x.short_name not in not_inherited_short_names
+            ]
 
-        return unit_spec.unit_groups
+            # update the result set with the objects from the current parent_ref
+            for obj in inherited_objects:
+
+                # no object with the given short name currently
+                # exits. add it to the result set and continue
+                if obj.short_name not in result_dict:
+                    result_dict[obj.short_name] = (obj, parent_dl)
+                    continue
+
+                # if an object with a given name already exists,
+                # there's no problem if it was inherited from a parent
+                # of different priority than the one currently
+                # considered
+                orig_prio = result_dict[obj.short_name][1].variant_type.inheritance_priority
+                new_prio = parent_dl.variant_type.inheritance_priority
+                if new_prio < orig_prio:
+                    continue
+                elif orig_prio < new_prio:
+                    result_dict[obj.short_name] = (obj, parent_dl)
+                    continue
+
+                # if there is a conflict on the same priority level,
+                # it does not matter if the object is overridden
+                # locally anyway...
+                if obj.short_name in local_object_short_names:
+                    continue
+
+                # if all of these conditions do not apply, and if the
+                # inherited objects are identical, there is no
+                # conflict. (note that value comparisons of complete
+                # complex objects tend to be expensive, so this test
+                # is done last.)
+                if obj == result_dict[obj.short_name][0]:
+                    continue
+
+                odxraise(f"Diagnostic layer {self.short_name} cannot inherit object "
+                         f"{obj.short_name} due to an unresolveable inheritance conflict between "
+                         f"parent layers {result_dict[obj.short_name][1].short_name} "
+                         f"and {parent_dl.short_name}")
+
+        # add the locally defined entries, overriding the inherited
+        # ones if necessary
+        for obj in local_objects:
+            result_dict[obj.short_name] = (obj, self)
+
+        return [x[0] for x in result_dict.values()]
 
     def _compute_available_diag_comms(self, odxlinks: OdxLinkDatabase) -> Iterable[DiagComm]:
 
@@ -550,6 +433,70 @@ class DiagLayer:
     # </value inheritance mechanism helpers>
     #####
 
+    #######
+    # <properties subject to value inheritance>
+    #######
+    @property
+    def diag_data_dictionary_spec(self) -> DiagDataDictionarySpec:
+        return self._diag_data_dictionary_spec
+
+    @property
+    def diag_comms(self) -> NamedItemList[DiagComm]:
+        """All diagnostic communication primitives applicable to this DiagLayer
+
+        Diagnostic communication primitives are diagnostic services as
+        well as single-ECU jobs. This list has all references
+        resolved.
+        """
+        return self._diag_comms
+
+    @property
+    def services(self) -> NamedItemList[DiagService]:
+        """This property is an alias for `.diag_services`"""
+        return self._diag_services
+
+    @property
+    def diag_services(self) -> NamedItemList[DiagService]:
+        """All diagnostic services applicable to this DiagLayer
+
+        This is a subset of all diagnostic communication
+        primitives. All references are resolved in the list returned.
+        """
+        return self._diag_services
+
+    @property
+    def single_ecu_jobs(self) -> NamedItemList[SingleEcuJob]:
+        """All single-ECU jobs applicable to this DiagLayer
+
+        This is a subset of all diagnostic communication
+        primitives. All references are resolved in the list returned.
+        """
+        return self._single_ecu_jobs
+
+    @property
+    def global_negative_responses(self) -> NamedItemList[Response]:
+        """All global negative responses applicable to this DiagLayer"""
+        return self._global_negative_responses
+
+    @property
+    def functional_classes(self) -> NamedItemList[FunctionalClass]:
+        """All functional classes applicable to this DiagLayer"""
+        return self._functional_classes
+
+    @property
+    def state_charts(self) -> NamedItemList[StateChart]:
+        """All state charts applicable to this DiagLayer"""
+        return self._state_charts
+
+    @property
+    def additional_audiences(self) -> NamedItemList[AdditionalAudience]:
+        """All audiences applicable to this DiagLayer"""
+        return self._additional_audiences
+
+    #######
+    # </properties subject to value inheritance>
+    #######
+
     #####
     # <communication parameter handling>
     #####
@@ -583,39 +530,45 @@ class DiagLayer:
         # parameters. First fetch the communication parameters from
         # low priority parents, then update with increasing priority.
         for parent_ref in self._get_parent_refs_sorted_by_priority():
-            for cp in parent_ref.layer._compute_available_commmunication_parameters():
+            parent_layer = parent_ref.layer
+            if not isinstance(parent_layer, HierarchyElement):
+                continue
+            for cp in parent_layer._compute_available_commmunication_parameters():
                 com_params_dict[(cp.spec_ref.ref_id, cp.protocol_snref)] = cp
 
         # finally, handle the locally defined communication parameters
-        for cp in self.diag_layer_raw.comparams:
+        for cp in getattr(self.hierarchy_element_raw, "comparam_refs", []):
             com_params_dict[(cp.spec_ref.ref_id, cp.protocol_snref)] = cp
 
         return list(com_params_dict.values())
 
     @property
-    def comparams(self) -> NamedItemList[ComparamInstance]:
+    def comparam_refs(self) -> NamedItemList[ComparamInstance]:
         """All communication parameters applicable to this DiagLayer
 
         Note that, although communication parameters use inheritance,
         it is *not* the "value inheritance" scheme used by e.g. DOPs,
         tables, state charts, ...
         """
-        return self._comparams
+        return self._comparam_refs
 
     @cached_property
-    def protocols(self) -> NamedItemList["DiagLayer"]:
+    def protocols(self) -> NamedItemList["Protocol"]:
         """Return the set of all protocols which are applicable to the diagnostic layer
 
-        Note that protocols are *not* explicitly inherited objects,
-        but the parent diagnostic layers of variant type "PROTOCOL".
+        Note that protocols are *not* explicitly defined by the XML,
+        but they are the parent layers of variant type "PROTOCOL".
+
         """
-        result_dict: Dict[str, DiagLayer] = {}
+        from .protocol import Protocol
 
-        for parent_ref in self._get_parent_refs_sorted_by_priority():
-            for prot in parent_ref.layer.protocols:
+        result_dict: Dict[str, Protocol] = {}
+
+        for parent_ref in getattr(self, "parent_refs", []):
+            for prot in getattr(parent_ref.layer, "protocols", []):
                 result_dict[prot.short_name] = prot
 
-        if self.diag_layer_raw.variant_type == DiagLayerType.PROTOCOL:
+        if isinstance(self, Protocol):
             result_dict[self.diag_layer_raw.short_name] = self
 
         return NamedItemList(result_dict.values())
@@ -624,20 +577,22 @@ class DiagLayer:
         self,
         cp_short_name: str,
         *,
-        protocol: Optional[Union[str, "DiagLayer"]] = None,
+        protocol: Optional[Union[str, "Protocol"]] = None,
     ) -> Optional[ComparamInstance]:
         """Find a specific communication parameter according to some criteria.
 
         Setting a given parameter to `None` means "don't care"."""
 
+        from .protocol import Protocol
+
         protocol_name: Optional[str]
-        if isinstance(protocol, DiagLayer):
+        if isinstance(protocol, Protocol):
             protocol_name = protocol.short_name
         else:
             protocol_name = protocol
 
         # determine the set of applicable communication parameters
-        cps = [cp for cp in self.comparams if cp.short_name == cp_short_name]
+        cps = [cp for cp in self.comparam_refs if cp.short_name == cp_short_name]
         if protocol_name is not None:
             cps = [cp for cp in cps if cp.protocol_snref in (None, protocol_name)]
 
@@ -655,7 +610,7 @@ class DiagLayer:
 
     def get_max_can_payload_size(self,
                                  protocol: Optional[Union[str,
-                                                          "DiagLayer"]] = None) -> Optional[int]:
+                                                          "Protocol"]] = None) -> Optional[int]:
         """Return the maximum size of a CAN frame payload that can be
         transmitted in bytes.
 
@@ -685,13 +640,13 @@ class DiagLayer:
         # unexpected format of parameter value
         return 8
 
-    def uses_can(self, protocol: Optional[Union[str, "DiagLayer"]] = None) -> bool:
+    def uses_can(self, protocol: Optional[Union[str, "Protocol"]] = None) -> bool:
         """
         Check if CAN ought to be used as the link layer protocol.
         """
         return self.get_can_receive_id(protocol=protocol) is not None
 
-    def uses_can_fd(self, protocol: Optional[Union[str, "DiagLayer"]] = None) -> bool:
+    def uses_can_fd(self, protocol: Optional[Union[str, "Protocol"]] = None) -> bool:
         """Check if CAN-FD ought to be used.
 
         If the ECU is not using CAN-FD for the specified protocol, `False`
@@ -710,7 +665,7 @@ class DiagLayer:
 
         return "CANFD" in com_param.value
 
-    def get_can_baudrate(self, protocol: Optional[Union[str, "DiagLayer"]] = None) -> Optional[int]:
+    def get_can_baudrate(self, protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
         """Baudrate of the CAN bus which is used by the ECU [bits/s]
 
         If the ECU is not using CAN for the specified protocol, None
@@ -728,7 +683,7 @@ class DiagLayer:
         return int(val)
 
     def get_can_fd_baudrate(self,
-                            protocol: Optional[Union[str, "DiagLayer"]] = None) -> Optional[int]:
+                            protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
         """Data baudrate of the CAN bus which is used by the ECU [bits/s]
 
         If the ECU is not using CAN-FD for the specified protocol,
@@ -748,7 +703,7 @@ class DiagLayer:
         return int(val)
 
     def get_can_receive_id(self,
-                           protocol: Optional[Union[str, "DiagLayer"]] = None) -> Optional[int]:
+                           protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
         """CAN ID to which the ECU listens for diagnostic messages"""
         com_param = self.get_comparam("CP_UniqueRespIdTable", protocol=protocol)
         if com_param is None:
@@ -767,11 +722,7 @@ class DiagLayer:
 
         return int(result)
 
-    @deprecated(details="use get_can_receive_id()")
-    def get_receive_id(self) -> Optional[int]:
-        return self.get_can_receive_id()
-
-    def get_can_send_id(self, protocol: Optional[Union[str, "DiagLayer"]] = None) -> Optional[int]:
+    def get_can_send_id(self, protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
         """CAN ID to which the ECU sends replies to diagnostic messages"""
 
         # this hopefully resolves to the 'CP_UniqueRespIdTable'
@@ -796,12 +747,8 @@ class DiagLayer:
 
         return int(result)
 
-    @deprecated(details="use get_can_send_id()")
-    def get_send_id(self) -> Optional[int]:
-        return self.get_can_send_id()
-
     def get_can_func_req_id(self,
-                            protocol: Optional[Union[str, "DiagLayer"]] = None) -> Optional[int]:
+                            protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
         """CAN Functional Request Id."""
         com_param = self.get_comparam("CP_CanFuncReqId", protocol=protocol)
         if com_param is None:
@@ -815,8 +762,8 @@ class DiagLayer:
         return int(result)
 
     def get_doip_logical_ecu_address(self,
-                                     protocol: Optional[Union[str, "DiagLayer"]] = None
-                                    ) -> Optional[int]:
+                                     protocol: Optional[Union[str,
+                                                              "Protocol"]] = None) -> Optional[int]:
         """Return the address of the ECU when using functional addressing.
 
         The parameter protocol is used to distinguish between
@@ -847,7 +794,7 @@ class DiagLayer:
         return int(ecu_addr)
 
     def get_doip_logical_gateway_address(self,
-                                         protocol: Optional[Union[str, "DiagLayer"]] = None
+                                         protocol: Optional[Union[str, "Protocol"]] = None
                                         ) -> Optional[int]:
         """The logical gateway address for the diagnosis over IP transport protocol"""
 
@@ -865,7 +812,7 @@ class DiagLayer:
         return int(result)
 
     def get_doip_logical_tester_address(self,
-                                        protocol: Optional[Union[str, "DiagLayer"]] = None
+                                        protocol: Optional[Union[str, "Protocol"]] = None
                                        ) -> Optional[int]:
         """DoIp logical gateway address"""
 
@@ -883,7 +830,7 @@ class DiagLayer:
         return int(result)
 
     def get_doip_logical_functional_address(self,
-                                            protocol: Optional[Union[str, "DiagLayer"]] = None
+                                            protocol: Optional[Union[str, "Protocol"]] = None
                                            ) -> Optional[int]:
         """The logical functional DoIP address of the ECU."""
 
@@ -904,7 +851,7 @@ class DiagLayer:
         return int(result)
 
     def get_doip_routing_activation_timeout(self,
-                                            protocol: Optional[Union[str, "DiagLayer"]] = None
+                                            protocol: Optional[Union[str, "Protocol"]] = None
                                            ) -> Optional[float]:
         """The timout for the DoIP routing activation request in seconds"""
 
@@ -922,7 +869,7 @@ class DiagLayer:
         return float(result) / 1e6
 
     def get_doip_routing_activation_type(self,
-                                         protocol: Optional[Union[str, "DiagLayer"]] = None
+                                         protocol: Optional[Union[str, "Protocol"]] = None
                                         ) -> Optional[int]:
         """The DoIP routing activation type
 
@@ -949,7 +896,7 @@ class DiagLayer:
 
     def get_tester_present_time(self,
                                 protocol: Optional[Union[str,
-                                                         "DiagLayer"]] = None) -> Optional[float]:
+                                                         "Protocol"]] = None) -> Optional[float]:
         """Timeout on inactivity in seconds.
 
         This is defined by the communication parameter "CP_TesterPresentTime".
@@ -976,149 +923,3 @@ class DiagLayer:
     #####
     # </communication parameter handling>
     #####
-
-    #####
-    # <PDU decoding>
-    #####
-
-    @cached_property
-    def _prefix_tree(self) -> PrefixTree:
-        """Constructs the coded prefix tree of the services.
-
-        Each leaf node is a list of `DiagService`s.  (This is because
-        navigating from a service to the request/ responses is easier
-        than finding the service for a given request/response object.)
-
-        Example:
-        Let there be four services with corresponding requests:
-        * Request 1 has the coded constant prefix `12 34`.
-        * Request 2 has the coded constant prefix `12 34`.
-        * Request 3 has the coded constant prefix `12 56`.
-        * Request 4 has the coded constant prefix `12 56 00`.
-
-        Then, the constructed prefix tree is the dict
-        ```
-        {0x12: {0x34: {-1: [<Service 1>, <Service 2>]},
-                0x56: {-1: [<Service 3>],
-                       0x0: {-1: [<Service 4>]}
-                       }}}
-        ```
-        Note, that the inner `-1` are constant to distinguish them
-        from possible service IDs.
-
-        Also note, that it is actually allowed that
-        (a) SIDs for different services are the same like for service 1 and 2 (thus each leaf node is a list) and
-        (b) one SID is the prefix of another SID like for service 3 and 4 (thus the constant `-1` key).
-
-        """
-        prefix_tree: PrefixTree = {}
-        for s in self.services:
-            # Compute prefixes for the service's request and all
-            # possible responses. We need to consider the global
-            # negative responses here, because they might contain
-            # MATCHING-REQUEST parameters. If these global responses
-            # do not contain such parameters, this will potentially
-            # result in an enormous amount of decoded messages for
-            # global negative responses. (I.e., one for each
-            # service. This can be avoided by specifying the
-            # corresponding request for `decode_response()`.)
-            request_prefix = b''
-            if s.request is not None:
-                request_prefix = s.request.coded_const_prefix()
-            prefixes = [request_prefix]
-            prefixes += [
-                x.coded_const_prefix(request_prefix=request_prefix) for x in chain(
-                    s.positive_responses, s.negative_responses, self.global_negative_responses)
-            ]
-            for coded_prefix in prefixes:
-                self._extend_prefix_tree(prefix_tree, coded_prefix, s)
-
-        return prefix_tree
-
-    @staticmethod
-    def _extend_prefix_tree(prefix_tree: PrefixTree, coded_prefix: bytes,
-                            service: DiagService) -> None:
-
-        # make sure that tree has an entry for the given prefix
-        sub_tree = prefix_tree
-        for b in coded_prefix:
-            if b not in sub_tree:
-                sub_tree[b] = {}
-            sub_tree = cast(PrefixTree, sub_tree[b])
-
-        # Store the object as in the prefix tree. This is done by
-        # assigning the list of possible objects to the key -1 of the
-        # dictionary (this is quite hacky...)
-        if sub_tree.get(-1) is None:
-            sub_tree[-1] = [service]
-        else:
-            cast(List[DiagService], sub_tree[-1]).append(service)
-
-    def _find_services_for_uds(self, message: bytes) -> List[DiagService]:
-        prefix_tree = self._prefix_tree
-
-        # Find matching service(s) in prefix tree
-        possible_services: List[DiagService] = []
-        for b in message:
-            if b in prefix_tree:
-                odxassert(isinstance(prefix_tree[b], dict))
-                prefix_tree = cast(PrefixTree, prefix_tree[b])
-            else:
-                break
-            if -1 in prefix_tree:
-                possible_services += cast(List[DiagService], prefix_tree[-1])
-        return possible_services
-
-    def _decode(self, message: bytes, candidate_services: Iterable[DiagService]) -> List[Message]:
-        decoded_messages: List[Message] = []
-
-        for service in candidate_services:
-            try:
-                decoded_messages.append(service.decode_message(message))
-            except DecodeError:
-                # check if the message can be decoded as a global
-                # negative response for the service
-                for gnr in self.global_negative_responses:
-                    try:
-                        decoded_gnr = gnr.decode(message)
-                        if not isinstance(decoded_gnr, dict):
-                            raise DecodeError(f"Expected the decoded value of a global "
-                                              f"negative response to be a dictionary, "
-                                              f"got {type(decoded_gnr)} for {self.short_name}")
-
-                        decoded_messages.append(
-                            Message(
-                                coded_message=message,
-                                service=service,
-                                coding_object=gnr,
-                                param_dict=decoded_gnr))
-                    except DecodeError:
-                        pass
-
-        if len(decoded_messages) == 0:
-            raise DecodeError(
-                f"None of the services {candidate_services} could parse {message.hex()}.")
-
-        return decoded_messages
-
-    def decode(self, message: bytes) -> List[Message]:
-        candidate_services = self._find_services_for_uds(message)
-
-        return self._decode(message, candidate_services)
-
-    def decode_response(self, response: bytes, request: Union[bytes, Message]) -> List[Message]:
-        if isinstance(request, Message):
-            candidate_services = [request.service]
-        else:
-            if not isinstance(request, (bytes, bytearray)):
-                raise TypeError(f"Request parameter must have type "
-                                f"Message, bytes or bytearray but was {type(request)}")
-            candidate_services = self._find_services_for_uds(request)
-        if candidate_services is None:
-            raise DecodeError(f"Couldn't find corresponding service for request {request.hex()}.")
-
-        return self._decode(response, candidate_services)
-
-    #####
-    # </PDU decoding>
-    #####