armodel 1.4.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

armodel/models/ar_package.py

@@ -1,16 +1,30 @@
 from typing import Dict, List
 
-from .data_dictionary import SwAddrMethod
+from .fibex.fibex_core.core_topology import EcuInstance, CanCluster, LinCluster
+from .fibex.fibex_core.core_communication import ISignalGroup, ISignalIPdu, ISignalIPduGroup, SecuredIPdu, SystemSignal, DcmIPdu, ISignal, NPdu, NmPdu, SystemSignalGroup
+from .fibex.can_communication import CanFrame
+from .fibex.fibex_4_multiplatform import Gateway
+from .fibex.lin_communication import LinUnconditionalFrame
+
+from .m2.msr.asam_hdo.units import PhysicalDimension
+from .m2.msr.data_dictionary.auxillary_objects import SwAddrMethod
+from .m2.autosar_templates.common_structure import ConstantSpecification
+from .m2.autosar_templates.ecuc_description_template import EcucModuleConfigurationValues, EcucValueCollection
+from .m2.autosar_templates.system_template import System
+from .m2.autosar_templates.system_template.transport_protocols import CanTpConfig
+from .m2.autosar_templates.system_template.network_management import NmConfig
+
+from .timing import SwcTiming
 from .record_layout import SwRecordLayout
 from .end_to_end_protection import EndToEndProtectionSet
-from .unit import Unit
+from .m2.msr.asam_hdo.units import Unit
 from .general_structure import Identifiable, ARObject, Referrable, CollectableElement, SwcBswMapping
-from .port_interface import ModeSwitchInterface, SenderReceiverInterface, ClientServerInterface, TriggerInterface
+from .m2.autosar_templates.sw_component_template.port_interface import ModeSwitchInterface, SenderReceiverInterface, ClientServerInterface, TriggerInterface
 from .sw_component import SwComponentType, EcuAbstractionSwComponentType, AtomicSwComponentType, ApplicationSwComponentType
 from .sw_component import ServiceSwComponentType, CompositionSwComponentType, SensorActuatorSwComponentType, ComplexDeviceDriverSwComponentType
 from .datatype import ApplicationArrayDataType, ImplementationDataType, ApplicationDataType, DataTypeMappingSet, DataTypeMap, SwBaseType, ApplicationPrimitiveDataType, ApplicationRecordDataType
 from .m2_msr import CompuMethod
-from .common_structure import ConstantSpecification, ModeDeclarationGroup
+from .common_structure import ModeDeclarationGroup
 from .implementation import BswImplementation, SwcImplementation, Implementation
 from .bsw_module_template import BswModuleDescription, BswModuleEntry
 from .global_constraints import DataConstr
@@ -153,8 +167,8 @@ class ARPackage(Identifiable, CollectableElement):
 
     def createSwcBswMapping(self, short_name: str) -> SwcBswMapping:
         if (short_name not in self.elements):
-            sw_component = SwcBswMapping(self, short_name)
-            self.elements[short_name] = sw_component
+            mapping = SwcBswMapping(self, short_name)
+            self.elements[short_name] = mapping
         return self.elements[short_name]
     
     def createConstantSpecification(self, short_name: str) -> ConstantSpecification:
@@ -165,14 +179,14 @@ class ARPackage(Identifiable, CollectableElement):
     
     def createDataConstr(self, short_name: str) -> DataConstr:
         if (short_name not in self.elements):
-            spec = DataConstr(self, short_name)
-            self.elements[short_name] = spec
+            constr = DataConstr(self, short_name)
+            self.elements[short_name] = constr
         return self.elements[short_name]
     
     def createUnit(self, short_name: str) -> Unit:
         if (short_name not in self.elements):
-            spec = Unit(self, short_name)
-            self.elements[short_name] = spec
+            unit = Unit(self, short_name)
+            self.elements[short_name] = unit
         return self.elements[short_name]
     
     def createEndToEndProtectionSet(self, short_name: str) -> EndToEndProtectionSet:
@@ -183,48 +197,186 @@ class ARPackage(Identifiable, CollectableElement):
     
     def createApplicationArrayDataType(self, short_name: str) -> ApplicationArrayDataType:
         if (short_name not in self.elements):
-            spec = ApplicationArrayDataType(self, short_name)
-            self.elements[short_name] = spec
+            data_type = ApplicationArrayDataType(self, short_name)
+            self.elements[short_name] = data_type
         return self.elements[short_name]
     
     def createSwRecordLayout(self, short_name: str) -> SwRecordLayout:
         if (short_name not in self.elements):
-            spec = SwRecordLayout(self, short_name)
-            self.elements[short_name] = spec
+            layout = SwRecordLayout(self, short_name)
+            self.elements[short_name] = layout
         return self.elements[short_name]
     
     def createSwAddrMethod(self, short_name: str) -> SwAddrMethod:
         if (short_name not in self.elements):
-            spec = SwAddrMethod(self, short_name)
-            self.elements[short_name] = spec
+            method = SwAddrMethod(self, short_name)
+            self.elements[short_name] = method
         return self.elements[short_name]
     
     def createTriggerInterface(self, short_name: str) -> TriggerInterface:
         if (short_name not in self.elements):
-            spec = TriggerInterface(self, short_name)
-            self.elements[short_name] = spec
+            trigger_interface = TriggerInterface(self, short_name)
+            self.elements[short_name] = trigger_interface
         return self.elements[short_name]
     
     def createModeDeclarationGroup(self, short_name: str) -> ModeDeclarationGroup:
         if (short_name not in self.elements):
-            spec = ModeDeclarationGroup(self, short_name)
-            self.elements[short_name] = spec
+            group = ModeDeclarationGroup(self, short_name)
+            self.elements[short_name] = group
         return self.elements[short_name]
     
     def createModeSwitchInterface(self, short_name: str) -> ModeSwitchInterface:
         if (short_name not in self.elements):
-            spec = ModeSwitchInterface(self, short_name)
-            self.elements[short_name] = spec
+            switch_interface = ModeSwitchInterface(self, short_name)
+            self.elements[short_name] = switch_interface
         return self.elements[short_name]
-
+    
+    def createSwcTiming(self, short_name: str) -> SwcTiming:
+        if (short_name not in self.elements):
+            timing = SwcTiming(self, short_name)
+            self.elements[short_name] = timing
+        return self.elements[short_name]
+    
+    def createLinCluster(self, short_name: str) -> LinCluster:
+        if (short_name not in self.elements):
+            cluster = LinCluster(self, short_name)
+            self.elements[short_name] = cluster
+        return self.elements[short_name]
+    
+    def createCanCluster(self, short_name: str) -> CanCluster:
+        if (short_name not in self.elements):
+            cluster = CanCluster(self, short_name)
+            self.elements[short_name] = cluster
+        return self.elements[short_name]
+    
+    def createLinUnconditionalFrame(self, short_name: str) -> LinUnconditionalFrame:
+        if (short_name not in self.elements):
+            frame = LinUnconditionalFrame(self, short_name)
+            self.elements[short_name] = frame
+        return self.elements[short_name]
+    
+    def createNmPdu(self, short_name: str) -> NmPdu:
+        if (short_name not in self.elements):
+            pdu = NmPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
+    def createNPdu(self, short_name: str) -> NPdu:
+        if (short_name not in self.elements):
+            pdu = NPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
+    def createDcmIPdu(self, short_name: str) -> DcmIPdu:
+        if (short_name not in self.elements):
+            pdu = DcmIPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
+    def createSecuredIPdu(self, short_name: str) -> SecuredIPdu:
+        if (short_name not in self.elements):
+            pdu = SecuredIPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
+    def createNmConfig(self, short_name: str) -> NmConfig:
+        if (short_name not in self.elements):
+            config = NmConfig(self, short_name)
+            self.elements[short_name] = config
+        return self.elements[short_name]
+    
+    def createCanTpConfig(self, short_name: str) -> CanTpConfig:
+        if (short_name not in self.elements):
+            config = CanTpConfig(self, short_name)
+            self.elements[short_name] = config
+        return self.elements[short_name]
+    
+    def createCanFrame(self, short_name: str) -> CanFrame:
+        if (short_name not in self.elements):
+            frame = CanFrame(self, short_name)
+            self.elements[short_name] = frame
+        return self.elements[short_name]
+    
+    def createEcuInstance(self, short_name: str) -> EcuInstance:
+        if (short_name not in self.elements):
+            frame = EcuInstance(self, short_name)
+            self.elements[short_name] = frame
+        return self.elements[short_name]
+    
+    def createGateway(self, short_name: str) -> Gateway:
+        if (short_name not in self.elements):
+            gateway = Gateway(self, short_name)
+            self.elements[short_name] = gateway
+        return self.elements[short_name]
+    
+    def createISignal(self, short_name: str) -> ISignal:
+        if (short_name not in self.elements):
+            signal = ISignal(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createSystemSignal(self, short_name: str) -> SystemSignal:
+        if (short_name not in self.elements):
+            signal = SystemSignal(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createSystemSignalGroup(self, short_name: str) -> SystemSignalGroup:
+        if (short_name not in self.elements):
+            signal = SystemSignalGroup(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createISignalIPdu(self, short_name: str) -> ISignalIPdu:
+        if (short_name not in self.elements):
+            signal = ISignalIPdu(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createEcucValueCollection(self, short_name: str) -> EcucValueCollection:
+        if (short_name not in self.elements):
+            signal = EcucValueCollection(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createEcucModuleConfigurationValues(self, short_name: str) -> EcucModuleConfigurationValues:
+        if (short_name not in self.elements):
+            signal = EcucModuleConfigurationValues(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createPhysicalDimension(self, short_name: str) -> PhysicalDimension:
+        if (short_name not in self.elements):
+            signal = PhysicalDimension(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createISignalGroup(self, short_name: str) -> ISignalGroup:
+        if (short_name not in self.elements):
+            signal = ISignalGroup(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createISignalIPduGroup(self, short_name: str) -> ISignalIPduGroup:
+        if (short_name not in self.elements):
+            signal = ISignalIPduGroup(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createSystem(self, short_name: str) -> System:
+        if (short_name not in self.elements):
+            signal = System(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
     def getApplicationPrimitiveDataTypes(self) -> List[ApplicationPrimitiveDataType]:
-        return list(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()))
+        return list(sorted(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()), key= lambda o:o.short_name))
     
     def getApplicationDataType(self) -> List[ApplicationDataType]:
         return list(sorted(filter(lambda a: isinstance(a, ApplicationDataType), self.elements.values()), key= lambda o:o.short_name))
 
     def getImplementationDataTypes(self) -> List[ImplementationDataType]:
-        return list(filter(lambda a: isinstance(a, ImplementationDataType), self.elements.values()))
+        return list(sorted(filter(lambda a: isinstance(a, ImplementationDataType), self.elements.values()), key= lambda o:o.short_name))
 
     def getSwBaseTypes(self) -> List[SwBaseType]:
         return list(filter(lambda a: isinstance(a, SwBaseType), self.elements.values()))
@@ -300,8 +452,74 @@ class ARPackage(Identifiable, CollectableElement):
     
     def getModeSwitchInterfaces(self) -> List[ModeSwitchInterface]:
         return list(sorted(filter(lambda a : isinstance(a, ModeSwitchInterface), self.elements.values()), key = lambda a: a.short_name))
-
-class AUTOSAR (CollectableElement):
+    
+    def getSwcTimings(self) -> List[SwcTiming]:
+        return list(sorted(filter(lambda a : isinstance(a, SwcTiming), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getLinClusters(self) -> List[LinCluster]:
+        return list(sorted(filter(lambda a : isinstance(a, LinCluster), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getCanClusters(self) -> List[CanCluster]:
+        return list(sorted(filter(lambda a : isinstance(a, CanCluster), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getLinUnconditionalFrames(self) -> List[LinUnconditionalFrame]:
+        return list(sorted(filter(lambda a : isinstance(a, LinUnconditionalFrame), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getNmPdus(self) -> List[NmPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, NmPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getNPdus(self) -> List[NPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, NPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getDcmIPdus(self) -> List[DcmIPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, DcmIPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSecuredIPdus(self) -> List[SecuredIPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, SecuredIPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getNmConfigs(self) -> List[NmConfig]:
+        return list(sorted(filter(lambda a : isinstance(a, NmConfig), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getCanTpConfigs(self) -> List[CanTpConfig]:
+        return list(sorted(filter(lambda a : isinstance(a, CanTpConfig), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getCanFrames(self) -> List[CanFrame]:
+        return list(sorted(filter(lambda a : isinstance(a, CanFrame), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getEcuInstances(self) -> List[EcuInstance]:
+        return list(sorted(filter(lambda a : isinstance(a, EcuInstance), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getGateways(self) -> List[Gateway]:
+        return list(sorted(filter(lambda a : isinstance(a, Gateway), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getISignals(self) -> List[ISignal]:
+        return list(sorted(filter(lambda a : isinstance(a, ISignal), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getEcucValueCollections(self) -> List[EcucValueCollection]:
+        return list(sorted(filter(lambda a : isinstance(a, EcucValueCollection), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getEcucModuleConfigurationValues(self) -> List[EcucModuleConfigurationValues]:
+        return list(sorted(filter(lambda a : isinstance(a, EcucModuleConfigurationValues), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getEcucModuleConfigurationValues(self) -> List[PhysicalDimension]:
+        return list(sorted(filter(lambda a : isinstance(a, PhysicalDimension), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getISignalGroups(self) -> List[ISignalGroup]:
+        return list(sorted(filter(lambda a : isinstance(a, ISignalGroup), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSystemSignals(self) -> List[SystemSignal]:
+        return list(sorted(filter(lambda a : isinstance(a, SystemSignal), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSystemSignalGroups(self) -> List[SystemSignalGroup]:
+        return list(sorted(filter(lambda a : isinstance(a, SystemSignalGroup), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getISignalIPdus(self) -> List[ISignalIPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, ISignalIPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSystems(self) -> List[System]:
+        return list(sorted(filter(lambda a : isinstance(a, System), self.elements.values()), key = lambda a: a.short_name))
+    
+class AUTOSAR (CollectableElement):        
     __instance = None
 
     @staticmethod
@@ -360,11 +578,11 @@ class AUTOSAR (CollectableElement):
     def getDataType(self, data_type: ImplementationDataType) -> ImplementationDataType:
         if (isinstance(data_type, ImplementationDataType) or isinstance(data_type, SwBaseType)):
             if (data_type.category == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
-                referred_type = self.find(data_type.sw_data_def_props.implementationDataTypeRef.value)
+                referred_type = self.find(data_type.swDataDefProps.implementationDataTypeRef.value)
                 return self.getDataType(referred_type)
             if (data_type.category == ImplementationDataType.CATEGORY_DATA_REFERENCE):
-                if (data_type.sw_data_def_props.sw_pointer_target_props.target_category == "VALUE"):
-                    referred_type = self.find(data_type.sw_data_def_props.sw_pointer_target_props.sw_data_def_props.baseTypeRef.value)
+                if (data_type.swDataDefProps.swPointerTargetProps.target_category == "VALUE"):
+                    referred_type = self.find(data_type.swDataDefProps.swPointerTargetProps.sw_data_def_props.baseTypeRef.value)
                     return self.getDataType(referred_type)
             return data_type
         else:

armodel/models/ar_ref.py

@@ -7,17 +7,81 @@ class RefType(ARObject):
         self.dest = ""
         self.value = ""
 
+    def getDest(self):
+        return self.dest
+
+    def setDest(self, value):
+        self.dest = value
+        return self
+
+    def getValue(self):
+        return self.value
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
 class TRefType(RefType):
     def __init__(self):
         super().__init__()
-        
+
+class AnyInstanceRef(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.baseRef = None                             # type: RefType
+        self.contextElementRef = None                   # type: RefType
+        self.targetRef = None                           # type: RefType
+
+    def getBaseRef(self) -> RefType:
+        return self.baseRef
+
+    def setBaseRef(self, value: RefType):
+        self.baseRef = value
+        return self
+
+    def getContextElementRef(self) -> RefType:
+        return self.contextElementRef
+
+    def setContextElementRef(self, value: RefType):
+        self.contextElementRef = value
+        return self
+
+    def getTargetRef(self) -> RefType:
+        return self.targetRef
+
+    def setTargetRef(self, value:RefType):
+        self.targetRef = value
+        return self
 
 class AutosarVariableRef(ARObject):
     def __init__(self):
         super().__init__()
-        self.autosar_variable_iref = None               # type: VariableInAtomicSWCTypeInstanceRef 
-        self.autosar_variable_in_impl_datatype = None   # type: ArVariableInImplementationDataInstanceRef
-        self.local_variable_ref = None
+
+        self.autosarVariableIRef = None             # type: VariableInAtomicSWCTypeInstanceRef 
+        self.autosarVariableInImplDatatype = None   # type: ArVariableInImplementationDataInstanceRef
+        self.localVariableRef = None
+
+    def getAutosarVariableIRef(self):
+        return self.autosarVariableIRef
+
+    def setAutosarVariableIRef(self, value):
+        self.autosarVariableIRef = value
+        return self
+
+    def getAutosarVariableInImplDatatype(self):
+        return self.autosarVariableInImplDatatype
+
+    def setAutosarVariableInImplDatatype(self, value):
+        self.autosarVariableInImplDatatype = value
+        return self
+
+    def getLocalVariableRef(self):
+        return self.localVariableRef
+
+    def setLocalVariableRef(self, value):
+        self.localVariableRef = value
+        return self
 
 class AutosarParameterRef(ARObject):
     def __init__(self):
@@ -32,16 +96,51 @@ class AtpInstanceRef(ARObject, metaclass=ABCMeta):
             raise NotImplementedError("AtpInstanceRef is an abstract class.")
         
         super().__init__()
-
 class VariableInAtomicSWCTypeInstanceRef(AtpInstanceRef):
     def __init__(self):
         super().__init__()
 
-        self.base_ref = None                            # type: RefType
-        self.context_data_prototype_ref = None          # type: RefType
-        self.port_prototype_ref = None                  # type: RefType
-        self.root_variable_data_prototype_ref = None    # type: RefType
-        self.target_data_prototype_ref = None           # type: RefType
+        self.baseRef = None                             # type: RefType
+        self.contextDataPrototypeRefs = []              # type: List[RefType]
+        self.portPrototypeRef = None                    # type: RefType
+        self.rootVariableDataPrototypeRef = None        # type: RefType
+        self.targetDataPrototypeRef = None              # type: RefType
+
+    def getBaseRef(self):
+        return self.baseRef
+
+    def setBaseRef(self, value):
+        self.baseRef = value
+        return self
+
+    def getContextDataPrototypeRefs(self):
+        return self.contextDataPrototypeRefs
+
+    def addContextDataPrototypeRef(self, value):
+        self.contextDataPrototypeRefs.append(value)
+        return self
+
+    def getPortPrototypeRef(self):
+        return self.portPrototypeRef
+
+    def setPortPrototypeRef(self, value):
+        self.portPrototypeRef = value
+        return self
+
+    def getRootVariableDataPrototypeRef(self):
+        return self.rootVariableDataPrototypeRef
+
+    def setRootVariableDataPrototypeRef(self, value):
+        self.rootVariableDataPrototypeRef = value
+        return self
+
+    def getTargetDataPrototypeRef(self):
+        return self.targetDataPrototypeRef
+
+    def setTargetDataPrototypeRef(self, value):
+        self.targetDataPrototypeRef = value
+        return self
+
 
 class PortInCompositionTypeInstanceRef(AtpInstanceRef, metaclass=ABCMeta):
     def __init__(self):
@@ -89,36 +188,6 @@ class ROperationInAtomicSwcInstanceRef(OperationInAtomicSwcInstanceRef):
         self.context_r_port_ref = None              # type: RefType
         self.target_required_operation_ref = None   # type: RefType
 
-class VariableInAtomicSwcInstanceRef(AtpInstanceRef, metaclass=ABCMeta):
-    def __init__(self):
-        if type(self) == OperationInAtomicSwcInstanceRef:
-            raise NotImplementedError("OperationInAtomicSwcInstanceRef is an abstract class.")
-
-        super().__init__()
-
-class RVariableInAtomicSwcInstanceRef(VariableInAtomicSwcInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.context_r_port_ref = None              # type: RefType
-        self.target_data_element_ref = None         # type: RefType
-
-class RVariableInAtomicSwcInstanceRef(VariableInAtomicSwcInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.context_r_port_ref = None              # type: RefType
-        self.target_data_element_ref = None         # type: RefType
-
-class RModeInAtomicSwcInstanceRef(AtpInstanceRef):
-    def __init__(self):
-        super().__init__()
-
-        self.base_ref = None                                        # type: RefType
-        self.context_mode_declaration_group_prototype_ref = None    # type: RefType
-        self.context_port_ref = None                                # type: RefType
-        self.target_mode_declaration_ref = None                     # type: RefType
-
 class ParameterInAtomicSWCTypeInstanceRef(AtpInstanceRef):
     def __init__(self):
         super().__init__()
@@ -150,8 +219,9 @@ class VariableDataPrototypeInSystemInstanceRef(AtpInstanceRef):
     def __init__(self):
         super().__init__()
 
-        self.baseRef = None                                        # type: RefType
-        self.contextComponentRef = []                              # type: List[RefType]
-        self.contextCompositionRef = None                          # type: RefType
-        self.contextPortRef = None                                 # type: RefType
-        self.targetDataPrototypeRef = None                         # type: RefType 
+        self.base_ref = None                                        # type: RefType
+        self.context_component_refs = []                            # type: List[RefType]
+        self.context_composition_ref = None                         # type: RefType
+        self.context_port_ref = None                                # type: RefType
+        self.target_data_prototype_ref = None                       # type: RefType 
+