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

armodel/__init__.py

@@ -1,2 +1,3 @@
 from .models import *
-from .parser import ARXMLParser
+from .parser import *
+from .writer import *

armodel/cli/arxml_dump_cli.py

@@ -35,12 +35,12 @@ def show_type(indent: int, data_type: ImplementationDataType):
     print("%s-Implementation Type: %s (%s)" % (" " * indent, data_type.short_name, data_type.parent.full_name))
     print("%s                    : %s" % (" " * indent, data_type.category))
     if (data_type.sw_data_def_props != None):
-        if (data_type.sw_data_def_props.base_type_ref != None):
-            base_type_ref = data_type.sw_data_def_props.base_type_ref
+        if (data_type.sw_data_def_props.baseTypeRef != None):
+            base_type_ref = data_type.sw_data_def_props.baseTypeRef
             print("%s                    : %s (%s)" % (" " * indent, base_type_ref.value, base_type_ref.dest))
             
-        if (data_type.sw_data_def_props.implementation_data_type_ref != None):
-            implementation_data_type_ref = data_type.sw_data_def_props.implementation_data_type_ref
+        if (data_type.sw_data_def_props.implementationDataTypeRef != None):
+            implementation_data_type_ref = data_type.sw_data_def_props.implementationDataTypeRef
             print("%s                    : %s (%s)" % (" " * indent, implementation_data_type_ref.value, implementation_data_type_ref.dest))
 
 def show_data_type_mapping(indent: int, mapping_set: DataTypeMappingSet):
@@ -104,8 +104,8 @@ def show_bsw_internal_behavior(indent: int, behavior: BswInternalBehavior):
 
     for event in behavior.getBswTimingEvents():
         print("%s-%s" % (" " * (indent + 2), event.short_name))
-        print("%s-%s: %s" % (" " * (indent + 4), "StartsOnEventRef", event.starts_on_event_ref.value))
-        starts_on_event = document.find(event.starts_on_event_ref.value) # type: BswModuleEntity
+        print("%s-%s: %s" % (" " * (indent + 4), "StartsOnEventRef", event.startsOnEventRef.value))
+        starts_on_event = document.find(event.startsOnEventRef.value) # type: BswModuleEntity
         print("%s-%s: %s" % (" " * (indent + 4), "StartsOnEvent", starts_on_event.short_name))
         print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntryRef", starts_on_event.implemented_entry_ref.value))
         implemented_entry = document.find(starts_on_event.implemented_entry_ref.value) # type: BswModuleEntry
@@ -121,6 +121,8 @@ def show_bsw_module_description(indent: int, description: BswModuleDescription):
 def show_ar_package(indent: int, ar_package: ARPackage):
     print("%s-%s (Pkg)" % (" " * indent, ar_package.short_name))
      
+    for sub_package in ar_package.getARPackages():
+        show_ar_package(indent + 2, sub_package)
     #for data_type in ar_package.getImplementationDataTypes():
     #    show_type(indent + 2, data_type)
     #for mapping_set in ar_package.getDataTypeMappingSets():

armodel/cli/arxml_format_cli.py

@@ -0,0 +1,72 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+
+from ..models.ar_package import AUTOSAR
+from ..parser.arxml_parser import ARXMLParser
+from ..parser.connector_xlsx_parser import ConnectorXlsReader
+
+from ..lib import InputFileParser
+from ..writer import ARXMLWriter
+
+def main():
+    version = pkg_resources.require("armodel")[0].version
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-v", "--verbose", required= False, help= "Print debug information", action= "store_true")
+    ap.add_argument("-w", "--warning", required= False, help= "Skip the error and report it as warning message", action= "store_true")
+    ap.add_argument("INPUT", help = "The path of AUTOSAR ARXML file")
+    ap.add_argument("OUTPUT", help = "The path of output ARXML file")
+
+    args = ap.parse_args()
+
+    logger = logging.getLogger()
+    
+    formatter = logging.Formatter('[%(levelname)s] : %(message)s')
+
+    stdout_handler = logging.StreamHandler(sys.stderr)
+    stdout_handler.setFormatter(formatter)
+
+    base_path = os.path.dirname(args.OUTPUT)
+    log_file = os.path.join(base_path, 'arxml_format.log')
+
+    if os.path.exists(log_file):
+        os.remove(log_file)
+
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setFormatter(formatter)
+
+    logger.setLevel(logging.DEBUG)
+    file_handler.setLevel(logging.DEBUG)
+
+    if args.verbose:
+        stdout_handler.setLevel(logging.DEBUG)
+        
+    else:
+        stdout_handler.setLevel(logging.INFO)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(stdout_handler)    
+
+    try:
+        options = {}
+        if args.warning:
+            options['warning'] = True
+
+        document = AUTOSAR().getInstance()
+        parser = ARXMLParser(options)
+        parser.load(args.INPUT, document)
+
+        writer = ARXMLWriter()
+        writer.save(args.OUTPUT, document)
+        
+    except Exception as e:
+        #print(e)
+        logger.error(e)
+        raise e
+
+if __name__ == "__main__":
+    main()

armodel/cli/connector_update_cli.py

@@ -4,8 +4,10 @@ import logging
 import sys
 import os.path
 
-from armodel import AUTOSAR
-from armodel.parser import ARXMLParser
+
+from ..models.ar_package import AUTOSAR
+from ..parser.arxml_parser import ARXMLParser
+from ..parser.connector_xlsx_parser import ConnectorXlsReader
 
 from ..lib import InputFileParser
 from ..writer import ARXMLWriter
@@ -16,9 +18,9 @@ def main():
     ap = argparse.ArgumentParser()
     ap.add_argument("-v", "--verbose", required= False, help= "Print debug information", action= "store_true")
     ap.add_argument("-w", "--warning", required= False, help= "Skip the error and report it as warning message", action= "store_true")
-    ap.add_argument("INPUT", help = "The path of AUTOSAR ARXML file")
+    ap.add_argument("INPUT", help = "The path of input ARXML file")
     ap.add_argument("MAPPING", help = "The path of connector excel file which exports with connector2xlsx")
-    ap.add_argument("OUTPUT", help = "The path of output excel file")
+    ap.add_argument("OUTPUT", help = "The path of output ARXML file")
 
     args = ap.parse_args()
 
@@ -59,11 +61,16 @@ def main():
         parser = ARXMLParser(options)
         parser.load(args.INPUT, document)
 
+        reader = ConnectorXlsReader()
+        reader.read(args.MAPPING)
+        reader.update(document)
+
         writer = ARXMLWriter()
         writer.save(args.OUTPUT, document)
         
     except Exception as e:
         #print(e)
+        logger.error(e)
         raise e
 
 if __name__ == "__main__":

armodel/data_models/sw_connector.py

@@ -0,0 +1,22 @@
+class SwConnectorData:
+    def __init__(self) -> None:
+        self.short_name = ""
+
+class DelegationSwConnectorData(SwConnectorData):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.inner_swc = ""
+        self.inner_pport = ""
+        self.inner_rport = ""
+        self.outer_pport = ""
+        self.outer_rport = ""
+
+class AssemblySwConnectorData(SwConnectorData):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.provider_swc= ""
+        self.pport = ""
+        self.requester_swc = ""
+        self.rport = ""        

armodel/lib/data_analyzer.py

@@ -29,6 +29,6 @@ class SwComponentAnalyzer:
 
         for swc in sorted(swc_list, key = lambda o: o.short_name):
             if option['format'] == 'long':
-                logger.info("%s (%s)" % (swc.full_name, type(swc)))
+                logger.info("%s" % swc.full_name)
             else:
                 logger.info("%s" % swc.short_name)

armodel/models/__init__.py

@@ -1,7 +1,9 @@
+from .annotation import *
+from .ar_object import *
 from .general_structure import *
 from .common_structure import *
 from .sw_component import *
-from .ar_package import ARPackage, AUTOSAR
+from .ar_package import *
 from .ar_ref import *
 from .datatype import *
 from .port_prototype import * 
@@ -13,6 +15,5 @@ from .implementation import *
 from .bsw_module_template import *
 from .communication import *
 from .calibration import *
-from .ar_object import *
 from .global_constraints import *
 from .unit import *

armodel/models/annotation.py

@@ -0,0 +1,20 @@
+
+from abc import ABCMeta
+
+from .multilanguage_data import MultilanguageLongName
+from .ar_object import ARObject
+
+
+class GeneralAnnotation(ARObject, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == ARObject:
+            raise NotImplementedError("GeneralAnnotation is an abstract class.")
+        
+        self.label = None       # type: MultilanguageLongName
+
+        super().__init__()
+
+class Annotation(GeneralAnnotation):
+    def __init__(self):
+        super().__init__()
+

armodel/models/ar_object.py

@@ -1,5 +1,9 @@
 from abc import ABCMeta
-from typing import List
+import re
+from typing import Dict, List
+
+import xml.etree.cElementTree as ET
+
 
 class ARObject(metaclass=ABCMeta):
     def __init__(self):
@@ -12,38 +16,179 @@ class ARObject(metaclass=ABCMeta):
         self.timestamp = None           # type: str
         self.uuid = None                # type: str
 
-
+    def getTagName(self, tag: str, nsmap: Dict) -> str:
+        return tag.replace("{%s}" % nsmap["xmlns"], "")
+    
 class ARType(metaclass=ABCMeta):
     def __init__(self) -> None:
         self.timestamp = None           # type: str   
         self.uuid = None                # type: str
+        self._value = None              
 
-class ARBoolean(ARType):
-    def __init__(self) -> None:
-        super().__init__()              
+    @property
+    def value(self):
+        return self._value
+    
+    @value.setter
+    def value(self, val):
+        self._value = val
+
+    def getValue(self):
+        return self.value
+    
+    def setValue(self, val):
+        self.value = val
 
-        self.value = ""                 # type: bool
+    def getText(self) -> str:
+        return str(self)
+
+        
 class ARLiteral(ARType):
     def __init__(self) -> None:
         super().__init__()              
 
-        self.value = ""                 # type: str
+    @property
+    def value(self) -> str:
+        if self._value is None:
+            return ""
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, str):
+            self._value = val
+        else:
+            self._value = str(val)
+    
+    def __str__(self) -> str:
+        return self.value
+    
+    def upper(self) -> str:
+        return self.value.upper()
 
-class LLongName(ARObject):
-    def __init__(self):
+class ARNumerical(ARType):
+    def __init__(self) -> None:
         super().__init__()
 
-        self.l = ""
-        self.value = ""
+        self._text = None                   # type: str
 
-class MultilanguageLongName(ARObject):
-    def __init__(self):
+    def _convertStringToNumberValue(self, value: str) -> int:
+        m = re.match(r"0x([0-9a-f]+)", value, re.I)
+        if (m):
+            return int(m.group(1), 16)
+        return int(value)
+    
+    @property
+    def value(self) -> int:
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, int):
+            self._value = val
+        elif isinstance(val, str):
+            self._text = val
+            self._value = self._convertStringToNumberValue(val)
+        else:
+            raise ValueError("Unsupported Type <%s>", type(val))
+
+    def __str__(self) -> str:
+        if self._text is not None:
+            return self._text
+        else:
+            return str(self._value)
+    
+class ARPositiveInteger(ARNumerical):
+    def __init__(self) -> None:
         super().__init__()
 
-        self.l4 = []        # type：List[LLongName]
+    @property
+    def value(self) -> int:
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, int):
+            if val < 0:
+                raise ValueError("Invalid Positive Integer <%s>" % val)
+            self._value = val
+        elif isinstance(val, str):
+            self._text = val
+            self._value = self._convertStringToNumberValue(val)
+        else:
+            raise ValueError("Unsupported Type <%s>", type(val))
+
+class ARFloat(ARType):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._text = None                   # type: str
+
+    @property
+    def value(self) -> float:
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, float):
+            self._value = val
+        elif isinstance(val, int):
+            self._value = val * 1.0
+        elif isinstance(val, str):
+            self._text = val
+            self._value = float(val)
+        else:
+            raise ValueError("Unsupported Type <%s>", type(val))
+
+    def __str__(self) -> str:
+        if self._text is not None:
+            return self._text
+        else:
+            return str(self._value)
+        
+class ARBoolean(ARType):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._text = None   
+
+    def _convertNumberToBoolean(self, value: int) -> bool:
+        if value == 0:
+            return False
+        return True
+
+    def _convertStringToBoolean(self, value: str) -> bool:
+        value = value.lower()
+        if value == "true":
+            return True
+        elif value == "false":
+            return False
+        else:
+            return self._convertNumberToBoolean(int(value))
 
-    def add_l4(self, l4: LLongName):
-        self.l4.append(l4)
+    @property
+    def value(self) -> int:
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, bool):
+            self._value = val
+        elif isinstance(val, int):
+            self._value = self._convertNumberToBoolean(val)
+            self._text = str(val)
+        elif isinstance(val, str):
+            self._text = val
+            self._value = self._convertStringToBoolean(val)
+        else:
+            raise ValueError("Unsupported Type <%s>", type(val))
 
-    def get_l4s(self) -> List[LLongName]:
-        return self.l4
+    def __str__(self) -> str:
+        if self._text is not None:
+            return self._text
+        else:
+            if self._value:
+                return "true"
+            else:
+                return "false"
+                

armodel/models/ar_package.py

@@ -1,12 +1,16 @@
-from typing import List
+from typing import Dict, List
 
+from .data_dictionary import SwAddrMethod
+from .record_layout import SwRecordLayout
+from .end_to_end_protection import EndToEndProtectionSet
 from .unit import Unit
 from .general_structure import Identifiable, ARObject, Referrable, CollectableElement, SwcBswMapping
-from .port_interface import SenderReceiverInterface, ClientServerInterface
-from .sw_component import SwComponentType, EcuAbstractionSwComponentType, AtomicSwComponentType, ApplicationSwComponentType, ServiceSwComponentType, CompositionSwComponentType, SensorActuatorSwComponentType
-from .datatype import ImplementationDataType, ApplicationDataType, DataTypeMappingSet, DataTypeMap, SwBaseType, ApplicationPrimitiveDataType, ApplicationRecordDataType
+from .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
+from .common_structure import ConstantSpecification, ModeDeclarationGroup
 from .implementation import BswImplementation, SwcImplementation, Implementation
 from .bsw_module_template import BswModuleDescription, BswModuleEntry
 from .global_constraints import DataConstr
@@ -16,14 +20,28 @@ class ARPackage(Identifiable, CollectableElement):
         Identifiable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
 
+        self._ar_packages = {}      # type: Dict[str, ARPackage]
+
     def getARPackages(self):    # type: (...) -> List[ARPackage]
-        return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
+        return list(sorted(self._ar_packages.values(), key= lambda a: a.short_name))
+        #return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
 
     def createARPackage(self, short_name: str):
+        '''
         if (short_name not in self.elements):
             ar_package = ARPackage(self, short_name)
             self.elements[short_name] = ar_package
         return self.elements[short_name]
+        '''
+        if short_name not in self._ar_packages:
+            ar_package = ARPackage(self, short_name)
+            self._ar_packages[short_name] = ar_package
+        return self._ar_packages[short_name]
+    
+    def getElement(self, short_name: str) -> Referrable:
+        if (short_name in self._ar_packages):
+            return self._ar_packages[short_name]
+        return CollectableElement.getElement(self, short_name)
 
     def createEcuAbstractionSwComponentType(self, short_name: str) -> EcuAbstractionSwComponentType:
         if (short_name not in self.elements):
@@ -32,10 +50,16 @@ class ARPackage(Identifiable, CollectableElement):
         return self.elements[short_name]
 
     def createApplicationSwComponentType(self, short_name: str) -> ApplicationSwComponentType:
-        if (short_name not in self.elements):
+        if short_name not in self.elements:
             sw_component = ApplicationSwComponentType(self, short_name)
             self.elements[short_name] = sw_component
         return self.elements[short_name]
+    
+    def createComplexDeviceDriverSwComponentType(self, short_name: str) -> ComplexDeviceDriverSwComponentType:
+        if short_name not in self.elements:
+            sw_component = ComplexDeviceDriverSwComponentType(self, short_name)
+            self.elements[short_name] = sw_component
+        return self.elements[short_name]
 
     def createServiceSwComponentType(self, short_name: str) -> ServiceSwComponentType:
         if (short_name not in self.elements):
@@ -150,6 +174,48 @@ class ARPackage(Identifiable, CollectableElement):
             spec = Unit(self, short_name)
             self.elements[short_name] = spec
         return self.elements[short_name]
+    
+    def createEndToEndProtectionSet(self, short_name: str) -> EndToEndProtectionSet:
+        if (short_name not in self.elements):
+            spec = EndToEndProtectionSet(self, short_name)
+            self.elements[short_name] = spec
+        return self.elements[short_name]
+    
+    def createApplicationArrayDataType(self, short_name: str) -> ApplicationArrayDataType:
+        if (short_name not in self.elements):
+            spec = ApplicationArrayDataType(self, short_name)
+            self.elements[short_name] = spec
+        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
+        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
+        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
+        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
+        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
+        return self.elements[short_name]
 
     def getApplicationPrimitiveDataTypes(self) -> List[ApplicationPrimitiveDataType]:
         return list(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()))
@@ -174,6 +240,9 @@ class ARPackage(Identifiable, CollectableElement):
 
     def getCompositionSwComponentTypes(self) -> List[CompositionSwComponentType]:
         return list(filter(lambda a : isinstance(a, CompositionSwComponentType), self.elements.values()))
+    
+    def getComplexDeviceDriverSwComponentTypes(self) -> List[ComplexDeviceDriverSwComponentType]:
+        return list(sorted(filter(lambda a : isinstance(a, ComplexDeviceDriverSwComponentType), self.elements.values()), key = lambda a: a.short_name))
 
     def getSenderReceiverInterfaces(self) -> List[SenderReceiverInterface]:
         return list(filter(lambda a : isinstance(a, SenderReceiverInterface), self.elements.values()))
@@ -213,6 +282,24 @@ class ARPackage(Identifiable, CollectableElement):
     
     def getUnits(self) -> List[Unit]:
         return list(filter(lambda a: isinstance(a, Unit), self.elements.values()))
+    
+    def getApplicationArrayDataTypes(self) -> List[ApplicationArrayDataType]:
+        return list(sorted(filter(lambda a : isinstance(a, ApplicationArrayDataType), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSwRecordLayouts(self) -> List[SwRecordLayout]:
+        return list(sorted(filter(lambda a : isinstance(a, SwRecordLayout), self.elements.values()), key = lambda a: a.short_name))
+
+    def getSwAddrMethods(self) -> List[SwAddrMethod]:
+        return list(sorted(filter(lambda a : isinstance(a, SwAddrMethod), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getTriggerInterfaces(self) -> List[TriggerInterface]:
+        return list(sorted(filter(lambda a : isinstance(a, TriggerInterface), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getModeDeclarationGroups(self) -> List[ModeDeclarationGroup]:
+        return list(sorted(filter(lambda a : isinstance(a, ModeDeclarationGroup), self.elements.values()), key = lambda a: a.short_name))
+    
+    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):
     __instance = None
@@ -228,26 +315,35 @@ class AUTOSAR (CollectableElement):
             raise Exception("The AUTOSAR is singleton!")
         CollectableElement.__init__(self)
 
-        self.version = "4.3.0"
+        self.schema_location = ""
         self._appl_impl_type_maps = {}
         self._impl_appl_type_maps = {}
         AUTOSAR.__instance = self
 
+        self._ar_packages = {}          # type: Dict[str, ARPackage]
+
     @property
     def full_name(self):
         return ""
 
     def clear(self):
+        self._ar_packages = {}
         self.elements = {}
 
+    def getElement(self, short_name: str) -> Referrable:
+        if (short_name in self._ar_packages):
+            return self._ar_packages[short_name]
+        return CollectableElement.getElement(self, short_name)
+
     def getARPackages(self) -> List[ARPackage]:
-        return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
+        #return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
+        return list(sorted(self._ar_packages.values(), key= lambda a: a.short_name))
 
     def createARPackage(self, short_name: str) -> ARPackage:
-        if (short_name not in self.elements):
+        if (short_name not in self._ar_packages):
             ar_package = ARPackage(self, short_name)
-            self.elements[short_name] = ar_package
-        return self.elements[short_name]
+            self._ar_packages[short_name] = ar_package
+        return self._ar_packages[short_name]
 
     def find(self, referred_name: str) -> Referrable:
         short_name_list = referred_name.split("/")
@@ -264,11 +360,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.implementation_data_type_ref.value)
+                referred_type = self.find(data_type.sw_data_def_props.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.base_type_ref.value)
+                    referred_type = self.find(data_type.sw_data_def_props.sw_pointer_target_props.sw_data_def_props.baseTypeRef.value)
                     return self.getDataType(referred_type)
             return data_type
         else: