author | etisserant |
Tue, 02 Oct 2007 18:00:13 +0200 | |
changeset 101 | 3f06a178b960 |
parent 92 | 76d5001393df |
child 116 | 58b9b84e385f |
permissions | -rw-r--r-- |
2 | 1 |
#!/usr/bin/env python |
2 |
# -*- coding: utf-8 -*- |
|
3 |
||
4 |
#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor |
|
5 |
#based on the plcopen standard. |
|
6 |
# |
|
58 | 7 |
#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD |
2 | 8 |
# |
9 |
#See COPYING file for copyrights details. |
|
10 |
# |
|
11 |
#This library is free software; you can redistribute it and/or |
|
12 |
#modify it under the terms of the GNU General Public |
|
13 |
#License as published by the Free Software Foundation; either |
|
14 |
#version 2.1 of the License, or (at your option) any later version. |
|
15 |
# |
|
16 |
#This library is distributed in the hope that it will be useful, |
|
17 |
#but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
18 |
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
58 | 19 |
#General Public License for more details. |
2 | 20 |
# |
21 |
#You should have received a copy of the GNU General Public |
|
22 |
#License along with this library; if not, write to the Free Software |
|
23 |
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
24 |
||
25 |
from xml.dom import minidom |
|
26 |
import sys,re |
|
27 |
from types import * |
|
28 |
from datetime import * |
|
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
29 |
from new import classobj |
2 | 30 |
|
31 |
""" |
|
32 |
Regular expression models for extracting dates and times from a string |
|
33 |
""" |
|
24 | 34 |
time_model = re.compile('([0-9]{2}):([0-9]{2}):([0-9]{2}(?:.[0-9]*)?)') |
2 | 35 |
date_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})') |
24 | 36 |
datetime_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})[ T]([0-9]{2}):([0-9]{2}):([0-9]{2}(?:.[0-9]*)?)') |
2 | 37 |
|
90
2245e8776086
Adding support support for using PLCOpenEditor with Beremiz
lbessard
parents:
88
diff
changeset
|
38 |
XSD_INTEGER_TYPES = ["integer","nonPositiveInteger","negativeInteger","long", |
2245e8776086
Adding support support for using PLCOpenEditor with Beremiz
lbessard
parents:
88
diff
changeset
|
39 |
"int","short","byte","nonNegativeInteger","unsignedLong","unsignedInt", |
2245e8776086
Adding support support for using PLCOpenEditor with Beremiz
lbessard
parents:
88
diff
changeset
|
40 |
"unsignedShort","unsignedByte","positiveInteger"] |
2245e8776086
Adding support support for using PLCOpenEditor with Beremiz
lbessard
parents:
88
diff
changeset
|
41 |
|
2245e8776086
Adding support support for using PLCOpenEditor with Beremiz
lbessard
parents:
88
diff
changeset
|
42 |
XSD_STRING_TYPES = ["string","normalizedString","token","anyURI","NMTOKEN","language"] |
2245e8776086
Adding support support for using PLCOpenEditor with Beremiz
lbessard
parents:
88
diff
changeset
|
43 |
|
2 | 44 |
""" |
45 |
This function calculates the number of whitespace for indentation |
|
46 |
""" |
|
47 |
def getIndent(indent, balise): |
|
48 |
first = indent * 2 |
|
49 |
second = first + len(balise) + 1 |
|
50 |
return "\t".expandtabs(first), "\t".expandtabs(second) |
|
51 |
||
52 |
""" |
|
53 |
Function that extracts data from a node |
|
54 |
""" |
|
55 |
def GetAttributeValue(attr): |
|
56 |
if len(attr.childNodes) == 1: |
|
57 |
return attr.childNodes[0].data.encode() |
|
58 |
else: |
|
67
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
58
diff
changeset
|
59 |
text = "" |
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
58
diff
changeset
|
60 |
for node in attr.childNodes: |
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
58
diff
changeset
|
61 |
if node.nodeName != "#text": |
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
58
diff
changeset
|
62 |
text += node.data.encode() |
3a1b0afdaf84
Adding support for automatically generate function blocks in interface when a block is added
lbessard
parents:
58
diff
changeset
|
63 |
return text |
2 | 64 |
|
65 |
""" |
|
66 |
Function that computes value from a python type (Only Boolean are critical because |
|
67 |
there is no uppercase in plcopen) |
|
68 |
""" |
|
69 |
def ComputeValue(value): |
|
70 |
if type(value) == BooleanType: |
|
71 |
if value: |
|
72 |
return "true" |
|
73 |
else: |
|
74 |
return "false" |
|
75 |
else: |
|
76 |
return str(value) |
|
77 |
||
78 |
""" |
|
79 |
Function that extracts a value from a string following the xsd type given |
|
80 |
""" |
|
81 |
def GetComputedValue(attr_type, value): |
|
82 |
type_compute = attr_type[4:].replace("[]", "") |
|
83 |
if type_compute == "boolean": |
|
84 |
if value == "true": |
|
85 |
return True |
|
86 |
elif value == "false": |
|
87 |
return False |
|
88 |
else: |
|
89 |
raise ValueError, "\"%s\" is not a valid boolean!"%value |
|
90
2245e8776086
Adding support support for using PLCOpenEditor with Beremiz
lbessard
parents:
88
diff
changeset
|
90 |
elif type_compute in XSD_INTEGER_TYPES: |
2 | 91 |
return int(value) |
90
2245e8776086
Adding support support for using PLCOpenEditor with Beremiz
lbessard
parents:
88
diff
changeset
|
92 |
elif type_compute in ["decimal", "float", "double"]: |
86
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
93 |
computed_value = float(value) |
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
94 |
if computed_value % 1 == 0: |
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
95 |
return int(computed_value) |
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
96 |
return computed_value |
90
2245e8776086
Adding support support for using PLCOpenEditor with Beremiz
lbessard
parents:
88
diff
changeset
|
97 |
elif type_compute in XSD_STRING_TYPES: |
2 | 98 |
return value |
99 |
elif type_compute == "time": |
|
100 |
result = time_model.match(value) |
|
101 |
if result: |
|
24 | 102 |
values = result.groups() |
103 |
time_values = [int(v) for v in values[:2]] |
|
104 |
seconds = float(values[2]) |
|
105 |
time_values.extend([int(seconds), int((seconds % 1) * 1000000)]) |
|
2 | 106 |
return time(*time_values) |
107 |
else: |
|
108 |
raise ValueError, "\"%s\" is not a valid time!"%value |
|
109 |
elif type_compute == "date": |
|
110 |
result = date_model.match(value) |
|
111 |
if result: |
|
112 |
date_values = [int(v) for v in result.groups()] |
|
113 |
return date(*date_values) |
|
114 |
else: |
|
115 |
raise ValueError, "\"%s\" is not a valid date!"%value |
|
116 |
elif type_compute == "dateTime": |
|
117 |
result = datetime_model.match(value) |
|
118 |
if result: |
|
24 | 119 |
values = result.groups() |
120 |
datetime_values = [int(v) for v in values[:5]] |
|
121 |
seconds = float(values[5]) |
|
122 |
datetime_values.extend([int(seconds), int((seconds % 1) * 1000000)]) |
|
2 | 123 |
return datetime(*datetime_values) |
124 |
else: |
|
125 |
raise ValueError, "\"%s\" is not a valid datetime!"%value |
|
126 |
else: |
|
127 |
print "Can't affect: %s"%type_compute |
|
128 |
return None |
|
129 |
||
83 | 130 |
def GetInitialValueFunction(value): |
131 |
def GetInitialValue(): |
|
132 |
return value |
|
133 |
return GetInitialValue |
|
134 |
||
2 | 135 |
""" |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
136 |
Class that generate class from an XML Tree |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
137 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
138 |
class ClassFactory: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
139 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
140 |
def __init__(self, xsd_tree): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
141 |
self.XML_Tree = xsd_tree |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
142 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
143 |
# Dictionary for stocking Classes and Types definitions created from the XML tree |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
144 |
self.XMLClassDefinitions = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
145 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
146 |
# Dictionaries for stocking Classes and Types generated |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
147 |
self.ComputedClasses = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
148 |
self.ComputedTypes = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
149 |
self.AlreadyComputed = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
150 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
151 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
152 |
This function recursively creates a definition of the classes and their attributes |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
153 |
for plcopen from the xsd file of plcopen opened in a DOM model |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
154 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
155 |
def GenerateXSDClasses(self, tree, parent, sequence = False): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
156 |
attributes = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
157 |
inheritance = [] |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
158 |
if sequence: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
159 |
order = [] |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
160 |
# The lists of attributes and inheritance of the node are generated from the childrens |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
161 |
for node in tree.childNodes: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
162 |
# We make fun of #text elements and all other tags that don't are xsd tags |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
163 |
if node.nodeName != "#text" and node.nodeName.startswith("xsd:"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
164 |
recursion = False |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
165 |
name = node.nodeName[4:].encode() |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
166 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
167 |
# This tags defines an attribute of the class |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
168 |
if name in ["element", "attribute"]: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
169 |
nodename = GetAttributeValue(node._attrs["name"]) |
83 | 170 |
default = None |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
171 |
if "type" in node._attrs: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
172 |
nodetype = GetAttributeValue(node._attrs["type"]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
173 |
if nodetype.startswith("xsd"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
174 |
nodetype = nodetype.replace("xsd", "bse") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
175 |
elif nodetype.startswith("ppx"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
176 |
nodetype = nodetype.replace("ppx", "cls") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
177 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
178 |
# The type of attribute is defines in the child tree so we generate a new class |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
179 |
# No name is defined so we create one from nodename and parent class name |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
180 |
# (because some different nodes can have the same name) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
181 |
if parent: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
182 |
classname = "%s_%s"%(parent, nodename) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
183 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
184 |
classname = nodename |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
185 |
self.GenerateXSDClasses(node, classname) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
186 |
nodetype = "cls:%s"%classname |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
187 |
if name == "attribute": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
188 |
if "use" in node._attrs: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
189 |
use = GetAttributeValue(node._attrs["use"]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
190 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
191 |
use = "optional" |
83 | 192 |
if "default" in node._attrs: |
193 |
default = GetAttributeValue(node._attrs["default"]) |
|
194 |
elif name == "element": |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
195 |
# If a tag can be written more than one time we define a list attribute |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
196 |
if "maxOccurs" in node._attrs and GetAttributeValue(node._attrs["maxOccurs"]) == "unbounded": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
197 |
nodetype = "%s[]"%nodetype |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
198 |
if "minOccurs" in node._attrs and GetAttributeValue(node._attrs["minOccurs"]) == "0": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
199 |
use = "optional" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
200 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
201 |
use = "required" |
83 | 202 |
attributes[nodename] = (nodetype, name, use, default) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
203 |
if sequence: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
204 |
order.append(nodename) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
205 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
206 |
# This tag defines a new class |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
207 |
elif name == "complexType" or name == "simpleType": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
208 |
if "name" in node._attrs: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
209 |
classname = GetAttributeValue(node._attrs["name"]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
210 |
super, attrs = self.GenerateXSDClasses(node, classname) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
211 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
212 |
classname = parent |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
213 |
super, attrs = self.GenerateXSDClasses(node, classname.split("_")[-1]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
214 |
# When all attributes and inheritances have been extracted, the |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
215 |
# values are added in the list of classes to create |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
216 |
if self.XMLClassDefinitions.get(classname, None) == None: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
217 |
self.XMLClassDefinitions[classname] = (super, attrs) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
218 |
elif self.XMLClassDefinitions[classname] != (super, attrs): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
219 |
print "A different class has already got %s for name"%classname |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
220 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
221 |
# This tag defines an attribute that can have different types |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
222 |
elif name == "choice": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
223 |
super, attrs = self.GenerateXSDClasses(node, parent) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
224 |
|
84 | 225 |
choices = {} |
226 |
for attr, values in attrs.items(): |
|
227 |
if attr == "ref": |
|
228 |
choices[attr] = values |
|
229 |
else: |
|
230 |
choices[attr] = values[0] |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
231 |
if "maxOccurs" in node._attrs and GetAttributeValue(node._attrs["maxOccurs"]) == "unbounded": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
232 |
attributes["multichoice_content"] = choices |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
233 |
if sequence: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
234 |
order.append("multichoice_content") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
235 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
236 |
attributes["choice_content"] = choices |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
237 |
if sequence: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
238 |
order.append("choice_content") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
239 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
240 |
# This tag defines the order in which class attributes must be written |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
241 |
# in plcopen xml file. We have to store this order like an attribute |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
242 |
elif name in "sequence": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
243 |
super, attrs, order = self.GenerateXSDClasses(node, parent, True) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
244 |
if "maxOccurs" in node._attrs and GetAttributeValue(node._attrs["maxOccurs"]) == "unbounded": |
83 | 245 |
for attr, (attr_type, xml_type, write_type, default) in attrs.items(): |
246 |
attrs[attr] = ("%s[]"%attr_type, xml_type, write_type, default) |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
247 |
if "minOccurs" in node._attrs and GetAttributeValue(node._attrs["minOccurs"]) == "0": |
83 | 248 |
for attr, (attr_type, xml_type, write_type, default) in attrs.items(): |
249 |
attrs[attr] = (attr_type, xml_type, "optional", default) |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
250 |
inheritance.extend(super) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
251 |
attributes.update(attrs) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
252 |
attributes["order"] = order |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
253 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
254 |
# This tag defines of types |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
255 |
elif name == "group": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
256 |
if "name" in node._attrs: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
257 |
nodename = GetAttributeValue(node._attrs["name"]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
258 |
super, attrs = self.GenerateXSDClasses(node, None) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
259 |
self.XMLClassDefinitions[nodename] = (super, {"group":attrs["choice_content"]}) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
260 |
elif "ref" in node._attrs: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
261 |
if "ref" not in attributes: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
262 |
attributes["ref"] = [GetAttributeValue(node._attrs["ref"])] |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
263 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
264 |
attributes["ref"].append(GetAttributeValue(node._attrs["ref"])) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
265 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
266 |
# This tag define a base class for the node |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
267 |
elif name == "extension": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
268 |
super = GetAttributeValue(node._attrs["base"]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
269 |
if super.startswith("xsd"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
270 |
super = super.replace("xsd", "bse") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
271 |
elif super.startswith("ppx"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
272 |
super = super.replace("ppx", "cls") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
273 |
inheritance.append(super[4:]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
274 |
recursion = True |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
275 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
276 |
# This tag defines a restriction on the type of attribute |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
277 |
elif name == "restriction": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
278 |
basetype = GetAttributeValue(node._attrs["base"]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
279 |
if basetype.startswith("xsd"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
280 |
basetype = basetype.replace("xsd", "bse") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
281 |
elif basetype.startswith("ppx"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
282 |
basetype = basetype.replace("ppx", "cls") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
283 |
attributes["basetype"] = basetype |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
284 |
recursion = True |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
285 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
286 |
# This tag defines an enumerated type |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
287 |
elif name == "enumeration": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
288 |
if "enum" not in attributes: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
289 |
attributes["enum"] = [GetAttributeValue(node._attrs["value"])] |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
290 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
291 |
attributes["enum"].append(GetAttributeValue(node._attrs["value"])) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
292 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
293 |
# This tags defines a restriction on a numerical value |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
294 |
elif name in ["minInclusive","maxInclusive"]: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
295 |
if "limit" not in attributes: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
296 |
attributes["limit"] = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
297 |
if name == "minInclusive": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
298 |
attributes["limit"]["min"] = eval(GetAttributeValue(node._attrs["value"])) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
299 |
elif name == "maxInclusive": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
300 |
attributes["limit"]["max"] = eval(GetAttributeValue(node._attrs["value"])) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
301 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
302 |
# This tag are not important but their childrens are. The childrens are then parsed. |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
303 |
elif name in ["complexContent", "schema"]: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
304 |
recursion = True |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
305 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
306 |
# We make fun of xsd documentation |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
307 |
elif name in ["annotation"]: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
308 |
pass |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
309 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
310 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
311 |
# Unable this line to print XSD element that is not yet supported |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
312 |
#print name |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
313 |
self.GenerateXSDClasses(node, parent) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
314 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
315 |
# Parse the childrens of node |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
316 |
if recursion: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
317 |
super, attrs = self.GenerateXSDClasses(node, parent) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
318 |
inheritance.extend(super) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
319 |
attributes.update(attrs) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
320 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
321 |
# if sequence tag have been found, order is returned |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
322 |
if sequence: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
323 |
return inheritance, attributes, order |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
324 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
325 |
return inheritance, attributes |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
326 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
327 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
328 |
Funtion that returns the Python type and default value for a given type |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
329 |
""" |
83 | 330 |
def GetTypeInitialValue(self, attr_type, default = None): |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
331 |
type_compute = attr_type[4:].replace("[]", "") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
332 |
if attr_type.startswith("bse:"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
333 |
if type_compute == "boolean": |
83 | 334 |
if default: |
335 |
def GetBooleanInitialValue(): |
|
336 |
return default == "true" |
|
337 |
return BooleanType, GetBooleanInitialValue |
|
338 |
else: |
|
339 |
return BooleanType, lambda:False |
|
340 |
elif type_compute in ["unsignedLong","long","integer"]: |
|
341 |
if default: |
|
342 |
def GetIntegerInitialValue(): |
|
343 |
return int(default) |
|
344 |
return IntType, GetIntegerInitialValue |
|
345 |
else: |
|
346 |
return IntType, lambda:0 |
|
347 |
elif type_compute == "decimal": |
|
348 |
if default: |
|
349 |
def GetFloatInitialValue(): |
|
350 |
return float(default) |
|
351 |
return FloatType, GetFloatInitialValue |
|
352 |
else: |
|
353 |
return FloatType, lambda:0. |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
354 |
elif type_compute in ["string","anyURI","NMTOKEN"]: |
83 | 355 |
if default: |
356 |
def GetStringInitialValue(): |
|
357 |
return default |
|
358 |
return StringType, GetStringInitialValue |
|
359 |
else: |
|
360 |
return StringType, lambda:"" |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
361 |
elif type_compute == "time": |
83 | 362 |
if default: |
363 |
def GetTimeInitialValue(): |
|
364 |
result = time_model.match(value) |
|
365 |
if result: |
|
366 |
values = result.groups() |
|
367 |
time_values = [int(v) for v in values[:2]] |
|
368 |
seconds = float(values[2]) |
|
369 |
time_values.extend([int(seconds), int((seconds % 1) * 1000000)]) |
|
370 |
return time(*time_values) |
|
371 |
return time(0,0,0,0) |
|
92
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
372 |
return time, GetTimeInitialValue |
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
373 |
else: |
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
374 |
return time, lambda:time(0,0,0,0) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
375 |
elif type_compute == "date": |
83 | 376 |
if default: |
377 |
def GetDateInitialValue(): |
|
378 |
result = date_model.match(value) |
|
379 |
if result: |
|
380 |
date_values = [int(v) for v in result.groups()] |
|
381 |
return date(*date_values) |
|
382 |
return date(1,1,1) |
|
92
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
383 |
return date, GetDateInitialValue |
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
384 |
else: |
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
385 |
return date, lambda:date(1,1,1) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
386 |
elif type_compute == "dateTime": |
83 | 387 |
if default: |
388 |
def GetDateTimeInitialValue(): |
|
389 |
result = datetime_model.match(value) |
|
390 |
if result: |
|
391 |
values = result.groups() |
|
392 |
datetime_values = [int(v) for v in values[:5]] |
|
393 |
seconds = float(values[5]) |
|
394 |
datetime_values.extend([int(seconds), int((seconds % 1) * 1000000)]) |
|
395 |
return datetime(*datetime_values) |
|
396 |
return datetime(1,1,1,0,0,0,0) |
|
92
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
397 |
return datetime, GetDateTimeInitialValue |
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
398 |
else: |
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
399 |
return datetime, lambda:datetime(1,1,1,0,0,0,0) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
400 |
elif type_compute == "language": |
83 | 401 |
if default: |
402 |
def GetStringInitialValue(): |
|
403 |
return default |
|
404 |
return StringType, GetStringInitialValue |
|
405 |
else: |
|
406 |
return StringType, lambda:"en-US" |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
407 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
408 |
print "Can't affect: %s"%type_compute |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
409 |
elif attr_type.startswith("cls:"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
410 |
if self.XMLClassDefinitions.get(type_compute, None) != None: |
83 | 411 |
def GetClassInitialValue(): |
412 |
if self.XMLClassDefinitions.get(type_compute, None) != None: |
|
413 |
obj = self.ComputedClasses[type_compute]() |
|
414 |
if default: |
|
415 |
obj.setValue(default) |
|
416 |
return obj |
|
417 |
return None |
|
418 |
return self.XMLClassDefinitions[type_compute], GetClassInitialValue |
|
419 |
return None, lambda:None |
|
420 |
||
421 |
""" |
|
422 |
Funtion that returns the Python type and default value for a given type |
|
423 |
""" |
|
424 |
def GetInitialValues(self, value_types): |
|
425 |
initial_values = {} |
|
426 |
for name, value_type in value_types.items(): |
|
427 |
result = self.GetTypeInitialValue(value_type) |
|
428 |
if result: |
|
429 |
initial_values[name] = result[1] |
|
430 |
return initial_values |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
431 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
432 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
433 |
Methods that generate the classes |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
434 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
435 |
def CreateClasses(self): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
436 |
self.GenerateXSDClasses(self.XML_Tree, None) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
437 |
for classname in self.XMLClassDefinitions.keys(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
438 |
self.CreateClass(classname) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
439 |
for classname in self.XMLClassDefinitions.keys(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
440 |
self.MarkUsedClasses(classname) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
441 |
return self.ComputedClasses, self.ComputedTypes |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
442 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
443 |
def CreateClass(self, classname): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
444 |
# Checks that classe haven't been generated yet |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
445 |
if not self.AlreadyComputed.get(classname, False) and classname in self.XMLClassDefinitions: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
446 |
self.AlreadyComputed[classname] = True |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
447 |
inheritance, attributes = self.XMLClassDefinitions[classname] |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
448 |
#print classname, inheritance, attributes |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
449 |
members = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
450 |
bases = [] |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
451 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
452 |
# If inheritance classes haven't been generated |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
453 |
for base in inheritance: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
454 |
self.CreateClass(base) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
455 |
bases.append(self.ComputedClasses[base]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
456 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
457 |
# Checks that all attribute types are available |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
458 |
for attribute, type_attribute in attributes.items(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
459 |
if attribute == "group": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
460 |
self.ComputedTypes[classname] = type_attribute |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
461 |
elif attribute in ["choice_content","multichoice_content"]: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
462 |
element_types = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
463 |
for attr, value in type_attribute.items(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
464 |
if attr == "ref": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
465 |
for ref in value: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
466 |
self.CreateClass(ref[4:]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
467 |
element_types.update(self.ComputedTypes[ref[4:]]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
468 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
469 |
element_types[attr] = value |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
470 |
members[attribute] = element_types |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
471 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
472 |
members[attribute] = type_attribute |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
473 |
if attribute == "enum": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
474 |
self.ComputedTypes["%s_enum"%classname] = type_attribute |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
475 |
elif attribute not in ["limit", "order"]: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
476 |
if type_attribute[0].startswith("cls:"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
477 |
type_compute = type_attribute[0][4:].replace("[]","") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
478 |
self.CreateClass(type_compute) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
479 |
if "group" not in attributes: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
480 |
bases = tuple(bases) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
481 |
classmembers = {"IsBaseClass" : True} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
482 |
initialValues = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
483 |
for attr, values in members.items(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
484 |
if attr in ["order", "basetype"]: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
485 |
pass |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
486 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
487 |
# Class is a enumerated type |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
488 |
elif attr == "enum": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
489 |
value_type, initial = self.GetTypeInitialValue(members["basetype"]) |
83 | 490 |
initialValues["value"] = GetInitialValueFunction(values[0]) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
491 |
classmembers["value"] = values[0] |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
492 |
classmembers["setValue"] = generateSetEnumMethod(values, value_type) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
493 |
classmembers["getValue"] = generateGetMethod("value") |
83 | 494 |
classmembers["getValidValues"] = generateGetChoicesMethod(values) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
495 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
496 |
# Class is a limited type |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
497 |
elif attr == "limit": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
498 |
value_type, initial = self.GetTypeInitialValue(members["basetype"]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
499 |
if "min" in values: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
500 |
initial = max(initial, values["min"]) |
92
76d5001393df
Adding support for refreshing PLCOpenEditor block list
lbessard
parents:
90
diff
changeset
|
501 |
elif "max" in values: |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
502 |
initial = min(initial, values["max"]) |
83 | 503 |
initialValues["value"] = GetInitialValueFunction(initial) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
504 |
classmembers["value"] = initial |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
505 |
classmembers["setValue"] = generateSetLimitMethod(values, value_type) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
506 |
classmembers["getValue"] = generateGetMethod("value") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
507 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
508 |
# Class has an attribute that can have different value types |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
509 |
elif attr == "choice_content": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
510 |
classmembers["content"] = None |
83 | 511 |
initialValues["content"] = lambda:None |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
512 |
classmembers["deleteContent"] = generateDeleteMethod("content") |
83 | 513 |
classmembers["addContent"] = generateAddChoiceMethod(values, self.GetInitialValues(values)) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
514 |
classmembers["setContent"] = generateSetChoiceMethod(values) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
515 |
classmembers["getContent"] = generateGetMethod("content") |
83 | 516 |
classmembers["getChoices"] = generateGetChoicesMethod(values) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
517 |
elif attr == "multichoice_content": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
518 |
classmembers["content"] = [] |
83 | 519 |
initialValues["content"] = lambda:[] |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
520 |
classmembers["appendContent"] = generateAppendChoiceMethod(values) |
83 | 521 |
classmembers["appendContentByType"] = generateAppendChoiceByTypeMethod(values, self.GetInitialValues(values)) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
522 |
classmembers["insertContent"] = generateInsertChoiceMethod(values) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
523 |
classmembers["removeContent"] = generateRemoveMethod("content") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
524 |
classmembers["countContent"] = generateCountMethod("content") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
525 |
classmembers["setContent"] = generateSetMethod("content", ListType) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
526 |
classmembers["getContent"] = generateGetMethod("content") |
83 | 527 |
classmembers["getChoices"] = generateGetChoicesMethod(values) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
528 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
529 |
# It's an attribute of the class |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
530 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
531 |
attrname = attr[0].upper()+attr[1:] |
83 | 532 |
attr_type, xml_type, write_type, default = values |
533 |
value_type, initial = self.GetTypeInitialValue(attr_type, default) |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
534 |
# Value of the attribute is a list |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
535 |
if attr_type.endswith("[]"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
536 |
classmembers[attr] = [] |
83 | 537 |
initialValues[attr] = lambda:[] |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
538 |
classmembers["append"+attrname] = generateAppendMethod(attr, value_type) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
539 |
classmembers["insert"+attrname] = generateInsertMethod(attr, value_type) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
540 |
classmembers["remove"+attrname] = generateRemoveMethod(attr) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
541 |
classmembers["count"+attrname] = generateCountMethod(attr) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
542 |
classmembers["set"+attrname] = generateSetMethod(attr, ListType) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
543 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
544 |
if write_type == "optional": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
545 |
classmembers[attr] = None |
83 | 546 |
initialValues[attr] = lambda:None |
547 |
classmembers["add"+attrname] = generateAddMethod(attr, initial) |
|
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
548 |
classmembers["delete"+attrname] = generateDeleteMethod(attr) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
549 |
else: |
83 | 550 |
classmembers[attr] = initial() |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
551 |
initialValues[attr] = initial |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
552 |
classmembers["set"+attrname] = generateSetMethod(attr, value_type) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
553 |
classmembers["get"+attrname] = generateGetMethod(attr) |
83 | 554 |
classmembers["__init__"] = generateInitMethod(bases, initialValues) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
555 |
classmembers["loadXMLTree"] = generateLoadXMLTree(bases, members, self.ComputedClasses) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
556 |
classmembers["generateXMLText"] = generateGenerateXMLText(bases, members) |
85
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
557 |
classmembers["getElementAttributes"] = generateGetElementAttributes(members, self.ComputedClasses) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
558 |
classmembers["getElementInfos"] = generateGetElementInfos(members, self.ComputedClasses) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
559 |
classmembers["setElementValue"] = generateSetElementValue(members) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
560 |
classmembers["singleLineAttributes"] = True |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
561 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
562 |
self.ComputedClasses[classname] = classobj(classname, bases, classmembers) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
563 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
564 |
def MarkUsedClasses(self, classname): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
565 |
# Checks that classe haven't been generated yet |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
566 |
if classname in self.XMLClassDefinitions: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
567 |
inheritance, attributes = self.XMLClassDefinitions[classname] |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
568 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
569 |
# If inheritance classes haven't been generated |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
570 |
for base in inheritance: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
571 |
if base in self.ComputedClasses: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
572 |
self.ComputedClasses[base].IsBaseClass = False |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
573 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
574 |
# Checks that all attribute types are available |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
575 |
for attribute, type_attribute in attributes.items(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
576 |
if attribute in ["choice_content","multichoice_content"]: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
577 |
element_types = {} |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
578 |
for attr, value in type_attribute.items(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
579 |
if attr == "ref": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
580 |
for ref in value: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
581 |
element_types.update(self.ComputedTypes[ref[4:]]) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
582 |
else: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
583 |
element_types[attr] = value |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
584 |
for type_name in element_types.values(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
585 |
type_compute = type_name[4:].replace("[]","") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
586 |
if type_compute in self.ComputedClasses: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
587 |
self.ComputedClasses[type_compute].IsBaseClass = False |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
588 |
elif attribute != "group": |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
589 |
if attribute not in ["enum", "limit", "order"]: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
590 |
if type_attribute[0].startswith("cls:"): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
591 |
type_compute = type_attribute[0][4:].replace("[]","") |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
592 |
if type_compute in self.ComputedClasses: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
593 |
self.ComputedClasses[type_compute].IsBaseClass = False |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
594 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
595 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
596 |
Methods that print the classes generated |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
597 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
598 |
def PrintClasses(self): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
599 |
for classname, xmlclass in self.ComputedClasses.items(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
600 |
print "%s : %s"%(classname, str(xmlclass)) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
601 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
602 |
def PrintClassNames(self): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
603 |
classnames = self.XMLClassDefinitions.keys() |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
604 |
classnames.sort() |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
605 |
for classname in classnames: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
606 |
print classname |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
607 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
608 |
""" |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
609 |
Method that generate the method for loading an xml tree by following the |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
610 |
attributes list defined |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
611 |
""" |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
612 |
def generateLoadXMLTree(bases, members, classes): |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
613 |
def loadXMLTreeMethod(self, tree): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
614 |
# If class is derived, values of inheritance classes are loaded |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
615 |
for base in bases: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
616 |
base.loadXMLTree(self, tree) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
617 |
# Class is a enumerated or limited value |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
618 |
if "enum" in members.keys() or "limit" in members.keys(): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
619 |
attr_value = GetAttributeValue(tree) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
620 |
attr_type = members["basetype"] |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
621 |
val = GetComputedValue(attr_type, attr_value) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
622 |
self.setValue(val) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
623 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
624 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
625 |
# Load the node attributes if they are defined in the list |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
626 |
for attrname, attr in tree._attrs.items(): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
627 |
if attrname in members.keys(): |
83 | 628 |
attr_type, xml_type, write_type, default = members[attrname] |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
629 |
attr_value = GetAttributeValue(attr) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
630 |
if write_type != "optional" or attr_value != "": |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
631 |
# Extracts the value |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
632 |
if attr_type.startswith("bse:"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
633 |
val = GetComputedValue(attr_type, attr_value) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
634 |
elif attr_type.startswith("cls:"): |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
635 |
val = classes[attr_type[4:]]() |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
636 |
val.loadXMLTree(attr) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
637 |
setattr(self, attrname, val) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
638 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
639 |
# Load the node childs if they are defined in the list |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
640 |
for node in tree.childNodes: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
641 |
name = node.nodeName |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
642 |
# We make fun of #text elements |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
643 |
if name != "#text": |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
644 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
645 |
# Class has an attribute that can have different value types |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
646 |
if "choice_content" in members.keys() and name in members["choice_content"].keys(): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
647 |
attr_type = members["choice_content"][name] |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
648 |
# Extracts the value |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
649 |
if attr_type.startswith("bse:"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
650 |
attr_value = GetAttributeValue(node) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
651 |
if write_type != "optional" or attr_value != "": |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
652 |
val = GetComputedValue(attr_type.replace("[]",""), attr_value) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
653 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
654 |
val = None |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
655 |
elif attr_type.startswith("cls:"): |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
656 |
val = classes[attr_type[4:].replace("[]","")]() |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
657 |
val.loadXMLTree(node) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
658 |
# Stock value in content attribute |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
659 |
if val: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
660 |
if attr_type.endswith("[]"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
661 |
if self.content: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
662 |
self.content["value"].append(val) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
663 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
664 |
self.content = {"name":name,"value":[val]} |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
665 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
666 |
self.content = {"name":name,"value":val} |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
667 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
668 |
# Class has a list of attributes that can have different value types |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
669 |
elif "multichoice_content" in members.keys() and name in members["multichoice_content"].keys(): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
670 |
attr_type = members["multichoice_content"][name] |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
671 |
# Extracts the value |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
672 |
if attr_type.startswith("bse:"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
673 |
attr_value = GetAttributeValue(node) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
674 |
if write_type != "optional" or attr_value != "": |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
675 |
val = GetComputedValue(attr_type, attr_value) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
676 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
677 |
val = None |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
678 |
elif attr_type.startswith("cls:"): |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
679 |
val = classes[attr_type[4:]]() |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
680 |
val.loadXMLTree(node) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
681 |
# Add to content attribute list |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
682 |
if val: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
683 |
self.content.append({"name":name,"value":val}) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
684 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
685 |
# The node child is defined in the list |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
686 |
elif name in members.keys(): |
83 | 687 |
attr_type, xml_type, write_type, default = members[name] |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
688 |
# Extracts the value |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
689 |
if attr_type.startswith("bse:"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
690 |
attr_value = GetAttributeValue(node) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
691 |
if write_type != "optional" or attr_value != "": |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
692 |
val = GetComputedValue(attr_type.replace("[]",""), attr_value) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
693 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
694 |
val = None |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
695 |
elif attr_type.startswith("cls:"): |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
696 |
val = classes[attr_type[4:].replace("[]","")]() |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
697 |
val.loadXMLTree(node) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
698 |
# Stock value in attribute |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
699 |
if val: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
700 |
if attr_type.endswith("[]"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
701 |
getattr(self, name).append(val) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
702 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
703 |
setattr(self, name, val) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
704 |
return loadXMLTreeMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
705 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
706 |
""" |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
707 |
Method that generates the method for generating an xml text by following the |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
708 |
attributes list defined |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
709 |
""" |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
710 |
def generateGenerateXMLText(bases, members): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
711 |
def generateXMLTextMethod(self, name, indent, extras = {}, derived = False): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
712 |
ind1, ind2 = getIndent(indent, name) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
713 |
if not derived: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
714 |
text = ind1 + "<%s"%name |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
715 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
716 |
text = "" |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
717 |
if len(bases) > 0: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
718 |
base_extras = {} |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
719 |
if "order" in members.keys(): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
720 |
order = members["order"] |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
721 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
722 |
order = [] |
83 | 723 |
for attr, values in members.items(): |
724 |
if attr != "order" and (attr in ("choice_content", "multichoice_content") or values[1] != "attribute"): |
|
725 |
if attr not in order: |
|
726 |
order.append(attr) |
|
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
727 |
size = 0 |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
728 |
first = True |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
729 |
for attr, value in extras.items(): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
730 |
if not first and not self.singleLineAttributes: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
731 |
text += "\n%s"%(ind2) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
732 |
text += " %s=\"%s\""%(attr, ComputeValue(value)) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
733 |
first = False |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
734 |
for attr, values in members.items(): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
735 |
if attr in ["order","choice_content","multichoice_content"]: |
2 | 736 |
pass |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
737 |
elif attr in ["enum","limit"]: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
738 |
if not derived: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
739 |
text += ">%s</%s>\n"%(ComputeValue(self.value),name) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
740 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
741 |
text += ComputeValue(self.value) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
742 |
return text |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
743 |
elif values[1] == "attribute": |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
744 |
value = getattr(self, attr, None) |
86
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
745 |
if value != None: |
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
746 |
if values[0].startswith("cls"): |
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
747 |
value = value.getValue() |
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
748 |
computed_value = ComputeValue(value) |
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
749 |
else: |
4f1dbdb0bed2
Bug on xmlclass XML file attributes generation fixed
lbessard
parents:
85
diff
changeset
|
750 |
computed_value = None |
88 | 751 |
if values[2] != "optional" or (value != None and computed_value != values[3]): |
83 | 752 |
if len(bases) > 0: |
753 |
base_extras[attr] = value |
|
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
754 |
else: |
83 | 755 |
if not first and not self.singleLineAttributes: |
756 |
text += "\n%s"%(ind2) |
|
757 |
text += " %s=\"%s\""%(attr, computed_value) |
|
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
758 |
first = False |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
759 |
if len(bases) > 0: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
760 |
first, new_text = bases[0].generateXMLText(self, name, indent, base_extras, True) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
761 |
text += new_text |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
762 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
763 |
first = True |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
764 |
ind3, ind4 = getIndent(indent + 1, name) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
765 |
for attr in order: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
766 |
value = getattr(self, attr, None) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
767 |
if attr == "choice_content": |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
768 |
if self.content: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
769 |
if first: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
770 |
text += ">\n" |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
771 |
first = False |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
772 |
value_type = members[attr][self.content["name"]] |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
773 |
if value_type.startswith("bse:"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
774 |
if value_type.endswith("[]"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
775 |
for content in self.content["value"]: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
776 |
text += ind1 + "<%s>%s</%s>\n"%(self.content["name"], ComputeValue(content), self.content["name"]) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
777 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
778 |
text += ind1 + "<%s>%s</%s>\n"%(self.content["name"], ComputeValue(self.content["value"]), self.content["name"]) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
779 |
elif value_type.endswith("[]"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
780 |
for content in self.content["value"]: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
781 |
text += content.generateXMLText(self.content["name"], indent + 1) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
782 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
783 |
text += self.content["value"].generateXMLText(self.content["name"], indent + 1) |
2 | 784 |
elif attr == "multichoice_content": |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
785 |
if len(self.content) > 0: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
786 |
for element in self.content: |
2 | 787 |
if first: |
788 |
text += ">\n" |
|
789 |
first = False |
|
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
790 |
value_type = members[attr][element["name"]] |
2 | 791 |
if value_type.startswith("bse:"): |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
792 |
text += ind1 + "<%s>%s</%s>\n"%(element["name"], ComputeValue(element["value"]), element["name"]) |
2 | 793 |
else: |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
794 |
text += element["value"].generateXMLText(element["name"], indent + 1) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
795 |
elif members[attr][2] != "optional" or value != None: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
796 |
if members[attr][0].endswith("[]"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
797 |
if first and len(value) > 0: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
798 |
text += ">\n" |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
799 |
first = False |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
800 |
for element in value: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
801 |
if members[attr][0].startswith("bse:"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
802 |
text += ind3 + "<%s>%s</%s>\n"%(attr, ComputeValue(element), attr) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
803 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
804 |
text += element.generateXMLText(attr, indent + 1) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
805 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
806 |
if first: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
807 |
text += ">\n" |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
808 |
first = False |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
809 |
if members[attr][0].startswith("bse:"): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
810 |
text += ind3 + "<%s>%s</%s>\n"%(attr, ComputeValue(value), attr) |
2 | 811 |
else: |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
812 |
text += getattr(self, attr).generateXMLText(attr, indent + 1) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
813 |
if not derived: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
814 |
if first: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
815 |
text += "/>\n" |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
816 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
817 |
text += ind1 + "</%s>\n"%(name) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
818 |
return text |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
819 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
820 |
return first, text |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
821 |
return generateXMLTextMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
822 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
823 |
|
85
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
824 |
def generateGetElementAttributes(members, classes): |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
825 |
def getElementAttributes(self): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
826 |
attr_list = [] |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
827 |
for attr, values in members.items(): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
828 |
if attr in ["order","choice_content","multichoice_content"]: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
829 |
pass |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
830 |
elif values[1] == "attribute": |
83 | 831 |
attr_params = {"name": attr, "require": values[2] == "required"} |
832 |
if values[0].startswith("cls:"): |
|
833 |
attr_value = getattr(self, attr, None) |
|
834 |
if attr_value: |
|
835 |
attr_params["value"] = attr_value.getValue() |
|
836 |
else: |
|
837 |
attr_params["value"] = "" |
|
838 |
attr_params["type"] = classes[values[0][4:]]().getValidValues() |
|
839 |
else: |
|
840 |
attr_params["value"] = getattr(self, attr, "") |
|
841 |
attr_params["type"] = values[0][4:] |
|
842 |
attr_list.append(attr_params) |
|
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
843 |
return attr_list |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
844 |
return getElementAttributes |
85
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
845 |
|
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
846 |
def generateGetElementInfos(members, classes): |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
847 |
def getElementInfos(self, name, path = None): |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
848 |
attr_type = "element" |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
849 |
value = None |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
850 |
children = [] |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
851 |
if "enum" in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
852 |
attr_type = self.getValidValues() |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
853 |
value = self.value |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
854 |
elif "limit" in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
855 |
attr_type = {"min" : None, "max" : None} |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
856 |
if "min" in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
857 |
attr_type["min"] = members["min"] |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
858 |
if "max" in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
859 |
attr_type["max"] = members["max"] |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
860 |
value = self.value |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
861 |
elif path: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
862 |
if "choice_content" in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
863 |
return self.content["value"].getElementInfos(self.content["name"], path) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
864 |
elif "multichoice_content" not in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
865 |
parts = path.split(".", 1) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
866 |
if parts[0] in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
867 |
values = members[parts[0]] |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
868 |
if values[1] == "attribute" and len(parts) == 1: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
869 |
attr = getattr(self, parts[0], None) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
870 |
if attr != None: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
871 |
if values[0].startswith("cls:"): |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
872 |
return attr.getElementInfos(parts[0]) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
873 |
else: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
874 |
attr_type = values[0][4:] |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
875 |
value = getattr(self, attr, "") |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
876 |
elif values[1] == "element": |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
877 |
attr = getattr(self, parts[0], None) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
878 |
if attr != None: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
879 |
if len(parts) == 1: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
880 |
return attr.getElementInfos(parts[0]) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
881 |
else: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
882 |
return attr.getElementInfos(parts[0], parts[1]) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
883 |
else: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
884 |
for attr, values in members.items(): |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
885 |
if attr == "order": |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
886 |
pass |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
887 |
elif attr == "choice_content": |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
888 |
attr_type = self.getChoices().items() |
87 | 889 |
if self.content: |
890 |
value = self.content["name"] |
|
891 |
children.extend(self.content["value"].getElementInfos(self.content["name"])["children"]) |
|
85
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
892 |
elif attr == "multichoice_content": |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
893 |
for element_infos in self.content: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
894 |
children.append(element_infos["value"].getElementInfos(element_infos["name"])) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
895 |
elif values[1] == "attribute" and not values[0].startswith("cls:"): |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
896 |
children.append({"name" : attr, "value" : getattr(self, attr, ""), "type" : values[0][4:], "children" : []}) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
897 |
else: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
898 |
element = getattr(self, attr, None) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
899 |
if not element: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
900 |
element = classes[values[0][4:]]() |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
901 |
children.append(element.getElementInfos(attr)) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
902 |
return {"name" : name, "type" : attr_type, "value" : value, "children" : children} |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
903 |
return getElementInfos |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
904 |
|
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
905 |
def generateSetElementValue(members): |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
906 |
def setElementValue(self, path, value): |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
907 |
if "enum" in members or "limit" in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
908 |
if not path: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
909 |
self.setValue(value) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
910 |
elif "choice_content" in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
911 |
if path: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
912 |
self.content["value"].setElementValue(path, value) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
913 |
else: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
914 |
self.addContent(value) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
915 |
else: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
916 |
parts = path.split(".", 1) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
917 |
if parts[0] in members: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
918 |
values = members[parts[0]] |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
919 |
if values[1] == "attribute" and len(parts) == 1: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
920 |
attr = getattr(self, parts[0], None) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
921 |
if attr != None: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
922 |
if values[0].startswith("cls:"): |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
923 |
attr.setElementValue(None, value) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
924 |
elif values[0][4:] == "boolean": |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
925 |
setattr(self, parts[0], value) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
926 |
else: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
927 |
setattr(self, parts[0], GetComputedValue(values[0], value)) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
928 |
elif values[1] == "element": |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
929 |
attr = getattr(self, parts[0], None) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
930 |
if attr != None: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
931 |
if len(parts) == 1: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
932 |
attr.setElementValue(None, value) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
933 |
else: |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
934 |
attr.setElementValue(parts[1], value) |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
935 |
return setElementValue |
fd17b0e0fd7e
Adding members to classes for automatically generate infos and set the value of an element with its path
lbessard
parents:
84
diff
changeset
|
936 |
|
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
937 |
""" |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
938 |
Methods that generates the different methods for setting and getting the attributes |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
939 |
""" |
83 | 940 |
def generateInitMethod(bases, members): |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
941 |
def initMethod(self): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
942 |
for base in bases: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
943 |
base.__init__(self) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
944 |
for attr, initial in members.items(): |
83 | 945 |
setattr(self, attr, initial()) |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
946 |
return initMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
947 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
948 |
def generateSetMethod(attr, attr_type): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
949 |
def setMethod(self, value): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
950 |
setattr(self, attr, value) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
951 |
return setMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
952 |
|
83 | 953 |
def generateAddChoiceMethod(choice_type, initial_values): |
954 |
def addChoiceMethod(self, name): |
|
955 |
if name in choice_type: |
|
956 |
self.content = {"name" : name, "value" : initial_values[name]()} |
|
957 |
return addChoiceMethod |
|
958 |
||
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
959 |
def generateSetChoiceMethod(choice_type): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
960 |
def setChoiceMethod(self, name, value): |
83 | 961 |
self.content = {"name" : name, "value" : value} |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
962 |
return setChoiceMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
963 |
|
83 | 964 |
def generateGetChoicesMethod(choice_type): |
965 |
def getChoicesMethod(self): |
|
966 |
return choice_type |
|
967 |
return getChoicesMethod |
|
968 |
||
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
969 |
def generateSetEnumMethod(enum, attr_type): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
970 |
def setEnumMethod(self, value): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
971 |
if value in enum: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
972 |
self.value = value |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
973 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
974 |
raise ValueError, "%s is not a valid value. Must be in %s"%(value, str(enum)) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
975 |
return setEnumMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
976 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
977 |
def generateSetLimitMethod(limit, attr_type): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
978 |
def setMethod(self, value): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
979 |
if "min" in limit and value < limit["min"]: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
980 |
raise ValueError, "%s is not a valid value. Must be greater than %d"%(value, limit["min"]) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
981 |
elif "max" in limit and value > limit["max"]: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
982 |
raise ValueError, "%s is not a valid value. Must be smaller than %d"%(value, limit["max"]) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
983 |
else: |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
984 |
self.value = value |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
985 |
return setMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
986 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
987 |
def generateGetMethod(attr): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
988 |
def getMethod(self): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
989 |
return getattr(self, attr, None) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
990 |
return getMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
991 |
|
83 | 992 |
def generateAddMethod(attr, initial): |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
993 |
def addMethod(self): |
83 | 994 |
setattr(self, attr, initial()) |
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
995 |
return addMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
996 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
997 |
def generateDeleteMethod(attr): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
998 |
def deleteMethod(self): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
999 |
setattr(self, attr, None) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1000 |
return deleteMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1001 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1002 |
def generateAppendMethod(attr, attr_type): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1003 |
def appendMethod(self, value): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1004 |
getattr(self, attr).append(value) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1005 |
return appendMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1006 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1007 |
def generateInsertMethod(attr, attr_type): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1008 |
def insertMethod(self, index, value): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1009 |
getattr(self, attr).insert(index, value) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1010 |
return insertMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1011 |
|
83 | 1012 |
def generateAppendChoiceByTypeMethod(choice_type, initial_values): |
1013 |
def addChoiceMethod(self, name): |
|
1014 |
if name in choice_type: |
|
1015 |
self.content.append({"name" : name, "value" : initial_values[name]()}) |
|
1016 |
return addChoiceMethod |
|
1017 |
||
75
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1018 |
def generateAppendChoiceMethod(choice_types): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1019 |
def appendMethod(self, name, value): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1020 |
self.content.append({"name":name,"value":value}) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1021 |
return appendMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1022 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1023 |
def generateInsertChoiceMethod(choice_types): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1024 |
def insertMethod(self, index, name, value): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1025 |
self.content.insert(index, {"name":name,"value":value}) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1026 |
return insertMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1027 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1028 |
def generateRemoveMethod(attr): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1029 |
def removeMethod(self, index): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1030 |
getattr(self, attr).pop(index) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1031 |
return removeMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1032 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1033 |
def generateCountMethod(attr): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1034 |
def countMethod(self): |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1035 |
return len(getattr(self, attr)) |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1036 |
return countMethod |
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1037 |
|
82d371634f15
Changed the way class are generated, using classobj from "new" module, instead of type inheritence.
etisserant
parents:
67
diff
changeset
|
1038 |
""" |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1039 |
This function generate the classes from a class factory |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1040 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1041 |
def GenerateClasses(factory, declare = False): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1042 |
ComputedClasses, ComputedTypes = factory.CreateClasses() |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1043 |
if declare: |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1044 |
for ClassName, Class in pluginClasses.items(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1045 |
sys._getframe(1).f_locals[ClassName] = Class |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1046 |
for TypeName, Type in pluginTypes.items(): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1047 |
sys._getframe(1).f_locals[TypeName] = Type |
83 | 1048 |
globals().update(ComputedClasses) |
76
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1049 |
return ComputedClasses, ComputedTypes |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1050 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1051 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1052 |
This function opens the xsd file and generate the classes from the xml tree |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1053 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1054 |
def GenerateClassesFromXSD(filename, declare = False): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1055 |
xsdfile = open(filename, 'r') |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1056 |
factory = ClassFactory(minidom.parse(xsdfile)) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1057 |
xsdfile.close() |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1058 |
return GenerateClasses(factory, declare) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1059 |
|
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1060 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1061 |
This function generate the classes from the xsd given as a string |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1062 |
""" |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1063 |
def GenerateClassesFromXSDstring(xsdstring, declare = False): |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1064 |
factory = ClassFactory(minidom.parseString(xsdstring)) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1065 |
return GenerateClasses(factory, declare) |
5bac3213fea1
xmlclass modified for allowing class definitions for multiple XSD files and indicating which classes are the base classes
lbessard
parents:
75
diff
changeset
|
1066 |