@@ -1,474 +1,479 | |||||
1 | ''' |
|
1 | ''' | |
2 | Created on September , 2012 |
|
2 | Created on September , 2012 | |
3 | @author: |
|
3 | @author: | |
4 | ''' |
|
4 | ''' | |
5 | from xml.etree.ElementTree import Element, SubElement, ElementTree |
|
5 | from xml.etree.ElementTree import Element, SubElement, ElementTree | |
6 | from xml.etree import ElementTree as ET |
|
6 | from xml.etree import ElementTree as ET | |
7 | from xml.dom import minidom |
|
7 | from xml.dom import minidom | |
8 |
|
8 | |||
9 | import sys |
|
9 | import sys | |
10 |
|
10 | |||
11 | def prettify(elem): |
|
11 | def prettify(elem): | |
12 | """Return a pretty-printed XML string for the Element. |
|
12 | """Return a pretty-printed XML string for the Element. | |
13 | """ |
|
13 | """ | |
14 | rough_string = ET.tostring(elem, 'utf-8') |
|
14 | rough_string = ET.tostring(elem, 'utf-8') | |
15 | reparsed = minidom.parseString(rough_string) |
|
15 | reparsed = minidom.parseString(rough_string) | |
16 | return reparsed.toprettyxml(indent=" ") |
|
16 | return reparsed.toprettyxml(indent=" ") | |
17 |
|
17 | |||
18 | class Controller(): |
|
18 | class Controller(): | |
19 |
|
19 | |||
20 | id = None |
|
20 | id = None | |
21 | name = None |
|
21 | name = None | |
22 | description = None |
|
22 | description = None | |
23 | readBranchObjList = None |
|
23 | readBranchObjList = None | |
24 | procBranchObjList = None |
|
24 | procBranchObjList = None | |
25 |
|
25 | |||
26 | def __init__(self): |
|
26 | def __init__(self): | |
27 |
|
27 | |||
28 | # self.id = id |
|
28 | # self.id = id | |
29 | # self.name = name |
|
29 | # self.name = name | |
30 | # self.description = description |
|
30 | # self.description = description | |
31 |
|
31 | |||
32 | self.readBranchObjList = [] |
|
32 | self.readBranchObjList = [] | |
33 | self.procBranchObjList = [] |
|
33 | self.procBranchObjList = [] | |
34 |
|
34 | |||
35 | def setParms(self, id, name, description): |
|
35 | def setParms(self, id, name, description): | |
36 |
|
36 | |||
37 | self.id = id |
|
37 | self.id = id | |
38 | self.name = name |
|
38 | self.name = name | |
39 | self.description = description |
|
39 | self.description = description | |
40 |
|
40 | |||
41 | def addReadBranch(self, dpath, dataformat, readMode, startDate='', endDate='', startTime='', endTime=''): |
|
41 | def addReadBranch(self, dpath, dataformat, readMode, startDate='', endDate='', startTime='', endTime=''): | |
42 |
|
42 | |||
43 | id = len(self.readBranchObjList) + 1 |
|
43 | id = self.getNewId() | |
44 |
|
44 | |||
45 | readBranchObj = ReadBranch() |
|
45 | readBranchObj = ReadBranch() | |
46 | readBranchObj.setup(id, dpath, dataformat, readMode, startDate, endDate, startTime, endTime) |
|
46 | readBranchObj.setup(id, dpath, dataformat, readMode, startDate, endDate, startTime, endTime) | |
47 |
|
47 | |||
48 | self.readBranchObjList.append(readBranchObj) |
|
48 | self.readBranchObjList.append(readBranchObj) | |
49 |
|
49 | |||
50 | return readBranchObj |
|
50 | return readBranchObj | |
51 |
|
51 | |||
52 | def addProcBranch(self, name): |
|
52 | def addProcBranch(self, name): | |
53 |
|
53 | |||
54 | id = len(self.procBranchObjList) + 1 |
|
54 | id = self.getNewId() | |
55 |
|
55 | |||
56 | procBranchObj = ProcBranch() |
|
56 | procBranchObj = ProcBranch() | |
57 | procBranchObj.setup(id, name) |
|
57 | procBranchObj.setup(id, name) | |
58 |
|
58 | |||
59 | self.procBranchObjList.append(procBranchObj) |
|
59 | self.procBranchObjList.append(procBranchObj) | |
60 |
|
60 | |||
61 | return procBranchObj |
|
61 | return procBranchObj | |
62 |
|
62 | |||
|
63 | def getNewId(self): | |||
|
64 | ||||
|
65 | id = int(self.id)*10 + len(self.readBranchObjList) + len(self.procBranchObjList) + 1 | |||
|
66 | return id | |||
|
67 | ||||
63 | def makeXml(self): |
|
68 | def makeXml(self): | |
64 |
|
69 | |||
65 | projectElement = Element('Controller') |
|
70 | projectElement = Element('Controller') | |
66 | projectElement.set('id', str(self.id)) |
|
71 | projectElement.set('id', str(self.id)) | |
67 | projectElement.set('name', self.name) |
|
72 | projectElement.set('name', self.name) | |
68 | projectElement.set('description', self.description) |
|
73 | projectElement.set('description', self.description) | |
69 |
|
74 | |||
70 | for readBranchObj in self.readBranchObjList: |
|
75 | for readBranchObj in self.readBranchObjList: | |
71 | readBranchObj.makeXml(projectElement) |
|
76 | readBranchObj.makeXml(projectElement) | |
72 |
|
77 | |||
73 | for procBranchObj in self.procBranchObjList: |
|
78 | for procBranchObj in self.procBranchObjList: | |
74 | procBranchObj.makeXml(projectElement) |
|
79 | procBranchObj.makeXml(projectElement) | |
75 |
|
80 | |||
76 | self.projectElement = projectElement |
|
81 | self.projectElement = projectElement | |
77 |
|
82 | |||
78 | def writeXml(self, filename): |
|
83 | def writeXml(self, filename): | |
79 |
|
84 | |||
80 | self.makeXml() |
|
85 | self.makeXml() | |
81 | ElementTree(self.projectElement).write(filename, method='xml') |
|
86 | ElementTree(self.projectElement).write(filename, method='xml') | |
82 | print prettify(self.projectElement) |
|
87 | print prettify(self.projectElement) | |
83 |
|
88 | |||
84 | def readXml(self, filename): |
|
89 | def readXml(self, filename): | |
85 |
|
90 | |||
86 | #tree = ET.parse(filename) |
|
91 | #tree = ET.parse(filename) | |
87 | self.projectElement = None |
|
92 | self.projectElement = None | |
88 | self.readBranchObjList = None |
|
93 | self.readBranchObjList = None | |
89 | self.procBranchObjList = None |
|
94 | self.procBranchObjList = None | |
90 |
|
95 | |||
91 | self.projectElement = ElementTree().parse(filename) |
|
96 | self.projectElement = ElementTree().parse(filename) | |
92 |
|
97 | |||
93 | self.project = self.projectElement.tag |
|
98 | self.project = self.projectElement.tag | |
94 |
|
99 | |||
95 | self.id = self.projectElement.get('id') |
|
100 | self.id = self.projectElement.get('id') | |
96 | self.name = self.projectElement.get('name') |
|
101 | self.name = self.projectElement.get('name') | |
97 |
|
102 | |||
98 | self.readBranchObjList = [] |
|
103 | self.readBranchObjList = [] | |
99 |
|
104 | |||
100 | readBranchElementList = self.projectElement.getiterator('readBranch') |
|
105 | readBranchElementList = self.projectElement.getiterator('readBranch') | |
101 |
|
106 | |||
102 | for readBranchElement in readBranchElementList: |
|
107 | for readBranchElement in readBranchElementList: | |
103 | readBrachObj = ReadBranch() |
|
108 | readBrachObj = ReadBranch() | |
104 | readBrachObj.readXml(readBranchElement) |
|
109 | readBrachObj.readXml(readBranchElement) | |
105 | self.readBranchObjList.append(readBranchObj) |
|
110 | self.readBranchObjList.append(readBranchObj) | |
106 |
|
111 | |||
107 | self.procBranchObjList = [] |
|
112 | self.procBranchObjList = [] | |
108 |
|
113 | |||
109 | procBranchElementList = self.projectElement.getiterator('procBranch') |
|
114 | procBranchElementList = self.projectElement.getiterator('procBranch') | |
110 |
|
115 | |||
111 | for procBranchElement in procBranchElementList: |
|
116 | for procBranchElement in procBranchElementList: | |
112 | procBranchObj = ProcBranch() |
|
117 | procBranchObj = ProcBranch() | |
113 | procBranchObj.readXml(procBranchElement) |
|
118 | procBranchObj.readXml(procBranchElement) | |
114 | self.procBranchObjList.append(procBranchObj) |
|
119 | self.procBranchObjList.append(procBranchObj) | |
115 |
|
120 | |||
116 | def printattr(self): |
|
121 | def printattr(self): | |
117 |
|
122 | |||
118 | print "Controller[%s]: name = %s, description = %s" %(self.id, |
|
123 | print "Controller[%s]: name = %s, description = %s" %(self.id, | |
119 | self.name, |
|
124 | self.name, | |
120 | self.description) |
|
125 | self.description) | |
121 |
|
126 | |||
122 | for readBranchObj in self.readBranchObjList: |
|
127 | for readBranchObj in self.readBranchObjList: | |
123 | readBranchObj.printattr() |
|
128 | readBranchObj.printattr() | |
124 |
|
129 | |||
125 | for procBranchObj in self.procBranchObjList: |
|
130 | for procBranchObj in self.procBranchObjList: | |
126 | procBranchObj.printattr() |
|
131 | procBranchObj.printattr() | |
127 |
|
132 | |||
128 | class ReadBranch(): |
|
133 | class ReadBranch(): | |
129 |
|
134 | |||
130 | id = None |
|
135 | id = None | |
131 | name = None |
|
136 | name = None | |
132 | # dpath = None |
|
137 | # dpath = None | |
133 | # dataformat = None |
|
138 | # dataformat = None | |
134 | # readMode = None |
|
139 | # readMode = None | |
135 | # startDate = None |
|
140 | # startDate = None | |
136 | # endDate = None |
|
141 | # endDate = None | |
137 | # startTime = None |
|
142 | # startTime = None | |
138 | # endTime = None |
|
143 | # endTime = None | |
139 |
|
144 | |||
140 | parmObjList = [] |
|
145 | parmObjList = [] | |
141 |
|
146 | |||
142 | def __init__(self): |
|
147 | def __init__(self): | |
143 |
|
148 | |||
144 | self.parmObjList = [] |
|
149 | self.parmObjList = [] | |
145 |
|
150 | |||
146 | def setup(self, id, dpath, dataformat, readMode, startDate, endDate, startTime, endTime): |
|
151 | def setup(self, id, dpath, dataformat, readMode, startDate, endDate, startTime, endTime): | |
147 |
|
152 | |||
148 | self.id = id |
|
153 | self.id = id | |
149 | self.dpath = dpath |
|
154 | self.dpath = dpath | |
150 | self.dataformat = dataformat |
|
155 | self.dataformat = dataformat | |
151 | self.readMode = readMode |
|
156 | self.readMode = readMode | |
152 | self.startDate = startDate |
|
157 | self.startDate = startDate | |
153 | self.endDate = endDate |
|
158 | self.endDate = endDate | |
154 | self.startTime = startTime |
|
159 | self.startTime = startTime | |
155 | self.endTime = endTime |
|
160 | self.endTime = endTime | |
156 |
|
161 | |||
157 | def addParameter(self, name, value): |
|
162 | def addParameter(self, name, value): | |
158 |
|
163 | |||
159 | id = len(self.parmObjList) + 1 |
|
164 | id = int(self.id)*10 + len(self.parmObjList) + 1 | |
160 |
|
165 | |||
161 | parmObj = ParameterConf() |
|
166 | parmObj = ParameterConf() | |
162 | parmObj.setup(id, name, value) |
|
167 | parmObj.setup(id, name, value) | |
163 |
|
168 | |||
164 | self.parmObjList.append(parmObj) |
|
169 | self.parmObjList.append(parmObj) | |
165 |
|
170 | |||
166 | return parmObj |
|
171 | return parmObj | |
167 |
|
172 | |||
168 | def makeXml(self, projectElement): |
|
173 | def makeXml(self, projectElement): | |
169 |
|
174 | |||
170 | readBranchElement = SubElement(projectElement, 'readBranch') |
|
175 | readBranchElement = SubElement(projectElement, 'readBranch') | |
171 | readBranchElement.set('id', str(self.id)) |
|
176 | readBranchElement.set('id', str(self.id)) | |
172 |
|
177 | |||
173 | self.addParameter(name='dpath' , value=self.dpath) |
|
178 | self.addParameter(name='dpath' , value=self.dpath) | |
174 | self.addParameter(name='dataformat', value=self.dataformat) |
|
179 | self.addParameter(name='dataformat', value=self.dataformat) | |
175 | self.addParameter(name='startDate' , value=self.startDate) |
|
180 | self.addParameter(name='startDate' , value=self.startDate) | |
176 | self.addParameter(name='endDate' , value=self.endDate) |
|
181 | self.addParameter(name='endDate' , value=self.endDate) | |
177 | self.addParameter(name='startTime' , value=self.startTime) |
|
182 | self.addParameter(name='startTime' , value=self.startTime) | |
178 | self.addParameter(name='endTime' , value=self.endTime) |
|
183 | self.addParameter(name='endTime' , value=self.endTime) | |
179 | self.addParameter(name='readMode' , value=str(self.readMode)) |
|
184 | self.addParameter(name='readMode' , value=str(self.readMode)) | |
180 |
|
185 | |||
181 | for parmObj in self.parmObjList: |
|
186 | for parmObj in self.parmObjList: | |
182 | parmObj.makeXml(readBranchElement) |
|
187 | parmObj.makeXml(readBranchElement) | |
183 |
|
188 | |||
184 | def readXml(self, readBranchElement): |
|
189 | def readXml(self, readBranchElement): | |
185 |
|
190 | |||
186 | self.id = readBranchElement.get('id') |
|
191 | self.id = readBranchElement.get('id') | |
187 |
|
192 | |||
188 | self.parmObjList = [] |
|
193 | self.parmObjList = [] | |
189 |
|
194 | |||
190 | parmElementList = readBranchElement.getiterator('Parameter') |
|
195 | parmElementList = readBranchElement.getiterator('Parameter') | |
191 |
|
196 | |||
192 | for parmElement in parmElementList: |
|
197 | for parmElement in parmElementList: | |
193 | parmObj = ParameterConf() |
|
198 | parmObj = ParameterConf() | |
194 | parmObj.readXml(parmElement) |
|
199 | parmObj.readXml(parmElement) | |
195 | self.parmObjList.append(parmObj) |
|
200 | self.parmObjList.append(parmObj) | |
196 |
|
201 | |||
197 | def printattr(self): |
|
202 | def printattr(self): | |
198 |
|
203 | |||
199 | print "ReadBranch[%s]: name = %s" %(self.id, |
|
204 | print "ReadBranch[%s]: name = %s" %(self.id, | |
200 | self.name) |
|
205 | self.name) | |
201 |
|
206 | |||
202 | for parmObj in self.parmObjList: |
|
207 | for parmObj in self.parmObjList: | |
203 | parmObj.printattr() |
|
208 | parmObj.printattr() | |
204 |
|
209 | |||
205 | class ProcBranch(): |
|
210 | class ProcBranch(): | |
206 |
|
211 | |||
207 | id = None |
|
212 | id = None | |
208 | name = None |
|
213 | name = None | |
209 |
|
214 | |||
210 | upObjList = None |
|
215 | upObjList = None | |
211 |
|
216 | |||
212 | def __init__(self): |
|
217 | def __init__(self): | |
213 | pass |
|
218 | pass | |
214 |
|
219 | |||
215 | def setup(self, id, name): |
|
220 | def setup(self, id, name): | |
216 |
|
221 | |||
217 | self.id = id |
|
222 | self.id = id | |
218 | self.name = name |
|
223 | self.name = name | |
219 |
|
224 | |||
220 | self.upObjList = [] |
|
225 | self.upObjList = [] | |
221 |
|
226 | |||
222 | def addUP(self, name, type): |
|
227 | def addUP(self, name, type, inputId): | |
223 |
|
228 | |||
224 | id = len(self.upObjList) + 1 |
|
229 | id = int(self.id)*10 + len(self.upObjList) + 1 | |
225 |
|
230 | |||
226 | upObj = UPConf() |
|
231 | upObj = UPConf() | |
227 | upObj.setup(id, name, type) |
|
232 | upObj.setup(id, name, type, inputId) | |
228 |
|
233 | |||
229 | self.upObjList.append(upObj) |
|
234 | self.upObjList.append(upObj) | |
230 |
|
235 | |||
231 | return upObj |
|
236 | return upObj | |
232 |
|
237 | |||
233 | def makeXml(self, projectElement): |
|
238 | def makeXml(self, projectElement): | |
234 |
|
239 | |||
235 | procBranchElement = SubElement(projectElement, 'procBranch') |
|
240 | procBranchElement = SubElement(projectElement, 'procBranch') | |
236 | procBranchElement.set('id', str(self.id)) |
|
241 | procBranchElement.set('id', str(self.id)) | |
237 | procBranchElement.set('name', self.name) |
|
242 | procBranchElement.set('name', self.name) | |
238 |
|
243 | |||
239 | for upObj in self.upObjList: |
|
244 | for upObj in self.upObjList: | |
240 | upObj.makeXml(procBranchElement) |
|
245 | upObj.makeXml(procBranchElement) | |
241 |
|
246 | |||
242 | def readXml(self, procBranchElement): |
|
247 | def readXml(self, procBranchElement): | |
243 |
|
248 | |||
244 | self.id = procBranchElement.get('id') |
|
249 | self.id = procBranchElement.get('id') | |
245 | self.name = procBranchElement.get('name') |
|
250 | self.name = procBranchElement.get('name') | |
246 |
|
251 | |||
247 | self.upObjList = [] |
|
252 | self.upObjList = [] | |
248 |
|
253 | |||
249 | upElementList = procBranchElement.getiterator('UP') |
|
254 | upElementList = procBranchElement.getiterator('UP') | |
250 |
|
255 | |||
251 | for upElement in upElementList: |
|
256 | for upElement in upElementList: | |
252 | upObj = UPConf() |
|
257 | upObj = UPConf() | |
253 | upObj.readXml(upElement) |
|
258 | upObj.readXml(upElement) | |
254 | self.upObjList.append(upObj) |
|
259 | self.upObjList.append(upObj) | |
255 |
|
260 | |||
256 | def printattr(self): |
|
261 | def printattr(self): | |
257 |
|
262 | |||
258 | print "ProcBranch[%s]: name = %s" %(self.id, |
|
263 | print "ProcBranch[%s]: name = %s" %(self.id, | |
259 | self.name) |
|
264 | self.name) | |
260 |
|
265 | |||
261 | for upObj in self.upObjList: |
|
266 | for upObj in self.upObjList: | |
262 | upObj.printattr() |
|
267 | upObj.printattr() | |
263 |
|
268 | |||
264 | class UPConf(): |
|
269 | class UPConf(): | |
265 |
|
270 | |||
266 | id = None |
|
271 | id = None | |
267 | name = None |
|
272 | name = None | |
268 | type = None |
|
273 | type = None | |
269 | inputId = None |
|
274 | inputId = None | |
270 |
|
275 | |||
271 | opObjList = [] |
|
276 | opObjList = [] | |
272 |
|
277 | |||
273 | def __init__(self): |
|
278 | def __init__(self): | |
274 | pass |
|
279 | pass | |
275 |
|
280 | |||
276 |
def setup(self, id, name, type, inputId |
|
281 | def setup(self, id, name, type, inputId): | |
277 |
|
282 | |||
278 | self.id = id |
|
283 | self.id = id | |
279 | self.name = name |
|
284 | self.name = name | |
280 | self.type = type |
|
285 | self.type = type | |
281 | self.inputId = inputId |
|
286 | self.inputId = inputId | |
282 |
|
287 | |||
283 | self.opObjList = [] |
|
288 | self.opObjList = [] | |
284 |
|
289 | |||
285 | def addOperation(self, name, priority, type='self'): |
|
290 | def addOperation(self, name, priority, type='self'): | |
286 |
|
291 | |||
287 | id = len(self.opObjList) + 1 |
|
292 | id = int(self.id)*10 + len(self.opObjList) + 1 | |
288 |
|
293 | |||
289 | opObj = OperationConf() |
|
294 | opObj = OperationConf() | |
290 | opObj.setup(id, name, priority, type) |
|
295 | opObj.setup(id, name, priority, type) | |
291 |
|
296 | |||
292 | self.opObjList.append(opObj) |
|
297 | self.opObjList.append(opObj) | |
293 |
|
298 | |||
294 | return opObj |
|
299 | return opObj | |
295 |
|
300 | |||
296 | def makeXml(self, procBranchElement): |
|
301 | def makeXml(self, procBranchElement): | |
297 |
|
302 | |||
298 | upElement = SubElement(procBranchElement, 'UP') |
|
303 | upElement = SubElement(procBranchElement, 'UP') | |
299 | upElement.set('id', str(self.id)) |
|
304 | upElement.set('id', str(self.id)) | |
300 | upElement.set('name', self.name) |
|
305 | upElement.set('name', self.name) | |
301 | upElement.set('type', self.type) |
|
306 | upElement.set('type', self.type) | |
302 | upElement.set('inputId', str(self.inputId)) |
|
307 | upElement.set('inputId', str(self.inputId)) | |
303 |
|
308 | |||
304 | for opObj in self.opObjList: |
|
309 | for opObj in self.opObjList: | |
305 | opObj.makeXml(upElement) |
|
310 | opObj.makeXml(upElement) | |
306 |
|
311 | |||
307 | def readXml(self, upElement): |
|
312 | def readXml(self, upElement): | |
308 |
|
313 | |||
309 | self.id = upElement.get('id') |
|
314 | self.id = upElement.get('id') | |
310 | self.name = upElement.get('name') |
|
315 | self.name = upElement.get('name') | |
311 | self.type = upElement.get('type') |
|
316 | self.type = upElement.get('type') | |
312 | self.inputId = upElement.get('inputId') |
|
317 | self.inputId = upElement.get('inputId') | |
313 |
|
318 | |||
314 | self.opObjList = [] |
|
319 | self.opObjList = [] | |
315 |
|
320 | |||
316 | opElementList = upElement.getiterator('Operation') |
|
321 | opElementList = upElement.getiterator('Operation') | |
317 |
|
322 | |||
318 | for opElement in opElementList: |
|
323 | for opElement in opElementList: | |
319 | opObj = OperationConf() |
|
324 | opObj = OperationConf() | |
320 | opObj.readXml(opElement) |
|
325 | opObj.readXml(opElement) | |
321 | self.opObjList.append(opObj) |
|
326 | self.opObjList.append(opObj) | |
322 |
|
327 | |||
323 | def getOperationObjList(self): |
|
328 | def getOperationObjList(self): | |
324 |
|
329 | |||
325 | return self.opObjList |
|
330 | return self.opObjList | |
326 |
|
331 | |||
327 | def printattr(self): |
|
332 | def printattr(self): | |
328 |
|
333 | |||
329 | print "UP[%s]: name = %s, type = %s, inputId = %s" %(self.id, |
|
334 | print "UP[%s]: name = %s, type = %s, inputId = %s" %(self.id, | |
330 | self.name, |
|
335 | self.name, | |
331 | self.type, |
|
336 | self.type, | |
332 | self.inputId) |
|
337 | self.inputId) | |
333 |
|
338 | |||
334 | for opObj in self.opObjList: |
|
339 | for opObj in self.opObjList: | |
335 | opObj.printattr() |
|
340 | opObj.printattr() | |
336 |
|
341 | |||
337 | class OperationConf(): |
|
342 | class OperationConf(): | |
338 |
|
343 | |||
339 | id = 0 |
|
344 | id = 0 | |
340 | name = None |
|
345 | name = None | |
341 | priority = None |
|
346 | priority = None | |
342 | type = 'self' |
|
347 | type = 'self' | |
343 |
|
348 | |||
344 | parmObjList = [] |
|
349 | parmObjList = [] | |
345 |
|
350 | |||
346 | def __init__(self): |
|
351 | def __init__(self): | |
347 | pass |
|
352 | pass | |
348 |
|
353 | |||
349 | def setup(self, id, name, priority, type): |
|
354 | def setup(self, id, name, priority, type): | |
350 |
|
355 | |||
351 | self.id = id |
|
356 | self.id = id | |
352 | self.name = name |
|
357 | self.name = name | |
353 | self.priority = priority |
|
358 | self.priority = priority | |
354 | self.type = type |
|
359 | self.type = type | |
355 |
|
360 | |||
356 | self.parmObjList = [] |
|
361 | self.parmObjList = [] | |
357 |
|
362 | |||
358 | def addParameter(self, name, value): |
|
363 | def addParameter(self, name, value): | |
359 |
|
364 | |||
360 | id = len(self.parmObjList) + 1 |
|
365 | id = int(self.id)*10 + len(self.parmObjList) + 1 | |
361 |
|
366 | |||
362 | parmObj = ParameterConf() |
|
367 | parmObj = ParameterConf() | |
363 | parmObj.setup(id, name, value) |
|
368 | parmObj.setup(id, name, value) | |
364 |
|
369 | |||
365 | self.parmObjList.append(parmObj) |
|
370 | self.parmObjList.append(parmObj) | |
366 |
|
371 | |||
367 | return parmObj |
|
372 | return parmObj | |
368 |
|
373 | |||
369 | def makeXml(self, upElement): |
|
374 | def makeXml(self, upElement): | |
370 |
|
375 | |||
371 | opElement = SubElement(upElement, 'Operation') |
|
376 | opElement = SubElement(upElement, 'Operation') | |
372 | opElement.set('id', str(self.id)) |
|
377 | opElement.set('id', str(self.id)) | |
373 | opElement.set('name', self.name) |
|
378 | opElement.set('name', self.name) | |
374 | opElement.set('priority', str(self.priority)) |
|
379 | opElement.set('priority', str(self.priority)) | |
375 |
|
380 | |||
376 | for parmObj in self.parmObjList: |
|
381 | for parmObj in self.parmObjList: | |
377 | parmObj.makeXml(opElement) |
|
382 | parmObj.makeXml(opElement) | |
378 |
|
383 | |||
379 | def readXml(self, opElement): |
|
384 | def readXml(self, opElement): | |
380 |
|
385 | |||
381 | self.id = opElement.get('id') |
|
386 | self.id = opElement.get('id') | |
382 | self.name = opElement.get('name') |
|
387 | self.name = opElement.get('name') | |
383 | self.type = opElement.get('type') |
|
388 | self.type = opElement.get('type') | |
384 |
|
389 | |||
385 | self.parmObjList = [] |
|
390 | self.parmObjList = [] | |
386 |
|
391 | |||
387 | parmElementList = opElement.getiterator('Parameter') |
|
392 | parmElementList = opElement.getiterator('Parameter') | |
388 |
|
393 | |||
389 | for parmElement in parmElementList: |
|
394 | for parmElement in parmElementList: | |
390 | parmObj = ParameterConf() |
|
395 | parmObj = ParameterConf() | |
391 | parmObj.readXml(parmElement) |
|
396 | parmObj.readXml(parmElement) | |
392 | self.parmObjList.append(parmObj) |
|
397 | self.parmObjList.append(parmObj) | |
393 |
|
398 | |||
394 | def getParameterObjList(self): |
|
399 | def getParameterObjList(self): | |
395 |
|
400 | |||
396 | return self.parmObjList |
|
401 | return self.parmObjList | |
397 |
|
402 | |||
398 | def printattr(self): |
|
403 | def printattr(self): | |
399 |
|
404 | |||
400 | print "Operation[%s]: name = %s, type = %s, priority = %s" %(self.id, |
|
405 | print "Operation[%s]: name = %s, type = %s, priority = %s" %(self.id, | |
401 | self.name, |
|
406 | self.name, | |
402 | self.type, |
|
407 | self.type, | |
403 | self.priority) |
|
408 | self.priority) | |
404 |
|
409 | |||
405 | for parmObj in self.parmObjList: |
|
410 | for parmObj in self.parmObjList: | |
406 | parmObj.printattr() |
|
411 | parmObj.printattr() | |
407 |
|
412 | |||
408 | class ParameterConf(): |
|
413 | class ParameterConf(): | |
409 |
|
414 | |||
410 | id = None |
|
415 | id = None | |
411 | name = None |
|
416 | name = None | |
412 | value = None |
|
417 | value = None | |
413 |
|
418 | |||
414 | def __init__(self): |
|
419 | def __init__(self): | |
415 | pass |
|
420 | pass | |
416 |
|
421 | |||
417 | def setup(self, id, name, value): |
|
422 | def setup(self, id, name, value): | |
418 |
|
423 | |||
419 | self.id = id |
|
424 | self.id = id | |
420 | self.name = name |
|
425 | self.name = name | |
421 | self.value = value |
|
426 | self.value = value | |
422 |
|
427 | |||
423 | def makeXml(self, opElement): |
|
428 | def makeXml(self, opElement): | |
424 |
|
429 | |||
425 | parmElement = SubElement(opElement, 'Parameter') |
|
430 | parmElement = SubElement(opElement, 'Parameter') | |
426 | parmElement.set('id', str(self.id)) |
|
431 | parmElement.set('id', str(self.id)) | |
427 | parmElement.set('name', self.name) |
|
432 | parmElement.set('name', self.name) | |
428 | parmElement.set('value', self.value) |
|
433 | parmElement.set('value', self.value) | |
429 |
|
434 | |||
430 | def readXml(self, parmElement): |
|
435 | def readXml(self, parmElement): | |
431 |
|
436 | |||
432 | self.id = parmElement.get('id') |
|
437 | self.id = parmElement.get('id') | |
433 | self.name = parmElement.get('name') |
|
438 | self.name = parmElement.get('name') | |
434 | self.value = parmElement.get('value') |
|
439 | self.value = parmElement.get('value') | |
435 |
|
440 | |||
436 | def printattr(self): |
|
441 | def printattr(self): | |
437 |
|
442 | |||
438 | print "Parameter[%s]: name = %s, value = %s" %(self.id, self.name, self.value) |
|
443 | print "Parameter[%s]: name = %s, value = %s" %(self.id, self.name, self.value) | |
439 |
|
444 | |||
440 | if __name__ == '__main__': |
|
445 | if __name__ == '__main__': | |
441 |
|
446 | |||
442 | desc = "Este es un test" |
|
447 | desc = "Este es un test" | |
443 | filename = "test.xml" |
|
448 | filename = "test.xml" | |
444 |
|
449 | |||
445 | projectObj = Controller() |
|
450 | projectObj = Controller() | |
446 |
|
451 | |||
447 | projectObj.setParms(id = '191', name='test01', description=desc) |
|
452 | projectObj.setParms(id = '191', name='test01', description=desc) | |
448 |
|
453 | |||
449 | readBranchObj = projectObj.addReadBranch(dpath='mydata', dataformat='rawdata', readMode=0, startDate='1', endDate='3', startTime='4', endTime='5') |
|
454 | readBranchObj = projectObj.addReadBranch(dpath='mydata', dataformat='rawdata', readMode=0, startDate='1', endDate='3', startTime='4', endTime='5') | |
450 |
|
455 | |||
451 | procBranchObj = projectObj.addProcBranch(name='Branch1') |
|
456 | procBranchObj = projectObj.addProcBranch(name='Branch1') | |
452 |
|
457 | |||
453 | procBranchObj1 = projectObj.addProcBranch(name='Branch2') |
|
458 | procBranchObj1 = projectObj.addProcBranch(name='Branch2') | |
454 | upObj1 = procBranchObj.addUP(name='UP1', type='Voltage') |
|
459 | ||
455 |
upObj |
|
460 | upObj1 = procBranchObj.addUP(name='UP1', type='Voltage', inputId=readBranchObj.id) | |
|
461 | upObj2 = procBranchObj.addUP(name='UP2', type='Voltage', inputId=upObj1.id) | |||
456 |
|
462 | |||
457 | opObj11 = upObj1.addOperation(name='removeDC', priority=1) |
|
463 | opObj11 = upObj1.addOperation(name='removeDC', priority=1) | |
458 | opObj11.addParameter(name='type', value='1') |
|
464 | opObj11.addParameter(name='type', value='1') | |
459 |
|
465 | |||
460 |
|
||||
461 | opObj12 = upObj1.addOperation(name='decoder', priority=2) |
|
466 | opObj12 = upObj1.addOperation(name='decoder', priority=2) | |
462 | opObj12.addParameter(name='ncode', value='2') |
|
467 | opObj12.addParameter(name='ncode', value='2') | |
463 | opObj12.addParameter(name='nbauds', value='8') |
|
468 | opObj12.addParameter(name='nbauds', value='8') | |
464 | opObj12.addParameter(name='code0', value='001110011') |
|
469 | opObj12.addParameter(name='code0', value='001110011') | |
465 | opObj12.addParameter(name='code1', value='001110011') |
|
470 | opObj12.addParameter(name='code1', value='001110011') | |
466 |
|
471 | |||
467 | print "Escribiendo el archivo XML" |
|
472 | print "Escribiendo el archivo XML" | |
468 |
|
473 | |||
469 | projectObj.writeXml(filename) |
|
474 | projectObj.writeXml(filename) | |
470 |
|
475 | |||
471 | print "Leyendo el archivo XML" |
|
476 | print "Leyendo el archivo XML" | |
472 | projectObj.readXml(filename) |
|
477 | projectObj.readXml(filename) | |
473 | projectObj.printattr() |
|
478 | projectObj.printattr() | |
474 | No newline at end of file |
|
479 |
General Comments 0
You need to be logged in to leave comments.
Login now