12 #modify it under the terms of the GNU Lesser General Public

    12 #modify it under the terms of the GNU General Public

    21 #You should have received a copy of the GNU Lesser General Public

    21 #You should have received a copy of the GNU General Public

    25 from xml.parsers import expat

    25 from xmlclass import *

    26 from minixsv import pyxsval

    27 from random import *

    28 

    29 from types import *

    30 from datetime import *

    31 

    32 import sys,re

    33 

    34 classes = {}

    35 TimeType = time(0,0,0).__class__

    36 DateType = date(1,1,1).__class__

    37 DateTimeType = datetime(1,1,1,0,0,0).__class__

    64 """

    45 PLCOpenClasses = {}

    65 pyxsval is not complete and the parts that are not supported print some error

    46 PLCOpenTypes = {}

    66 reports. This class is used for not displaying them

    47 GenerateClassesFromXSD("plcopen/TC6_XML_V10_B.xsd")

    67 """

    48 CreateClasses(PLCOpenClasses, PLCOpenTypes)

    68 class HolePseudoFile:

    49 

    69     """ Base class for file like objects to facilitate StdOut for the Shell."""

    50 if "dataType" in PLCOpenClasses:

    70     def __init__(self, output = None):

    51     cls = PLCOpenClasses["dataType"]

    71         if output is None: output = []

    52     cls.value = None

    72         self.output = output

    53     

    73 

    54     def getValue(self):

    74     def writelines(self, l):

    55         return self.value

    75         map(self.write, l)

    56     setattr(cls, "getValue", getValue)

    76 

    57     

    77     def write(self, s):

    58     def setValue(self, value):

    78         pass

    59         self.value = value

    79 

    60     setattr(cls, "setValue", setValue)

    80     def flush(self):

    61     

    81         pass

    62     def loadXMLTree(self, tree):

    82     

    63         self.value = tree.childNodes[1].nodeName

    83     def isatty(self):

    64     setattr(cls, "loadXMLTree", loadXMLTree)

    84         return false

    65     

    85 

    66     def generateXMLText(self, name, indent, extras = {}):

    86 """

    67         ind1, ind2 = getIndent(indent, name)

    87 This function calculates the number of whitespace for indentation

    68         text = ind1 + "<%s>\n"%name

    88 """

    69         ind3, ind4 = getIndent(indent + 1, self.value)

    89 def getIndent(indent, balise):

    70         text += ind3 + "<%s/>\n"%self.value

    90     first = indent * 2

    71         text += ind1 + "</%s>\n"%name

    91     second = first + len(balise) + 1

    72         return text

    92     return "\t".expandtabs(first), "\t".expandtabs(second)

    73     setattr(cls, "generateXMLText", generateXMLText)

    93 

    74 

    94 """

    75 if "formattedText" in PLCOpenClasses:

    95 This function recursively creates a definition of the classes and their attributes

    76     cls = PLCOpenClasses["formattedText"]

    96 for plcopen from the xsd file of plcopen opened in a DOM model

    77     cls.text = ""

    97 """

    78     

    98 def Generate_classes(tree, parent, sequence = False):

    79     def getText(self):

    99     attributes = {}

    80         return self.text

   100     inheritance = []

    81     setattr(cls, "getText", getText)

   101     if sequence:

    82     

   102         order = []

    83     def setText(self, text):

   103     # The lists of attributes and inheritance of the node are generated from the childrens 

    84         self.text = text

   104     for node in tree.childNodes:

    85     setattr(cls, "setText", setText)

   105         # We make fun of #text elements and all other tags that don't are xsd tags

    86     

   106         if node.nodeName != "#text" and node.nodeName.startswith("xsd:"):

    87     def loadXMLTree(self, tree):

   107             recursion = False

    88         self.text = GetAttributeValue(tree)

   108             name = node.nodeName[4:].encode()

    89         if len(self.text.splitlines()) > 1:

   109             

    90             self.text = self.text[1:].rstrip()

   110             # This tags defines an attribute of the class

    91     setattr(cls, "loadXMLTree", loadXMLTree)

   111             if name in ["element", "attribute"]:

    92     

   112                 nodename = GetAttributeValue(node._attrs["name"])

    93     def generateXMLText(self, name, indent, extras = {}):

   113                 if "type" in node._attrs:

    94         ind1, ind2 = getIndent(indent, name)

   114                     nodetype = GetAttributeValue(node._attrs["type"])

    95         if len(self.text.splitlines()) > 1:

   115                 else:

   116                     # The type of attribute is defines in the child tree so we generate a new class

   117                     # No name is defined so we create one from nodename and parent class name

   118                     # (because some different nodes can have the same name)

   119                     if parent:

   120                         classname = "%s_%s"%(parent, nodename)

   121                     else:

   122                         classname = nodename

   123                     Generate_classes(node, classname)

   124                     nodetype = "ppx:%s"%classname

   125                 if name == "attribute":

   126                     if "use" in node._attrs:

   127                         use = GetAttributeValue(node._attrs["use"])

   128                     else:

   129                         use = "optional"

   130                 if name == "element":

   131                     # If a tag can be written more than one time we define a list attribute

   132                     if "maxOccurs" in node._attrs and GetAttributeValue(node._attrs["maxOccurs"]) == "unbounded":

   133                         nodetype = "%s[]"%nodetype

   134                     if "minOccurs" in node._attrs and GetAttributeValue(node._attrs["minOccurs"]) == "0":

   135                         use = "optional"

   136                     else:

   137                         use = "required"

   138                 attributes[nodename] = (nodetype, name, use)

   139                 if sequence:

   140                     order.append(nodename)

   141             

   142             # This tag defines a new class

   143             elif name == "complexType" or name == "simpleType":

   144                 if "name" in node._attrs:

   145                     classname = GetAttributeValue(node._attrs["name"])

   146                     super, attrs = Generate_classes(node, classname)

   147                 else:

   148                     classname = parent

   149                     super, attrs = Generate_classes(node, classname.split("_")[-1])

   150                 # When all attributes and inheritances have been extracted, the

   151                 # values are added in the list of classes to create

   152                 if classname not in classes:

   153                     classes[classname] = (super, attrs)

   154                 elif classes[classname] != (super, attrs):

   155                     print "A different class has already got %s for name"%classname

   156             

   157             # This tag defines an attribute that can have different types

   158             elif name == "choice":

   159                 super, attrs = Generate_classes(node, parent)

   160                 if "ref" in attrs.keys():

   161                     choices = attrs

   162                 else:

   163                     choices = {}

   164                     for attr, (attr_type, xml_type, write_type) in attrs.items():

   165                         choices[attr] = attr_type

   166                 if "maxOccurs" in node._attrs and GetAttributeValue(node._attrs["maxOccurs"]) == "unbounded":

   167                     attributes["multichoice_content"] = choices

   168                     if sequence:

   169                         order.append("multichoice_content")

   170                 else:

   171                     attributes["choice_content"] = choices

   172                     if sequence:

   173                         order.append("choice_content")

   174             

   175             # This tag defines the order in which class attributes must be written

   176             # in plcopen xml file. We have to store this order like an attribute

   177             elif name in "sequence":

   178                 super, attrs, order = Generate_classes(node, parent, True)

   179                 if "maxOccurs" in node._attrs and GetAttributeValue(node._attrs["maxOccurs"]) == "unbounded":

   180                     for attr, (attr_type, xml_type, write_type) in attrs.items():

   181                         attrs[attr] = ("%s[]"%attr_type, xml_type, write_type)

   182                 if "minOccurs" in node._attrs and GetAttributeValue(node._attrs["minOccurs"]) == "0":

   183                     for attr, (attr_type, xml_type, write_type) in attrs.items():

   184                         attrs[attr] = (attr_type, xml_type, "optional")

   185                 inheritance.extend(super)

   186                 attributes.update(attrs)

   187                 attributes["order"] = order

   188             

   189             # This tag defines of types

   190             elif name == "group":

   191                 if "name" in node._attrs:

   192                     nodename = GetAttributeValue(node._attrs["name"])

   193                     super, attrs = Generate_classes(node, None)

   194                     classes[nodename] = (super, {"group":attrs["choice_content"]})

   195                 elif "ref" in node._attrs:

   196                     if "ref" not in attributes:

   197                         attributes["ref"] = [GetAttributeValue(node._attrs["ref"])]

   198                     else:

   199                         attributes["ref"].append(GetAttributeValue(node._attrs["ref"]))

   200             

   201             # This tag define a base class for the node

   202             elif name == "extension":

   203                 super = GetAttributeValue(node._attrs["base"])

   204                 inheritance.append(super[4:])

   205                 recursion = True

   206                 

   207             # This tag defines a restriction on the type of attribute

   208             elif name == "restriction":

   209                 attributes["basetype"] = GetAttributeValue(node._attrs["base"])

   210                 recursion = True

   211             

   212             # This tag defines an enumerated type

   213             elif name == "enumeration":

   214                 if "enum" not in attributes:

   215                     attributes["enum"] = [GetAttributeValue(node._attrs["value"])]

   216                 else:

   217                     attributes["enum"].append(GetAttributeValue(node._attrs["value"]))

   218             

   219             # This tags defines a restriction on a numerical value

   220             elif name in ["minInclusive","maxInclusive"]:

   221                 if "limit" not in attributes:

   222                     attributes["limit"] = {}

   223                 if name == "minInclusive":

   224                     attributes["limit"]["min"] = eval(GetAttributeValue(node._attrs["value"]))

   225                 elif name == "maxInclusive":

   226                     attributes["limit"]["max"] = eval(GetAttributeValue(node._attrs["value"]))

   227             

   228             # This tag are not important but their childrens are. The childrens are then parsed. 

   229             elif name in ["complexContent", "schema"]:

   230                 recursion = True

   231             

   232             # We make fun of xsd documentation

   233             elif name in ["annotation"]:

   234                 pass

   235             

   236             else:

   237                 #print name

   238                 Generate_classes(node, parent)

   239             

   240             # Parse the childrens of node

   241             if recursion:

   242                 super, attrs = Generate_classes(node, parent)

   243                 inheritance.extend(super)

   244                 attributes.update(attrs)

   245     

   246     # if sequence tag have been found, order is returned

   247     if sequence:

   248         return inheritance, attributes, order

   249     else:

   250         return inheritance, attributes

   251 """

   252 Function that extracts data from a node

   253 """

   254 def GetAttributeValue(attr):

   255     if len(attr.childNodes) == 1:

   256         return attr.childNodes[0].data.encode()

   257     else:

   258         return ""

   259 

   260 """

   261 Funtion that returns the Python type and default value for a given xsd type

   262 """

   263 def GetTypeInitialValue(attr_type):

   264     type_compute = attr_type[4:].replace("[]", "")

   265     if attr_type.startswith("xsd:"):

   266         if type_compute == "boolean":

   267             return BooleanType, "False"

   268         elif type_compute in ["decimal","unsignedLong","long","integer"]:

   269             return IntType, "0"

   270         elif type_compute in ["string","anyURI","NMTOKEN"]:

   271             return StringType, "\"\""

   272         elif type_compute == "time":

   273             return TimeType, "time(0,0,0)"

   274         elif type_compute == "date":

   275             return DateType, "date(1,1,1)"

   276         elif type_compute == "dateTime":

   277             return DateTimeType, "datetime(1,1,1,0,0,0)"

   278         elif type_compute == "language":

   279             return StringType, "\"en-US\""

   280         else:

   281             print "Can't affect: %s"%type_compute

   282     elif attr_type.startswith("ppx:"):

   283         if type_compute in PLCOpenClasses:

   284             return PLCOpenClasses[type_compute],"%s()"%type_compute

   285 

   286 """

   287 Function that computes value from a python type (Only Boolean are critical because

   288 there is no uppercase in plcopen)

   289 """

   290 def ComputeValue(value):

   291     if type(value) == BooleanType:

   292         if value:

   293             return "true"

   294         else:

   295             return "false"

   296     else:

   297         return str(value)

   298 

   299 """

   300 Function that extracts a value from a string following the xsd type given

   301 """

   302 def GetComputedValue(attr_type, value):

   303     type_compute = attr_type[4:].replace("[]", "")

   304     if type_compute == "boolean":

   305          if value == "true":

   306              return True

   307          elif value == "false":

   308              return False

   309          else:

   310             raise ValueError, "\"%s\" is not a valid boolean!"%value

   311     elif type_compute in ["decimal","unsignedLong","long","integer"]:

   312         return int(value)

   313     elif type_compute in ["string","anyURI","NMTOKEN","language"]:

   314         return value

   315     elif type_compute == "time":

   316         result = time_model.match(value)

   317         if result:

   318             time_values = [int(v) for v in result.groups()]

   319             return time(*time_values)

   320         else:

   321             raise ValueError, "\"%s\" is not a valid time!"%value

   322     elif type_compute == "date":

   323         result = date_model.match(value)

   324         if result:

   325             date_values = [int(v) for v in result.groups()]

   326             return date(*date_values)

   327         else:

   328             raise ValueError, "\"%s\" is not a valid date!"%value

   329     elif type_compute == "dateTime":

   330         result = datetime_model.match(value)

   331         if result:

   332             datetime_values = [int(v) for v in result.groups()]

   333             return datetime(*datetime_values)

   334         else:

   335             raise ValueError, "\"%s\" is not a valid datetime!"%value

   336     else:

   337         print "Can't affect: %s"%type_compute

   338         return None

   339 

   340 """

   341 This is the Metaclass for PLCOpen element classes. It generates automatically

   342 the basic useful methods for manipulate the differents attributes of the classes

   343 """

   344 class MetaClass(type):

   345     

   346     def __init__(cls, name, bases, dict):

   347         super(MetaClass, cls).__init__(name, bases, {})

   348         #print name, bases, dict, "\n"

   349         initialValues = {}

   350         for attr, values in dict.items():

   351             if attr in ["order", "basetype"]:

   352                 pass

   353             

   354             # Class is a enumerated type

   355             elif attr == "enum":

   356                 value_type, initial = GetTypeInitialValue(dict["basetype"])

   357                 initialValues["value"] = "\"%s\""%values[0]

   358                 setattr(cls, "value", values[0])

   359                 setattr(cls, "setValue", MetaClass.generateSetEnumMethod(cls, values, value_type))

   360                 setattr(cls, "getValue", MetaClass.generateGetMethod(cls, "value"))

   361             

   362             # Class is a limited type

   363             elif attr == "limit":

   364                 value_type, initial = GetTypeInitialValue(dict["basetype"])

   365                 initial = 0

   366                 if "min" in values:

   367                     initial = max(initial, values["min"])

   368                 if "max" in values:

   369                     initial = min(initial, values["max"])

   370                 initialValues["value"] = "%d"%initial

   371                 setattr(cls, "value", initial)

   372                 setattr(cls, "setValue", MetaClass.generateSetLimitMethod(cls, values, value_type))

   373                 setattr(cls, "getValue", MetaClass.generateGetMethod(cls, "value"))

   374             

   375             # Class has an attribute that can have different value types

   376             elif attr == "choice_content":

   377                 setattr(cls, "content", None)

   378                 initialValues["content"] = "None"

   379                 setattr(cls, "deleteContent", MetaClass.generateDeleteMethod(cls, "content"))

   380                 setattr(cls, "setContent", MetaClass.generateSetChoiceMethod(cls, values))

   381                 setattr(cls, "getContent", MetaClass.generateGetMethod(cls, "content"))

   382             elif attr == "multichoice_content":

   383                 setattr(cls, "content", [])

   384                 initialValues["content"] = "[]"

   385                 setattr(cls, "appendContent", MetaClass.generateAppendChoiceMethod(cls, values))

   386                 setattr(cls, "insertContent", MetaClass.generateInsertChoiceMethod(cls, values))

   387                 setattr(cls, "removeContent", MetaClass.generateRemoveMethod(cls, "content"))

   388                 setattr(cls, "countContent", MetaClass.generateCountMethod(cls, "content"))

   389                 setattr(cls, "setContent", MetaClass.generateSetMethod(cls, "content", ListType))

   390                 setattr(cls, "getContent", MetaClass.generateGetMethod(cls, "content"))

   391             

   392             # It's an attribute of the class

   393             else:

   394                 attrname = attr[0].upper()+attr[1:]

   395                 attr_type, xml_type, write_type = values

   396                 value_type, initial = GetTypeInitialValue(attr_type)

   397                 # Value of the attribute is a list

   398                 if attr_type.endswith("[]"):

   399                     setattr(cls, attr, [])

   400                     initialValues[attr] = "[]"

   401                     setattr(cls, "append"+attrname, MetaClass.generateAppendMethod(cls, attr, value_type))

   402                     setattr(cls, "insert"+attrname, MetaClass.generateInsertMethod(cls, attr, value_type))

   403                     setattr(cls, "remove"+attrname, MetaClass.generateRemoveMethod(cls, attr))

   404                     setattr(cls, "count"+attrname, MetaClass.generateCountMethod(cls, attr))

   405                     setattr(cls, "set"+attrname, MetaClass.generateSetMethod(cls, attr, ListType))

   406                 else:

   407                     if write_type == "optional":

   408                         setattr(cls, attr, None)

   409                         initialValues[attr] = "None"

   410                         setattr(cls, "add"+attrname, MetaClass.generateAddMethod(cls, attr, initial))

   411                         setattr(cls, "delete"+attrname, MetaClass.generateDeleteMethod(cls, attr))

   412                     else:

   413                         setattr(cls, attr, initial)

   414                         initialValues[attr] = initial

   415                     setattr(cls, "set"+attrname, MetaClass.generateSetMethod(cls, attr, value_type))

   416                 setattr(cls, "get"+attrname, MetaClass.generateGetMethod(cls, attr))

   417         setattr(cls, "__init__", MetaClass.generateInitMethod(cls, bases, initialValues))

   418         setattr(cls, "loadXMLTree", MetaClass.generateLoadXMLTree(cls, bases, dict))

   419         setattr(cls, "generateXMLText", MetaClass.generateGenerateXMLText(cls, bases, dict))

   420         setattr(cls, "singleLineAttributes", True)

   421 

   422     """

   423     Method that generate the method for loading an xml tree by following the

   424     attributes list defined

   425     """

   426     def generateLoadXMLTree(cls, bases, dict):

   427         def loadXMLTreeMethod(self, tree):

   428             # If class is derived, values of inheritance classes are loaded

   429             for base in bases:

   430                 base.loadXMLTree(self, tree)

   431             # Class is a enumerated or limited value

   432             if "enum" in dict.keys() or "limit" in dict.keys():

   433                 attr_value = GetAttributeValue(tree)

   434                 attr_type = dict["basetype"]

   435                 val = GetComputedValue(attr_type, attr_value)

   436                 self.setValue(val)

   437             else:

   438                 

   439                 # Load the node attributes if they are defined in the list

   440                 for attrname, attr in tree._attrs.items():

   441                     if attrname in dict.keys():

   442                         attr_type, xml_type, write_type = dict[attrname]

   443                         attr_value = GetAttributeValue(attr)

   444                         if write_type != "optional" or attr_value != "":

   445                             # Extracts the value

   446                             if attr_type.startswith("xsd:"):

   447                                 val = GetComputedValue(attr_type, attr_value)

   448                             elif attr_type.startswith("ppx:"):

   449                                 val = eval("%s()"%attr_type[4:], globals().update(PLCOpenClasses))

   450                                 val.loadXMLTree(attr)

   451                             setattr(self, attrname, val)

   452                 

   453                 # Load the node childs if they are defined in the list

   454                 for node in tree.childNodes:

   455                     name = node.nodeName

   456                     # We make fun of #text elements

   457                     if name != "#text":

   458                         

   459                         # Class has an attribute that can have different value types

   460                         if "choice_content" in dict.keys() and name in dict["choice_content"].keys():

   461                             attr_type = dict["choice_content"][name]

   462                             # Extracts the value

   463                             if attr_type.startswith("xsd:"):

   464                                 attr_value = GetAttributeValue(node)

   465                                 if write_type != "optional" or attr_value != "":

   466                                     val = GetComputedValue(attr_type.replace("[]",""), attr_value)

   467                                 else:

   468                                     val = None

   469                             elif attr_type.startswith("ppx:"):

   470                                 val = eval("%s()"%attr_type[4:].replace("[]",""), globals().update(PLCOpenClasses))

   471                                 val.loadXMLTree(node)

   472                             # Stock value in content attribute

   473                             if val:

   474                                 if attr_type.endswith("[]"):

   475                                     if self.content:

   476                                         self.content["value"].append(val)

   477                                     else:

   478                                         self.content = {"name":name,"value":[val]}

   479                                 else:

   480                                     self.content = {"name":name,"value":val}

   481                         

   482                         # Class has a list of attributes that can have different value types

   483                         elif "multichoice_content" in dict.keys() and name in dict["multichoice_content"].keys():

   484                             attr_type = dict["multichoice_content"][name]

   485                             # Extracts the value

   486                             if attr_type.startswith("xsd:"):

   487                                 attr_value = GetAttributeValue(node)

   488                                 if write_type != "optional" or attr_value != "":

   489                                     val = GetComputedValue(attr_type, attr_value)

   490                                 else:

   491                                     val = None

   492                             elif attr_type.startswith("ppx:"):

   493                                 val = eval("%s()"%attr_type[4:], globals().update(PLCOpenClasses))

   494                                 val.loadXMLTree(node)

   495                             # Add to content attribute list

   496                             if val:

   497                                 self.content.append({"name":name,"value":val})

   498                         

   499                         # The node child is defined in the list

   500                         elif name in dict.keys():

   501                             attr_type, xml_type, write_type = dict[name]

   502                             # Extracts the value

   503                             if attr_type.startswith("xsd:"):

   504                                 attr_value = GetAttributeValue(node)

   505                                 if write_type != "optional" or attr_value != "":

   506                                     val = GetComputedValue(attr_type.replace("[]",""), attr_value)

   507                                 else:

   508                                     val = None

   509                             elif attr_type.startswith("ppx:"):

   510                                 val = eval("%s()"%attr_type[4:].replace("[]",""), globals().update(PLCOpenClasses))

   511                                 val.loadXMLTree(node)

   512                             # Stock value in attribute

   513                             if val:

   514                                 if attr_type.endswith("[]"):

   515                                     getattr(self, name).append(val)

   516                                 else:

   517                                     setattr(self, name, val)

   518         return loadXMLTreeMethod

   519 

   520     """

   521     Method that generates the method for generating an xml text by following the

   522     attributes list defined

   523     """

   524     def generateGenerateXMLText(cls, bases, dict):

   525         def generateXMLTextMethod(self, name, indent, extras = {}, derived = False):

   526             ind1, ind2 = getIndent(indent, name)

   527             if not derived:

   528                 text = ind1 + "<%s"%name

   529             else:

   530                 text = ""

   531             if len(bases) > 0:

   532                 base_extras = {}

   533             if "order" in dict.keys():

   534                 order = dict["order"]

   535             else:

   536                 order = []

   537             if "choice_content" in dict.keys() and "choice_content" not in order:

   538                 order.append("choice_content") 

   539             if "multichoice_content" in dict.keys() and "multichoice_content" not in order:

   540                 order.append("multichoice_content") 

   541             size = 0

   542             first = True

   543             for attr, value in extras.items():

   544                 if not first and not self.singleLineAttributes:

   545                     text += "\n%s"%(ind2)

   546                 text += " %s=\"%s\""%(attr, ComputeValue(value))

   547                 first = False

   548             for attr, values in dict.items():

   549                 if attr in ["order","choice_content","multichoice_content"]:

   550                     pass

   551                 elif attr in ["enum","limit"]:

   552                     if not derived:

   553                         text += ">%s</%s>\n"%(ComputeValue(self.value),name)

   554                     else:

   555                         text += ComputeValue(self.value)

   556                     return text

   557                 elif values[1] == "attribute":

   558                     value = getattr(self, attr, None)

   559                     if values[2] != "optional" or value != None:

   560                         if not first and not self.singleLineAttributes:

   561                             text += "\n%s"%(ind2)

   562                         if values[0].startswith("ppx"):

   563                             if len(bases) > 0:

   564                                 base_extras[attr] = value.getValue()

   565                             else:

   566                                 text += " %s=\"%s\""%(attr, ComputeValue(value.getValue()))

   567                         else:

   568                             if len(bases) > 0:

   569                                 base_extras[attr] = value

   570                             else:

   571                                 text += " %s=\"%s\""%(attr, ComputeValue(value))

   572                         first = False

   573             if len(bases) > 0:

   574                 first, new_text = bases[0].generateXMLText(self, name, indent, base_extras, True)

   575                 text += new_text

   576             else:

   577                 first = True

   578             ind3, ind4 = getIndent(indent + 1, name)

   579             for attr in order:

   580                 value = getattr(self, attr, None)

   581                 if attr == "choice_content":

   582                     if self.content:

   583                         if first:

   584                             text += ">\n"

   585                             first = False

   586                         value_type = dict[attr][self.content["name"]]

   587                         if value_type.startswith("xsd:"):

   588                             if value_type.endswith("[]"):

   589                                 for content in self.content["value"]:

   590                                     text += ind1 + "<%s>%s</%s>\n"%(self.content["name"], ComputeValue(content), self.content["name"])

   591                             else:

   592                                 text += ind1 + "<%s>%s</%s>\n"%(self.content["name"], ComputeValue(self.content["value"]), self.content["name"])

   593                         elif value_type.endswith("[]"):

   594                             for content in self.content["value"]:

   595                                 text += content.generateXMLText(self.content["name"], indent + 1)

   596                         else:

   597                             text += self.content["value"].generateXMLText(self.content["name"], indent + 1)

   598                 elif attr == "multichoice_content":

   599                     if len(self.content) > 0:

   600                         for element in self.content:

   601                             if first:

   602                                 text += ">\n"

   603                                 first = False

   604                             value_type = dict[attr][element["name"]]

   605                             if value_type.startswith("xsd:"):

   606                                 text += ind1 + "<%s>%s</%s>\n"%(element["name"], ComputeValue(element["value"]), element["name"])

   607                             else:

   608                                 text += element["value"].generateXMLText(element["name"], indent + 1)

   609                 elif dict[attr][2] != "optional" or value != None:

   610                     if dict[attr][0].endswith("[]"):

   611                         if first and len(value) > 0:

   612                             text += ">\n"

   613                             first = False

   614                         for element in value:

   615                             if dict[attr][0].startswith("xsd:"):

   616                                 text += ind3 + "<%s>%s</%s>\n"%(attr, ComputeValue(element), attr)

   617                             else:

   618                                 text += element.generateXMLText(attr, indent + 1)

   619                     else:

   620                         if first:

   621                             text += ">\n"

   622                             first = False

   623                         if dict[attr][0].startswith("xsd:"):

   624                             text += ind3 + "<%s>%s</%s>\n"%(attr, ComputeValue(value), attr)

   625                         else:

   626                             text += getattr(self, attr).generateXMLText(attr, indent + 1)

   627             if not derived:

   628                 if first:

   629                     text += "/>\n"

   630                 else:

   631                     text += ind1 + "</%s>\n"%(name)

   632                 return text

   633             else:

   634                 return first, text

   635         return generateXMLTextMethod

   636         

   637     """

   638     Methods that generates the different methods for setting and getting the attributes

   639     """

   640     

   641     def generateInitMethod(cls, bases, dict):

   642         def initMethod(self):

   643             for base in bases:

   644                 base.__init__(self)

   645             for attr, initial in dict.items():

   646                 setattr(self, attr, eval(initial, globals().update(PLCOpenClasses)))

   647         return initMethod

   648 

   649     def generateSetMethod(cls, attr, choice_type):

   650         def setMethod(self, value):

   651             setattr(self, attr, value)

   652         return setMethod

   653 

   654     def generateSetChoiceMethod(cls, attr_type):

   655         def setChoiceMethod(self, name, value):

   656             self.content = {"name":name,"value":value}

   657         return setChoiceMethod

   658 

   659     def generateSetEnumMethod(cls, enum, attr_type):

   660         def setEnumMethod(self, value):

   661             if value in enum:

   662                 self.value = value

   663             else:

   664                 raise ValueError, "%s is not a valid value. Must be in %s"%(value, str(enum))

   665         return setEnumMethod

   666 

   667     def generateSetLimitMethod(cls, limit, attr_type):

   668         def setMethod(self, value):

   669             if "min" in limit and value < limit["min"]:

   670                 raise ValueError, "%s is not a valid value. Must be greater than %d"%(value, limit["min"])

   671             elif "max" in limit and value > limit["max"]:

   672                 raise ValueError, "%s is not a valid value. Must be smaller than %d"%(value, limit["max"])

   673             else:

   674                 self.value = value

   675         return setMethod

   676 

   677     def generateGetMethod(cls, attr):

   678         def getMethod(self):

   679             return getattr(self, attr, None)

   680         return getMethod

   681 

   682     def generateAddMethod(cls, attr, initial):

   683         def addMethod(self):

   684             setattr(self, attr, eval(initial, globals().update(PLCOpenClasses)))

   685         return addMethod

   686 

   687     def generateDeleteMethod(cls, attr):

   688         def deleteMethod(self):

   689             setattr(self, attr, None)

   690         return deleteMethod

   691 

   692     def generateAppendMethod(cls, attr, attr_type):

   693         def appendMethod(self, value):

   694             getattr(self, attr).append(value)

   695         return appendMethod

   696 

   697     def generateInsertMethod(cls, attr, attr_type):

   698         def insertMethod(self, index, value):

   699             getattr(self, attr).insert(index, value)

   700         return insertMethod

   701 

   702     def generateAppendChoiceMethod(cls, choice_types):

   703         def appendMethod(self, name, value):

   704             self.content.append({"name":name,"value":value})

   705         return appendMethod

   706 

   707     def generateInsertChoiceMethod(cls, choice_types):

   708         def insertMethod(self, index, name, value):

   709             self.content.insert(index, {"name":name,"value":value})

   710         return insertMethod

   711 

   712     def generateRemoveMethod(cls, attr):

   713         def removeMethod(self, index):

   714             getattr(self, attr).pop(index)

   715         return removeMethod

   716 

   717     def generateCountMethod(cls, attr):

   718         def countMethod(self):

   719             return len(getattr(self, attr))

   720         return countMethod

   721 

   722 """

   723 Method that generate the classes

   724 """

   725 def CreateClass(classe):

   726     # Checks that classe haven't been generated yet

   727     if classe not in PLCOpenClasses and classe not in PLCOpenTypes and classe in classes:

   728         inheritance, attributes = classes[classe]

   729         #print classe, inheritance, attributes

   730         dict = {}

   731         bases = []

   732         

   733         # If inheritance classes haven't been generated

   734         for base in inheritance:

   735             if base not in PLCOpenClasses:

   736                 CreateClass(base)

   737             bases.append(PLCOpenClasses[base])

   738         

   739         # Checks that all attribute types are available 

   740         for attribute, type_attribute in attributes.items():

   741             if attribute == "group":

   742                 PLCOpenTypes[classe] = type_attribute

   743             elif attribute == "ref":

   744                 PLCOpenTypes[classe] = {}

   745                 for attr in type_attribute:

   746                     if attr[4:] not in PLCOpenTypes:

   747                         CreateClass(attr[4:])

   748                     PLCOpenTypes[classe].update(PLCOpenTypes[attr[4:]])

   749             elif attribute in ["choice_content","multichoice_content"]:

   750                 element_types = {}

   751                 for attr, value in type_attribute.items():

   752                     if attr == "ref":

   753                         for ref in type_attribute["ref"]:

   754                             if ref[4:] not in PLCOpenTypes:

   755                                 CreateClass(ref[4:])

   756                             element_types.update(PLCOpenTypes[ref[4:]])

   757                     else:

   758                         element_types[attr] = value

   759                 dict[attribute] = element_types

   760             else:

   761                 dict[attribute] = type_attribute

   762                 if attribute == "enum":

   763                     PLCOpenTypes["%s_enum"%classe] = type_attribute

   764                 elif attribute not in ["limit", "order"]:

   765                     if type_attribute[0].startswith("ppx:"):

   766                         type_compute = type_attribute[0][4:].replace("[]","")

   767                         if type_compute not in PLCOpenClasses:

   768                             CreateClass(type_compute)

   769         if "group" not in attributes.keys() and "ref" not in attributes.keys():

   770             cls = MetaClass.__new__(MetaClass, classe, tuple(bases), dict)

   771             MetaClass.__init__(cls, classe, tuple(bases), dict)

   772             PLCOpenClasses[classe] = cls

   773     

   774 def Generate_Methods():

   775     if "dataType" in PLCOpenClasses:

   776         cls = PLCOpenClasses["dataType"]

   777         cls.value = None

   778         

   779         def getValue(self):

   780             return self.value

   781         setattr(cls, "getValue", getValue)

   782         

   783         def setValue(self, value):

   784             self.value = value

   785         setattr(cls, "setValue", setValue)

   786         

   787         def loadXMLTree(self, tree):

   788             self.value = tree.childNodes[1].nodeName

   789         setattr(cls, "loadXMLTree", loadXMLTree)

   790         

   791         def generateXMLText(self, name, indent, extras = {}):

   792             ind1, ind2 = getIndent(indent, name)

   794             ind3, ind4 = getIndent(indent + 1, self.value)

    97             text += "%s\n"%self.text

   795             text += ind3 + "<%s/>\n"%self.value

   798         setattr(cls, "generateXMLText", generateXMLText)

   100         else:

   799     

   101             return ind1 + "<%s>%s</%s>\n"%(name, self.text, name)

   800     if "formattedText" in PLCOpenClasses:

   102     setattr(cls, "generateXMLText", generateXMLText)

   801         cls = PLCOpenClasses["formattedText"]

   103     

   802         cls.text = ""

   104 if "project" in PLCOpenClasses:

   105     cls = PLCOpenClasses["project"]

   106     cls.singleLineAttributes = False

   107     

   108     def getFileHeader(self):

   109         fileheader = {}

   110         fileheader["companyName"] = self.fileHeader.getCompanyName()

   111         if self.fileHeader.getCompanyURL():

   112             fileheader["companyURL"] = self.fileHeader.getCompanyURL()

   113         fileheader["productName"] = self.fileHeader.getProductName()

   114         fileheader["productVersion"] = self.fileHeader.getProductVersion()

   115         if self.fileHeader.getProductRelease():

   116             fileheader["productRelease"] = self.fileHeader.getProductRelease()

   117         fileheader["creationDateTime"] = self.fileHeader.getCreationDateTime()

   118         if self.fileHeader.getContentDescription():

   119             fileheader["contentDescription"] = self.fileHeader.getContentDescription()

   120         return fileheader

   121     setattr(cls, "getFileHeader", getFileHeader)

   122     

   123     def setFileHeader(self, fileheader):

   124         self.fileHeader.setCompanyName(fileheader["companyName"])

   125         if "companyURL" in fileheader:

   126             self.fileHeader.setCompanyURL(fileheader["companyURL"])

   127         self.fileHeader.setProductName(fileheader["productName"])

   128         self.fileHeader.setProductVersion(fileheader["productVersion"])

   129         if "productRelease" in fileheader:

   130             self.fileHeader.setProductRelease(fileheader["productRelease"])

   131         self.fileHeader.setCreationDateTime(fileheader["creationDateTime"])

   132         if "contentDescription" in fileheader:

   133             self.fileHeader.setContentDescription(fileheader["contentDescription"])

   134     setattr(cls, "setFileHeader", setFileHeader)

   135     

   136     def setName(self, name):

   137         self.contentHeader.setName(name)

   138     setattr(cls, "setName", setName)

   804         def getText(self):

   140     def getName(self):

   805             return self.text

   141         return self.contentHeader.getName()

   806         setattr(cls, "getText", getText)

   142     setattr(cls, "getName", getName)

   143     

   144     def getPous(self):

   145         return self.types.getPouElements()

   146     setattr(cls, "getPous", getPous)

   147     

   148     def getPou(self, name):

   149         return self.types.getPouElement(name)

   150     setattr(cls, "getPou", getPou)

   151     

   152     def appendPou(self, name, pou_type, body_type):

   153         self.types.appendPouElement(name, pou_type, body_type)

   154     setattr(cls, "appendPou", appendPou)

   808         def setText(self, text):

   156     def insertPou(self, index, pou):

   809             self.text = text

   157         self.types.insertPouElement(index, pou)

   810         setattr(cls, "setText", setText)

   158     setattr(cls, "insertPou", insertPou)

   811         

   159     

   812         def loadXMLTree(self, tree):

   160     def removePou(self, name):

   813             self.text = GetAttributeValue(tree)

   161         self.types.removePouElement(name)

   814             if len(self.text.splitlines()) > 1:

   162     setattr(cls, "removePou", removePou)

   815                 self.text = self.text[1:].rstrip()

   163 

   816         setattr(cls, "loadXMLTree", loadXMLTree)

   164     def getConfigurations(self):

   817         

   165         configurations = self.instances.configurations.getConfiguration()

   818         def generateXMLText(self, name, indent, extras = {}):

   166         if configurations:

   819             ind1, ind2 = getIndent(indent, name)

   167             return configurations

   820             if len(self.text.splitlines()) > 1:

   168         return []

   821                 text = ind1 + "<%s>\n"%name

   169     setattr(cls, "getConfigurations", getConfigurations)

   822                 text += "%s\n"%self.text

   170 

   823                 text += ind1 + "</%s>\n"%name

   171     def getConfiguration(self, name):

   824                 return text

   172         for configuration in self.instances.configurations.getConfiguration():

   825             else:

   173             if configuration.getName() == name:

   826                 return ind1 + "<%s>%s</%s>\n"%(name, self.text, name)

   174                 return configuration

   827         setattr(cls, "generateXMLText", generateXMLText)

   175         return None

   828         

   176     setattr(cls, "getConfiguration", getConfiguration)

   829     if "project" in PLCOpenClasses:

   177 

   830         cls = PLCOpenClasses["project"]

   178     def addConfiguration(self, name):

   831         cls.singleLineAttributes = False

   179         for configuration in self.instances.configurations.getConfiguration():

   832         

   180             if configuration.getName() == name:

   833         def getFileHeader(self):

   181                 raise ValueError, "\"%s\" configuration already exists !!!"%name

   834             fileheader = {}

   182         new_configuration = PLCOpenClasses["configurations_configuration"]()

   835             fileheader["companyName"] = self.fileHeader.getCompanyName()

   183         new_configuration.setName(name)

   836             if self.fileHeader.getCompanyURL():

   184         self.instances.configurations.appendConfiguration(new_configuration)

   837                 fileheader["companyURL"] = self.fileHeader.getCompanyURL()

   185     setattr(cls, "addConfiguration", addConfiguration)    

   838             fileheader["productName"] = self.fileHeader.getProductName()

   186 

   839             fileheader["productVersion"] = self.fileHeader.getProductVersion()

   187     def removeConfiguration(self, name):

   840             if self.fileHeader.getProductRelease():

   188         found = False

   841                 fileheader["productRelease"] = self.fileHeader.getProductRelease()

   189         for idx, configuration in enumerate(self.instances.configurations.getConfiguration()):

   842             fileheader["creationDateTime"] = self.fileHeader.getCreationDateTime()

   190             if configuration.getName() == name:

   843             if self.fileHeader.getContentDescription():

   191                 self.instances.configurations.removeConfiguration(idx)

   844                 fileheader["contentDescription"] = self.fileHeader.getContentDescription()

   192                 found = True

   845             return fileheader

   193                 break

   846         setattr(cls, "getFileHeader", getFileHeader)

   194         if not found:

   847         

   195             raise ValueError, "\"%s\" configuration doesn't exist !!!"%name

   848         def setFileHeader(self, fileheader):

   196     setattr(cls, "removeConfiguration", removeConfiguration)

   849             self.fileHeader.setCompanyName(fileheader["companyName"])

   197 

   850             if "companyURL" in fileheader:

   198     def getConfigurationResource(self, config_name, name):

   851                 self.fileHeader.setCompanyURL(fileheader["companyURL"])

   199         configuration = self.getConfiguration(config_name)

   852             self.fileHeader.setProductName(fileheader["productName"])

   200         if configuration:

   853             self.fileHeader.setProductVersion(fileheader["productVersion"])

   201             for resource in configuration.getResource():

   854             if "productRelease" in fileheader:

   202                 if resource.getName() == name:

   855                 self.fileHeader.setProductRelease(fileheader["productRelease"])

   203                     return resource

   856             self.fileHeader.setCreationDateTime(fileheader["creationDateTime"])

   204         return None

   857             if "contentDescription" in fileheader:

   205     setattr(cls, "getConfigurationResource", getConfigurationResource)

   858                 self.fileHeader.setContentDescription(fileheader["contentDescription"])

   206 

   859         setattr(cls, "setFileHeader", setFileHeader)

   207     def addConfigurationResource(self, config_name, name):

   860         

   208         configuration = self.getConfiguration(config_name)

   861         def setName(self, name):

   209         if configuration:

   862             self.contentHeader.setName(name)

   210             for resource in configuration.getResource():

   863         setattr(cls, "setName", setName)

   211                 if resource.getName() == name:

   864             

   212                     raise ValueError, "\"%s\" resource already exists in \"%s\" configuration !!!"%(name, config_name)

   865         def getName(self):

   213             new_resource = PLCOpenClasses["configuration_resource"]()

   866             return self.contentHeader.getName()

   214             new_resource.setName(name)

   867         setattr(cls, "getName", getName)

   215             configuration.appendResource(new_resource)

   868         

   216     setattr(cls, "addConfigurationResource", addConfigurationResource)    

   869         def getPous(self):

   217 

   870             return self.types.getPouElements()

   218     def removeConfigurationResource(self, config_name, name):

   871         setattr(cls, "getPous", getPous)

   219         configuration = self.getConfiguration(config_name)

   872         

   220         if configuration:

   873         def getPou(self, name):

   874             return self.types.getPouElement(name)

   875         setattr(cls, "getPou", getPou)

   876         

   877         def appendPou(self, name, pou_type, body_type):

   878             self.types.appendPouElement(name, pou_type, body_type)

   879         setattr(cls, "appendPou", appendPou)

   880             

   881         def insertPou(self, index, pou):

   882             self.types.insertPouElement(index, pou)

   883         setattr(cls, "insertPou", insertPou)

   884         

   885         def removePou(self, name):

   886             self.types.removePouElement(name)

   887         setattr(cls, "removePou", removePou)

   888 

   889         def getConfigurations(self):

   890             configurations = self.instances.configurations.getConfiguration()

   891             if configurations:

   892                 return configurations

   893             return []

   894         setattr(cls, "getConfigurations", getConfigurations)

   895 

   896         def getConfiguration(self, name):

   897             for configuration in self.instances.configurations.getConfiguration():

   898                 if configuration.getName() == name:

   899                     return configuration

   900             return None

   901         setattr(cls, "getConfiguration", getConfiguration)

   902 

   903         def addConfiguration(self, name):

   904             for configuration in self.instances.configurations.getConfiguration():

   905                 if configuration.getName() == name:

   906                     raise ValueError, "\"%s\" configuration already exists !!!"%name

   907             new_configuration = PLCOpenClasses["configurations_configuration"]()

   908             new_configuration.setName(name)

   909             self.instances.configurations.appendConfiguration(new_configuration)

   910         setattr(cls, "addConfiguration", addConfiguration)    

   911 

   912         def removeConfiguration(self, name):

   914             for idx, configuration in enumerate(self.instances.configurations.getConfiguration()):

   222             for idx, resource in enumerate(configuration.getResource()):

   915                 if configuration.getName() == name:

   223                 if resource.getName() == name:

   916                     self.instances.configurations.removeConfiguration(idx)

   224                     configuration.removeResource(idx)

   920                 raise ValueError, "\"%s\" configuration doesn't exist !!!"%name

   228                 raise ValueError, "\"%s\" resource doesn't exist in \"%s\" configuration !!!"%(name, config_name)

   921         setattr(cls, "removeConfiguration", removeConfiguration)

   229     setattr(cls, "removeConfigurationResource", removeConfigurationResource)

   922 

   230 

   923         def getConfigurationResource(self, config_name, name):

   231 PLCOpenClasses["project_fileHeader"].singleLineAttributes = False

   924             configuration = self.getConfiguration(config_name)

   232 

   925             if configuration:

   233 if "project_types" in PLCOpenClasses:

   926                 for resource in configuration.getResource():

   234     cls = PLCOpenClasses["project_types"]

   927                     if resource.getName() == name:

   235 

   928                         return resource

   236     def getPouElements(self):

   237         return self.pous.getPou()

   238     setattr(cls, "getPouElements", getPouElements)

   239     

   240     def getPouElement(self, name):

   241         elements = self.pous.getPou()

   242         for element in elements:

   243             if element.getName() == name:

   244                 return element

   245         return None

   246     setattr(cls, "getPouElement", getPouElement)

   247 

   248     def appendPouElement(self, name, pou_type, body_type):

   249         for element in self.pous.getPou():

   250             if element.getName() == name:

   251                 raise ValueError, "\"%s\" POU already exists !!!"%name

   252         new_pou = PLCOpenClasses["pous_pou"]()

   253         new_pou.setName(name)

   254         new_pou.pouType.setValue(pou_type)

   255         new_pou.setBody(PLCOpenClasses["body"]())

   256         new_pou.setBodyType(body_type)

   257         self.pous.appendPou(new_pou)

   258     setattr(cls, "appendPouElement", appendPouElement)

   259         

   260     def insertPouElement(self, index, pou):

   261         self.pous.insertPou(index, pou)

   262     setattr(cls, "insertPouElement", insertPouElement)

   263     

   264     def removePouElement(self, name):

   265         found = False

   266         for idx, element in enumerate(self.pous.getPou()):

   267             if element.getName() == name:

   268                 self.pous.removePou(idx)

   269                 found = True

   270                 break

   271         if not found:

   272             raise ValueError, "\"%s\" POU doesn't exist !!!"%name

   273     setattr(cls, "removePouElement", removePouElement)

   274 

   275 def setBodyType(self, type):

   276     if type == "IL":

   277         self.body.setContent("IL", PLCOpenClasses["formattedText"]())

   278     elif type == "ST":

   279         self.body.setContent("ST", PLCOpenClasses["formattedText"]())

   280     elif type == "LD":

   281         self.body.setContent("LD", PLCOpenClasses["body_LD"]())

   282     elif type == "FBD":

   283         self.body.setContent("FBD", PLCOpenClasses["body_FBD"]())

   284     elif type == "SFC":

   285         self.body.setContent("SFC", PLCOpenClasses["body_SFC"]())

   286     else:

   287         raise ValueError, "%s isn't a valid body type!"%type

   288         

   289 def getBodyType(self):

   290     return self.body.getContent()["name"]

   291 

   292 def addInstance(self, name, instance):

   293     self.body.appendContentInstance(name, instance)

   294 

   295 def getInstances(self):

   296     return self.body.getContentInstances()

   297 

   298 def getInstance(self, id):

   299     return self.body.getContentInstance(id)

   300 

   301 def getRandomInstance(self, exclude):

   302     return self.body.getContentRandomInstance(exclude)

   303 

   304 def getInstanceByName(self, name):

   305     return self.body.getContentInstanceByName(name)

   306 

   307 def removeInstance(self, id):

   308     self.body.removeContentInstance(id)

   309 

   310 def setText(self, text):

   311     self.body.setText(text)

   312 

   313 def getText(self):

   314     return self.body.getText()

   315 setattr(cls, "getText", getText)

   316 

   317 if "pous_pou" in PLCOpenClasses:

   318     cls = PLCOpenClasses["pous_pou"]

   319 

   320     setattr(cls, "setBodyType", setBodyType)

   321     setattr(cls, "getBodyType", getBodyType)

   322     setattr(cls, "addInstance", addInstance)

   323     setattr(cls, "getInstances", getInstances)

   324     setattr(cls, "getInstance", getInstance)

   325     setattr(cls, "getRandomInstance", getRandomInstance)

   326     setattr(cls, "getInstanceByName", getInstanceByName)

   327     setattr(cls, "removeInstance", removeInstance)

   328     setattr(cls, "setText", setText)

   329     setattr(cls, "getText", getText)

   330 

   331     def getVars(self):

   332         vars = []

   333         reverse_types = {}

   334         for name, value in VarTypes.items():

   335             reverse_types[value] = name

   336         for varlist in self.interface.getContent():

   337             vars.append((reverse_types[varlist["name"]], varlist["value"]))

   338         return vars

   339     setattr(cls, "getVars", getVars)

   340     

   341     def setVars(self, vars):

   342         self.interface.setContent([])

   343         for vartype, varlist in vars:

   344             self.interface.appendContent(VarTypes[vartype], varlist)

   345     setattr(cls, "setVars", setVars)

   346     

   347     def addTransition(self, name, type):

   348         if not self.transitions:

   349             self.addTransitions()

   350             self.transitions.setTransition([])

   351         transition = PLCOpenClasses["transitions_transition"]()

   352         transition.setName(name)

   353         transition.setBodyType(type)

   354         self.transitions.appendTransition(transition)

   355     setattr(cls, "addTransition", addTransition)

   356     

   357     def getTransition(self, name):

   358         if self.transitions:

   359             for transition in self.transitions.getTransition():

   360                 if transition.getName() == name:

   361                     return transition

   362         return None

   363     setattr(cls, "getTransition", getTransition)

   364         

   365     def getTransitionList(self):

   366         if self.transitions:

   367             return self.transitions.getTransition()

   368         return []

   369     setattr(cls, "getTransitionList", getTransitionList)

   370     

   371     def removeTransition(self, name):

   372         if self.transitions:

   373             transitions = self.transitions.getTransition()

   374             i = 0

   375             removed = False

   376             while i < len(transitions) and not removed:

   377                 if transitions[i].getName() == name:

   378                     transitions.removeTransition(i)

   379                     removed = True

   380                 i += 1

   381             if not removed:

   382                 raise ValueError, "Transition with name %s doesn't exists!"%name

   383     setattr(cls, "removeTransition", removeTransition)

   384 

   385     def addAction(self, name, type):

   386         if not self.actions:

   387             self.addActions()

   388             self.actions.setAction([])

   389         action = PLCOpenClasses["actions_action"]()

   390         action.setName(name)

   391         action.setBodyType(type)

   392         self.actions.appendAction(action)

   393     setattr(cls, "addAction", addAction)

   394     

   395     def getAction(self, name):

   396         if self.actions:

   397             for action in self.actions.getAction():

   398                 if action.getName() == name:

   399                     return action

   400         return None

   401     setattr(cls, "getAction", getAction)

   402     

   403     def getActionList(self):

   404         if self.actions:

   405             return self.actions.getAction()

   406         return []

   407     setattr(cls, "getActionList", getActionList)