canfestival: comparison objdictgen/nodemanager.py

equal deleted inserted replaced

-:44ce74232ccb
+:dac0f9b4e3f8
 UndoBufferLength = 20
 type_model = re.compile('([\_A-Z]*)([0-9]*)')
 range_model = re.compile('([\_A-Z]*)([0-9]*)\[([\-0-9]*)-([\-0-9]*)\]')
-name_model = re.compile('(.*)\[(.*)\]')
+# ID for the file viewed
-def IsOfType(object, typedef):
+CurrentID = 0
-return type(object) == typedef
+# Returns a new id
-#-------------------------------------------------------------------------------
+def GetNewId():
-#                           Formating Name of an Entry
+global CurrentID
-#-------------------------------------------------------------------------------
+CurrentID += 1
+return CurrentID
-"""
-Format the text given with the index and subindex defined
-"""
-def StringFormat(text, idx, sub):
-result = name_model.match(text)
-if result:
-format = result.groups()
-return format[0]%eval(format[1])
-else:
-return text
-#-------------------------------------------------------------------------------
-#                         Search in a Mapping Dictionary
-#-------------------------------------------------------------------------------
-"""
-Return the index of the informations in the Object Dictionary in case of identical
-indexes
-"""
-def FindIndex(index, mappingdictionary):
-if index in mappingdictionary:
-return index
-else:
-listpluri = [idx for idx in mappingdictionary.keys() if mappingdictionary[idx]["struct"] & OD_IdenticalIndexes]
-listpluri.sort()
-for idx in listpluri:
-nb_max = mappingdictionary[idx]["nbmax"]
-incr = mappingdictionary[idx]["incr"]
-if idx < index < idx + incr * nb_max and (index - idx)%incr == 0:
-return idx
-return None
-"""
-Return the index of the typename given by searching in mappingdictionary
-"""
-def FindTypeIndex(typename, mappingdictionary):
-testdic = {}
-for index, values in mappingdictionary.iteritems():
-if index < 0x1000:
-testdic[values["name"]] = index
-if typename in testdic:
-return testdic[typename]
-return None
-"""
-Return the name of the type by searching in mappingdictionary
-"""
-def FindTypeName(typeindex, mappingdictionary):
-if typeindex < 0x1000 and typeindex in mappingdictionary:
-return mappingdictionary[typeindex]["name"]
-return None
-"""
-Return the default value of the type by searching in mappingdictionary
-"""
-def FindTypeDefaultValue(typeindex, mappingdictionary):
-if typeindex < 0x1000 and typeindex in mappingdictionary:
-return mappingdictionary[typeindex]["default"]
-return None
-"""
-Return the list of types defined in mappingdictionary
-"""
-def FindTypeList(mappingdictionary):
-list = []
-for index in mappingdictionary.keys():
-if index < 0x1000:
-list.append((index, mappingdictionary[index]["name"]))
-return list
-"""
-Return the name of an entry by searching in mappingdictionary
-"""
-def FindEntryName(index, mappingdictionary):
-base_index = FindIndex(index, mappingdictionary)
-if base_index:
-infos = mappingdictionary[base_index]
-if infos["struct"] & OD_IdenticalIndexes:
-return StringFormat(infos["name"], (index - base_index) / infos["incr"] + 1, 0)
-else:
-return infos["name"]
-return None
-"""
-Return the informations of one entry by searching in mappingdictionary
-"""
-def FindEntryInfos(index, mappingdictionary):
-base_index = FindIndex(index, mappingdictionary)
-if base_index:
-copy = mappingdictionary[base_index].copy()
-if copy["struct"] & OD_IdenticalIndexes:
-copy["name"] = StringFormat(copy["name"], (index - base_index) / copy["incr"] + 1, 0)
-copy.pop("values")
-return copy
-return None
-"""
-Return the informations of one subentry of an entry by searching in mappingdictionary
-"""
-def FindSubentryInfos(index, subIndex, mappingdictionary):
-base_index = FindIndex(index, mappingdictionary)
-if base_index:
-struct = mappingdictionary[base_index]["struct"]
-if struct & OD_Subindex:
-if struct & OD_IdenticalSubindexes:
-if struct & OD_IdenticalIndexes:
-incr = mappingdictionary[base_index]["incr"]
-else:
-incr = 1
-if subIndex == 0:
-return mappingdictionary[base_index]["values"][0].copy()
-elif 0 < subIndex <= mappingdictionary[base_index]["values"][1]["nbmax"]:
-copy = mappingdictionary[base_index]["values"][1].copy()
-copy["name"] = StringFormat(copy["name"], (index - base_index) / incr + 1, subIndex)
-return copy
-elif struct & OD_MultipleSubindexes and 0 <= subIndex < len(mappingdictionary[base_index]["values"]):
-return mappingdictionary[base_index]["values"][subIndex].copy()
-elif subIndex == 0:
-return mappingdictionary[base_index]["values"][0].copy()
-return None
-"""
-Return the list of variables that can be mapped defined in mappingdictionary
-"""
-def FindMapVariableList(mappingdictionary, Manager):
-list = []
-for index in mappingdictionary.iterkeys():
-if Manager.IsCurrentEntry(index):
-for subIndex, values in enumerate(mappingdictionary[index]["values"]):
-if mappingdictionary[index]["values"][subIndex]["pdo"]:
-infos = Manager.GetEntryInfos(mappingdictionary[index]["values"][subIndex]["type"])
-if mappingdictionary[index]["struct"] & OD_IdenticalSubindexes:
-values = Manager.GetCurrentEntry(index)
-for i in xrange(len(values) - 1):
-list.append((index, i + 1, infos["size"], StringFormat(mappingdictionary[index]["values"][subIndex]["name"],1,i+1)))
-else:
-list.append((index, subIndex, infos["size"], mappingdictionary[index]["values"][subIndex]["name"]))
-return list
-"""
-Return the list of mandatory indexes defined in mappingdictionary
-"""
-def FindMandatoryIndexes(mappingdictionary):
-list = []
-for index in mappingdictionary.iterkeys():
-if index >= 0x1000 and mappingdictionary[index]["need"]:
-list.append(index)
-return list
 """
 Class implementing a buffer of changes made on the current editing Object Dictionary
 """
 """
 Constructor
 """
 def __init__(self, cwd):
 self.LastNewIndex = 0
-self.FilePaths = []
+self.FilePaths = {}
-self.FileNames = []
+self.FileNames = {}
-self.NodeIndex = -1
+self.NodeIndex = None
 self.CurrentNode = None
 self.ScriptDirectory = cwd
-self.UndoBuffers = []
+self.UndoBuffers = {}
 #-------------------------------------------------------------------------------
 #                         Type and Map Variable Lists
 #-------------------------------------------------------------------------------
-"""
-Generate the list of types defined for the current node
-"""
-def GenerateTypeList(self):
-self.TypeList = ""
-self.TypeTranslation = {}
-list = self.GetTypeList()
-sep = ""
-for index, name in list:
-self.TypeList += "%s%s"%(sep,name)
-self.TypeTranslation[name] = index
-sep = ","
-"""
-Generate the list of variables that can be mapped for the current node
-"""
-def GenerateMapList(self):
-self.MapList = "None"
-self.NameTranslation = {"None" : "00000000"}
-self.MapTranslation = {"00000000" : "None"}
-list = self.GetMapVariableList()
-for index, subIndex, size, name in list:
-self.MapList += ",%s"%name
-map = "%04X%02X%02X"%(index,subIndex,size)
-self.NameTranslation[name] = map
-self.MapTranslation[map] = name
 """
 Return the list of types defined for the current node
 """
 def GetCurrentTypeList(self):
-return self.TypeList
+if self.CurrentNode:
+return self.CurrentNode.GetTypeList()
+else:
+return ""
 """
 Return the list of variables that can be mapped for the current node
 """
 def GetCurrentMapList(self):
-return self.MapList
+if self.CurrentNode:
+return self.CurrentNode.GetMapList()
+else:
+return ""
 #-------------------------------------------------------------------------------
 #                        Create Load and Save Functions
 #-------------------------------------------------------------------------------
 elif option == "SaveConfig":
 AddIndexList.extend([0x1010, 0x1011, 0x1020])
 elif option == "StoreEDS":
 AddIndexList.extend([0x1021, 0x1022])
 # Add a new buffer
-self.AddNodeBuffer()
+index = self.AddNodeBuffer()
 self.SetCurrentFilePath("")
 # Add Mandatory indexes
 self.ManageEntriesOfCurrent(AddIndexList, [])
-# Regenerate lists
+return index
-self.GenerateTypeList()
-self.GenerateMapList()
-return True
 else:
 return result
 """
 Load a profile in node
 file = open(filepath, "r")
 node = load(file)
 file.close()
 self.CurrentNode = node
 # Add a new buffer and defining current state
-self.AddNodeBuffer(self.CurrentNode.Copy(), True)
+index = self.AddNodeBuffer(self.CurrentNode.Copy(), True)
 self.SetCurrentFilePath(filepath)
-# Regenerate lists
+return index
-self.GenerateTypeList()
-self.GenerateMapList()
-return True
 """
 Save current node in  a file
 """
 def SaveCurrentInFile(self, filepath = None):
 """
 Import an eds file and store it in a new buffer if no node edited
 """
 def ImportCurrentFromEDSFile(self, filepath):
 # Generate node from definition in a xml file
-result = eds_utils.GenerateNode(filepath, self, self.ScriptDirectory)
+result = eds_utils.GenerateNode(filepath, self.ScriptDirectory)
 if isinstance(result, Node):
 self.CurrentNode = result
-self.GenerateTypeList()
-self.GenerateMapList()
 if len(self.UndoBuffers) == 0:
-self.AddNodeBuffer()
+index = self.AddNodeBuffer()
 self.SetCurrentFilePath("")
 self.BufferCurrentNode()
-return None
+return index
 else:
 return result
 """
 Export to an eds file and store it in a new buffer if no node edited
 infos = self.GetEntryInfos(index)
 if not infos["need"]:
 self.CurrentNode.RemoveEntry(index, subIndex)
 if index in Mappings[-1]:
 self.CurrentNode.RemoveMappingEntry(index, subIndex)
-self.GenerateMapList()
 def AddMapVariableToCurrent(self, index, name, struct, number):
 if 0x2000 <= index <= 0x5FFF:
 if not self.CurrentNode.IsEntry(index):
 self.CurrentNode.AddMappingEntry(index, name = name, struct = struct)
 if struct == var:
-values = {"name" : name, "type" : 5, "access" : "rw", "pdo" : True}
+values = {"name" : name, "type" : 0x05, "access" : "rw", "pdo" : True}
 self.CurrentNode.AddMappingEntry(index, 0, values = values)
 self.CurrentNode.AddEntry(index, 0, 0)
 else:
-values = {"name" : "Number of Entries", "type" : 2, "access" : "ro", "pdo" : False}
+values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False}
 self.CurrentNode.AddMappingEntry(index, 0, values = values)
 if struct == rec:
-values = {"name" : name + " %d[(sub)]", "type" : 5, "access" : "rw", "pdo" : True, "nbmax" : 0xFE}
+values = {"name" : name + " %d[(sub)]", "type" : 0x05, "access" : "rw", "pdo" : True, "nbmax" : 0xFE}
 self.CurrentNode.AddMappingEntry(index, 1, values = values)
 for i in xrange(number):
 self.CurrentNode.AddEntry(index, i + 1, 0)
 else:
 for i in xrange(number):
-values = {"name" : "Undefined", "type" : 5, "access" : "rw", "pdo" : True}
+values = {"name" : "Undefined", "type" : 0x05, "access" : "rw", "pdo" : True}
 self.CurrentNode.AddMappingEntry(index, i + 1, values = values)
 self.CurrentNode.AddEntry(index, i + 1, 0)
-self.GenerateMapList()
 self.BufferCurrentNode()
 return None
 else:
 return "Index 0x%04X already defined!"%index
 else:
 name, valuetype = customisabletypes[type]
 size = self.GetEntryInfos(type)["size"]
 default = self.GetTypeDefaultValue(type)
 if valuetype == 0:
 self.CurrentNode.AddMappingEntry(index, name = "%s[%d-%d]"%(name, min, max), struct = 3, size = size, default = default)
-self.CurrentNode.AddMappingEntry(index, 0, values = {"name" : "Number of Entries", "type" : 0x02, "access" : "ro", "pdo" : False})
+self.CurrentNode.AddMappingEntry(index, 0, values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False})
-self.CurrentNode.AddMappingEntry(index, 1, values = {"name" : "Type", "type" : 0x02, "access" : "ro", "pdo" : False})
+self.CurrentNode.AddMappingEntry(index, 1, values = {"name" : "Type", "type" : 0x05, "access" : "ro", "pdo" : False})
 self.CurrentNode.AddMappingEntry(index, 2, values = {"name" : "Minimum Value", "type" : type, "access" : "ro", "pdo" : False})
 self.CurrentNode.AddMappingEntry(index, 3, values = {"name" : "Maximum Value", "type" : type, "access" : "ro", "pdo" : False})
 self.CurrentNode.AddEntry(index, 1, type)
 self.CurrentNode.AddEntry(index, 2, min)
 self.CurrentNode.AddEntry(index, 3, max)
 elif valuetype == 1:
 self.CurrentNode.AddMappingEntry(index, name = "%s%d"%(name, length), struct = 3, size = length * size, default = default)
-self.CurrentNode.AddMappingEntry(index, 0, values = {"name" : "Number of Entries", "type" : 0x02, "access" : "ro", "pdo" : False})
+self.CurrentNode.AddMappingEntry(index, 0, values = {"name" : "Number of Entries", "type" : 0x05, "access" : "ro", "pdo" : False})
-self.CurrentNode.AddMappingEntry(index, 1, values = {"name" : "Type", "type" : 0x02, "access" : "ro", "pdo" : False})
+self.CurrentNode.AddMappingEntry(index, 1, values = {"name" : "Type", "type" : 0x05, "access" : "ro", "pdo" : False})
-self.CurrentNode.AddMappingEntry(index, 2, values = {"name" : "Length", "type" : 0x02, "access" : "ro", "pdo" : False})
+self.CurrentNode.AddMappingEntry(index, 2, values = {"name" : "Length", "type" : 0x05, "access" : "ro", "pdo" : False})
 self.CurrentNode.AddEntry(index, 1, type)
 self.CurrentNode.AddEntry(index, 2, length)
-self.GenerateTypeList()
 self.BufferCurrentNode()
 return None
 else:
 return "Too many User Types have already been defined!"
 def SetCurrentEntry(self, index, subIndex, value, name, editor):
 if self.CurrentNode and self.CurrentNode.IsEntry(index):
 if name == "value":
 if editor == "map":
-try:
+value = self.CurrentNode.GetMapValue(value)
-value = int(self.NameTranslation[value], 16)
+if value:
 self.CurrentNode.SetEntry(index, subIndex, value)
-except:
-pass
 elif editor == "bool":
 value = value == "True"
 self.CurrentNode.SetEntry(index, subIndex, value)
 elif editor == "time":
 self.CurrentNode.SetEntry(index, subIndex, value)
 self.CurrentNode.SetParamsEntry(index, subIndex, save = value)
 elif name == "comment":
 self.CurrentNode.SetParamsEntry(index, subIndex, comment = value)
 else:
 if editor == "type":
-value = self.TypeTranslation[value]
+value = self.GetTypeIndex(value)
 size = self.GetEntryInfos(value)["size"]
 self.CurrentNode.UpdateMapVariable(index, subIndex, size)
 elif editor in ["access","raccess"]:
 dic = {}
 for abbrev,access in AccessType.iteritems():
 entry_infos = self.GetEntryInfos(index)
 self.CurrentNode.AddMappingEntry(index, name = entry_infos["name"], struct = 7)
 self.CurrentNode.AddMappingEntry(index, 0, values = self.GetSubentryInfos(index, 0, False).copy())
 self.CurrentNode.AddMappingEntry(index, 1, values = self.GetSubentryInfos(index, 1, False).copy())
 self.CurrentNode.SetMappingEntry(index, subIndex, values = {name : value})
-if name == "name" or editor == "type":
-self.GenerateMapList()
 self.BufferCurrentNode()
 def SetCurrentEntryName(self, index, name):
 self.CurrentNode.SetMappingEntry(index, name=name)
 self.BufferCurrentNode()
 def CurrentIsSaved(self):
 return self.UndoBuffers[self.NodeIndex].IsCurrentSaved()
 def OneFileHasChanged(self):
 result = False
-for buffer in self.UndoBuffers:
+for buffer in self.UndoBuffers.values():
 result |= not buffer.IsCurrentSaved()
 return result
 def GetBufferNumber(self):
 return len(self.UndoBuffers)
 def LoadCurrentNext(self):
 self.CurrentNode = self.UndoBuffers[self.NodeIndex].Next().Copy()
 def AddNodeBuffer(self, currentstate = None, issaved = False):
-self.NodeIndex = len(self.UndoBuffers)
+self.NodeIndex = GetNewId()
-self.UndoBuffers.append(UndoBuffer(currentstate, issaved))
+self.UndoBuffers[self.NodeIndex] = UndoBuffer(currentstate, issaved)
-self.FilePaths.append("")
+self.FilePaths[self.NodeIndex] = ""
-self.FileNames.append("")
+self.FileNames[self.NodeIndex] = ""
+return self.NodeIndex
 def ChangeCurrentNode(self, index):
-if index < len(self.UndoBuffers):
+if index in self.UndoBuffers.keys():
 self.NodeIndex = index
 self.CurrentNode = self.UndoBuffers[self.NodeIndex].Current().Copy()
-self.GenerateTypeList()
-self.GenerateMapList()
 def RemoveNodeBuffer(self, index):
 self.UndoBuffers.pop(index)
 self.FilePaths.pop(index)
 self.FileNames.pop(index)
-self.NodeIndex = min(self.NodeIndex, len(self.UndoBuffers) - 1)
-if len(self.UndoBuffers) > 0:
-self.CurrentNode = self.UndoBuffers[self.NodeIndex].Current().Copy()
-self.GenerateTypeList()
-self.GenerateMapList()
-else:
-self.CurrentNode = None
 def GetCurrentNodeIndex(self):
 return self.NodeIndex
 def GetCurrentFilename(self):
 return self.GetFilename(self.NodeIndex)
 def GetAllFilenames(self):
-filenames = []
+indexes = self.UndoBuffers.keys()
-for i in xrange(len(self.UndoBuffers)):
+indexes.sort()
-filenames.append(self.GetFilename(i))
+return [self.GetFilename(idx) for idx in indexes]
-return filenames
 def GetFilename(self, index):
 if self.UndoBuffers[index].IsCurrentSaved():
 return self.FileNames[index]
 else:
 return False
 #-------------------------------------------------------------------------------
 #                         Node State and Values Functions
 #-------------------------------------------------------------------------------
+def GetCurrentNodeName(self):
+if self.CurrentNode:
+return self.CurrentNode.GetNodeName()
+else:
+return ""
+def GetCurrentNodeID(self):
+if self.CurrentNode:
+return self.CurrentNode.GetNodeID()
+else:
+return None
 def GetCurrentNodeInfos(self):
 name = self.CurrentNode.GetNodeName()
 id = self.CurrentNode.GetNodeID()
 type = self.CurrentNode.GetNodeType()
 return entry_infos["callback"]
 return self.CurrentNode.HasEntryCallbacks(index)
 return False
 def GetCurrentEntryValues(self, index):
-if self.CurrentNode and self.CurrentNode.IsEntry(index):
+if self.CurrentNode:
-entry_infos = self.GetEntryInfos(index)
+return self.GetNodeEntryValues(self.CurrentNode, index)
+def GetNodeEntryValues(self, node, index):
+if node and node.IsEntry(index):
+entry_infos = node.GetEntryInfos(index)
 data = []
 editors = []
-values = self.CurrentNode.GetEntry(index)
+values = node.GetEntry(index)
-params = self.CurrentNode.GetParamsEntry(index)
+params = node.GetParamsEntry(index)
 if type(values) == ListType:
 for i, value in enumerate(values):
 data.append({"value" : value})
 data[-1].update(params[i])
 else:
 data.append({"value" : values})
 data[-1].update(params)
 for i, dic in enumerate(data):
-infos = self.GetSubentryInfos(index, i)
+infos = node.GetSubentryInfos(index, i)
 dic["subindex"] = "0x%02X"%i
 dic["name"] = infos["name"]
-dic["type"] = self.GetTypeName(infos["type"])
+dic["type"] = node.GetTypeName(infos["type"])
 dic["access"] = AccessType[infos["access"]]
 dic["save"] = OptionType[dic["save"]]
 editor = {"subindex" : None, "save" : "option", "callback" : "option", "comment" : "string"}
 if type(values) == ListType and i == 0:
 editor["name"] = None
 editor["type"] = None
 editor["access"] = None
 if index < 0x260:
 editor["value"] = None
 if i == 1:
-dic["value"] = self.GetTypeName(dic["value"])
+dic["value"] = node.GetTypeName(dic["value"])
 elif 0x1600 <= index <= 0x17FF or 0x1A00 <= index <= 0x1C00:
 editor["value"] = "map"
-dic["value"] = self.MapTranslation["%08X"%dic["value"]]
+dic["value"] = node.GetMapName(dic["value"])
 else:
 if dic["type"].startswith("VISIBLE_STRING"):
 editor["value"] = "string"
 elif dic["type"] in ["TIME_OF_DAY","TIME_DIFFERENCE"]:
 editor["value"] = "time"
 editor["max"] = values[3]
 editors.append(editor)
 return data, editors
 else:
 return None
 #-------------------------------------------------------------------------------
 #                         Node Informations Functions
 #-------------------------------------------------------------------------------
 def GetCustomisedTypeValues(self, index):
-values = self.CurrentNode.GetEntry(index)
+if self.CurrentNode:
-customisabletypes = self.GetCustomisableTypes()
+values = self.CurrentNode.GetEntry(index)
-return values, customisabletypes[values[1]][1]
+customisabletypes = self.GetCustomisableTypes()
+return values, customisabletypes[values[1]][1]
-def GetEntryName(self, index, node = None):
+else:
-result = None
+return None, None
-if node == None:
-node = self.CurrentNode
+def GetEntryName(self, index):
-NodeMappings = node.GetMappings()
+if self.CurrentNode:
-i = 0
+return self.CurrentNode.GetEntryName(index)
-while not result and i < len(NodeMappings):
+else:
-result = FindEntryName(index, NodeMappings[i])
+return FindEntryName(index, MappingDictionary)
-i += 1
-if result == None:
+def GetEntryInfos(self, index):
-result = FindEntryName(index, MappingDictionary)
+if self.CurrentNode:
-return result
+return self.CurrentNode.GetEntryInfos(index)
+else:
-def GetEntryInfos(self, index, node = None):
+return FindEntryInfos(index, MappingDictionary)
-result = None
-if node == None:
+def GetSubentryInfos(self, index, subindex):
-node = self.CurrentNode
+if self.CurrentNode:
-NodeMappings = node.GetMappings()
+return self.CurrentNode.GetSubentryInfos(index, subindex)
-i = 0
+else:
-while not result and i < len(NodeMappings):
+result = FindSubentryInfos(index, subindex, MappingDictionary)
-result = FindEntryInfos(index, NodeMappings[i])
-i += 1
-if result == None:
-result = FindEntryInfos(index, MappingDictionary)
-return result
-def GetSubentryInfos(self, index, subIndex, node = None):
-result = None
-if node == None:
-node = self.CurrentNode
-NodeMappings = node.GetMappings()
-i = 0
-while not result and i < len(NodeMappings):
-result = FindSubentryInfos(index, subIndex, NodeMappings[i])
-if result:
-result["user_defined"] = i == len(NodeMappings) - 1 and index >= 0x1000
-i += 1
-if result == None:
-result = FindSubentryInfos(index, subIndex, MappingDictionary)
 if result:
 result["user_defined"] = False
 return result
-def GetTypeIndex(self, typename, node = None):
+def GetTypeIndex(self, typename):
-result = None
+if self.CurrentNode:
-if node == None:
+return self.CurrentNode.GetTypeIndex(typename)
-node = self.CurrentNode
+else:
-NodeMappings = node.GetMappings()
+return FindTypeIndex(typename, MappingDictionary)
-i = 0
-while not result and i < len(NodeMappings):
+def GetTypeName(self, typeindex):
-result = FindTypeIndex(typename, NodeMappings[i])
+if self.CurrentNode:
-i += 1
+return self.CurrentNode.GetTypeName(typeindex)
-if result == None:
+else:
-result = FindTypeIndex(typename, MappingDictionary)
+return FindTypeName(typeindex, MappingDictionary)
-return result
+def GetTypeDefaultValue(self, typeindex):
-def GetTypeName(self, typeindex, node = None):
+if self.CurrentNode:
-result = None
+return self.CurrentNode.GetTypeDefaultValue(typeindex)
-if node == None:
+else:
-node = self.CurrentNode
+return FindTypeDefaultValue(typeindex, MappingDictionary)
-NodeMappings = node.GetMappings()
-i = 0
+def GetMapVariableList(self):
-while not result and i < len(NodeMappings):
+if self.CurrentNode:
-result = FindTypeName(typeindex, NodeMappings[i])
+return self.CurrentNode.GetMapVariableList()
-i += 1
+else:
-if result == None:
+return []
-result = FindTypeName(typeindex, MappingDictionary)
-return result
-def GetTypeDefaultValue(self, typeindex, node = None):
-result = None
-if node == None:
-node = self.CurrentNode
-if node:
-NodeMappings = node.GetMappings()
-i = 0
-while not result and i < len(NodeMappings):
-result = FindTypeDefaultValue(typeindex, NodeMappings[i])
-i += 1
-if result == None:
-result = FindTypeDefaultValue(typeindex, MappingDictionary)
-return result
-def GetTypeList(self, node = None):
-list = FindTypeList(MappingDictionary)
-if node == None:
-node = self.CurrentNode
-for NodeMapping in self.CurrentNode.GetMappings():
-list.extend(FindTypeList(NodeMapping))
-list.sort()
-return list
-def GetMapVariableList(self, node = None):
-list = FindMapVariableList(MappingDictionary, self)
-if node == None:
-node = self.CurrentNode
-for NodeMapping in node.GetMappings():
-list.extend(FindMapVariableList(NodeMapping, self))
-list.sort()
-return list
 def GetMandatoryIndexes(self, node = None):
-list = FindMandatoryIndexes(MappingDictionary)
+if self.CurrentNode:
-if node == None:
+return self.CurrentNode.GetMapVariableList()
-node = self.CurrentNode
+else:
-for NodeMapping in node.GetMappings():
+return FindMandatoryIndexes(MappingDictionary)
-list.extend(FindMandatoryIndexes(NodeMapping))
-return list
 def GetCustomisableTypes(self):
 dic = {}
 for index, valuetype in CustomisableTypes:
 name = self.GetTypeName(index)

changeset 205	dac0f9b4e3f8
parent 188	00245bc2e6fe
child 220	b7fb826c66d9