|
1 /* |
|
2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the License "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * CScrXmlParser - Used to retrieve details from xml files for creating database and |
|
16 * Software environment updates. |
|
17 * |
|
18 */ |
|
19 |
|
20 |
|
21 /** |
|
22 @file |
|
23 @released |
|
24 @internalTechnology |
|
25 */ |
|
26 |
|
27 #include "xmlparser.h" |
|
28 #include "logs.h" |
|
29 #include "exception.h" |
|
30 #include "util.h" |
|
31 |
|
32 #include <xercesc/sax2/XMLReaderFactory.hpp> |
|
33 #include <xercesc/sax2/DefaultHandler.hpp> |
|
34 #include <xercesc/util/XMLString.hpp> |
|
35 #include <xercesc/util/PlatformUtils.hpp> |
|
36 #include <xercesc/framework/LocalFileInputSource.hpp> |
|
37 #include <xercesc/util/OutOfMemoryException.hpp> |
|
38 |
|
39 #include <string> |
|
40 #include <vector> |
|
41 |
|
42 #include <memory> |
|
43 #include <cstdio> |
|
44 |
|
45 XERCES_CPP_NAMESPACE_USE |
|
46 |
|
47 // these function pointers are used to call appropriate release methods of XMLString |
|
48 // present in the xerces library. |
|
49 typedef void (*releaseXmlChPtr) (XMLCh** buf); |
|
50 typedef void (*releaseChPtr) (char** buf); |
|
51 |
|
52 |
|
53 |
|
54 DllExport CScrXmlParser::CScrXmlParser() |
|
55 {} |
|
56 |
|
57 DllExport CScrXmlParser::~CScrXmlParser() |
|
58 {} |
|
59 |
|
60 /** |
|
61 Initializes the xml framework for DOM parsing. Registers an error handler for retrieving |
|
62 all errors while xml parsing. |
|
63 Retrieves database creation statements from the xml file. The DTD for the same is |
|
64 specified in the xml document. |
|
65 |
|
66 @param aDbFile name of the database file in xml format. |
|
67 |
|
68 @return list of database create statements in the form of a vector. |
|
69 */ |
|
70 |
|
71 DllExport std::vector<std::string>* CScrXmlParser::ParseDbSchema(const std::string& aDbFile) |
|
72 { |
|
73 std::vector<std::string>* dbSchema = NULL; |
|
74 |
|
75 try |
|
76 { |
|
77 LOGENTER("CScrXmlParser::GetDBSchema()"); |
|
78 |
|
79 XMLPlatformUtils::Initialize(); |
|
80 |
|
81 std::auto_ptr<xercesc::XercesDOMParser> configFileParser(new XercesDOMParser()); |
|
82 |
|
83 ConfigDomParser(*configFileParser); |
|
84 // set the error handler for the xml parser |
|
85 std::auto_ptr<SchemaErrorHandler> errHandler(new SchemaErrorHandler()); |
|
86 configFileParser->setErrorHandler(errHandler.get()); |
|
87 |
|
88 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSQLQuery( &XMLString::release, XMLString::transcode("SQLQuery") ); |
|
89 fn_auto_ptr<releaseXmlChPtr, XMLCh> dbFileName( &XMLString::release, XMLString::transcode(aDbFile.c_str()) ); |
|
90 |
|
91 dbSchema = new std::vector<std::string>(); |
|
92 |
|
93 LocalFileInputSource dbFile( dbFileName.get() ); |
|
94 configFileParser->parse(dbFile); |
|
95 |
|
96 // no need to free this pointer - owned by the parent parser object |
|
97 DOMDocument* xmlDoc = configFileParser->getDocument(); |
|
98 |
|
99 // Get the top-level element |
|
100 DOMElement* elementRoot = xmlDoc->getDocumentElement(); |
|
101 |
|
102 // Retrieve the nodes for CreateDatabase. |
|
103 DOMNodeList* createDbNode = elementRoot->getChildNodes(); |
|
104 const XMLSize_t createDbNodeCount = createDbNode->getLength(); |
|
105 |
|
106 // for each Transaction retrieve all tags |
|
107 for( XMLSize_t count = 0; count < createDbNodeCount; ++count ) |
|
108 { |
|
109 DOMNode* currentNode = createDbNode->item(count); |
|
110 DOMElement* currentElement = static_cast< xercesc::DOMElement* >( currentNode ); |
|
111 |
|
112 if( XMLString::equals(currentElement->getTagName(), tagSQLQuery.get())) |
|
113 { |
|
114 fn_auto_ptr<releaseChPtr, char> cleanupText( &XMLString::release, XMLString::transcode( currentElement->getTextContent()) ); |
|
115 std::string query(cleanupText.get()); |
|
116 dbSchema->push_back(query); |
|
117 } |
|
118 |
|
119 } // for |
|
120 } |
|
121 |
|
122 catch(XMLException& aXmlException) |
|
123 { |
|
124 delete dbSchema; |
|
125 XMLPlatformUtils::Terminate(); |
|
126 const XMLCh* msg = aXmlException.getMessage(); |
|
127 std::string msgStr = XMLString::transcode(msg); |
|
128 int errCode = aXmlException.getCode(); |
|
129 throw CException(msgStr,errCode); |
|
130 } |
|
131 catch(CException& aXmlException) |
|
132 { |
|
133 delete dbSchema; |
|
134 XMLPlatformUtils::Terminate(); |
|
135 throw aXmlException; |
|
136 } |
|
137 |
|
138 XMLPlatformUtils::Terminate(); |
|
139 |
|
140 LOGEXIT("CScrXmlParser::GetDBSchema()"); |
|
141 |
|
142 return dbSchema; |
|
143 } |
|
144 |
|
145 |
|
146 /** |
|
147 Initializes the xml framework for DOM parsing. Registers an error handler for retrieving |
|
148 all errors while xml parsing. |
|
149 |
|
150 Retrieves software environment details from the xml file. The DTD for the same is |
|
151 specified in the xml document. |
|
152 |
|
153 @param aEnvDetailFile name of the s/w environment file in xml format. |
|
154 |
|
155 @return list of details in the form of a vector. |
|
156 */ |
|
157 |
|
158 DllExport std::vector<XmlDetails::TScrEnvironmentDetails>* CScrXmlParser::GetEnvironmentDetails( const std::string aEnvDetailFile ) |
|
159 { |
|
160 |
|
161 std::vector<XmlDetails::TScrEnvironmentDetails>* environmentDetails = NULL; |
|
162 |
|
163 try |
|
164 { |
|
165 |
|
166 LOGENTER("CScrXmlParser::GetEnvironmentDetails()"); |
|
167 |
|
168 XMLPlatformUtils::Initialize(); |
|
169 |
|
170 std::auto_ptr<xercesc::XercesDOMParser> configFileParser(new XercesDOMParser()); |
|
171 |
|
172 ConfigDomParser(*configFileParser); |
|
173 // set the error handler for the xml parser |
|
174 std::auto_ptr<SchemaErrorHandler> errHandler(new SchemaErrorHandler()); |
|
175 configFileParser->setErrorHandler(errHandler.get()); |
|
176 |
|
177 // Tags and attributes used in XML file. |
|
178 // Can't call transcode till after Xerces Initialize() |
|
179 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagEnvironment( &XMLString::release, XMLString::transcode("Environment") ); |
|
180 |
|
181 environmentDetails = new std::vector<XmlDetails::TScrEnvironmentDetails>(); |
|
182 |
|
183 fn_auto_ptr<releaseXmlChPtr, XMLCh> envFileName( &XMLString::release, XMLString::transcode(aEnvDetailFile.c_str()) ); |
|
184 LocalFileInputSource envFile( envFileName.get() ); |
|
185 configFileParser->parse( envFile ); |
|
186 |
|
187 // no need to free this pointer - owned by the parent parser object |
|
188 DOMDocument* xmlDoc = configFileParser->getDocument(); |
|
189 |
|
190 // Get the top-level element which is SoftwareEnvironments. |
|
191 DOMElement* elementRoot = xmlDoc->getDocumentElement(); |
|
192 |
|
193 // Retrieve the nodes for Environment. |
|
194 DOMNodeList* entryNodes = elementRoot->getChildNodes(); |
|
195 const XMLSize_t nodeCount = entryNodes->getLength(); |
|
196 |
|
197 // for each Environment retrieve all tags |
|
198 for( XMLSize_t xx = 0; xx < nodeCount; ++xx ) |
|
199 { |
|
200 DOMNode* currentNode = entryNodes->item(xx); |
|
201 DOMElement* currentElement = static_cast< xercesc::DOMElement* >( currentNode ); |
|
202 |
|
203 // is not null and is an element |
|
204 if( XMLString::equals(currentElement->getTagName(), tagEnvironment.get())) |
|
205 { |
|
206 XmlDetails::TScrEnvironmentDetails scrEnvDetails = GetEnvironmentData(currentElement); |
|
207 environmentDetails->push_back(scrEnvDetails); |
|
208 } |
|
209 } |
|
210 } |
|
211 catch(XMLException& aXmlException) |
|
212 { |
|
213 XMLPlatformUtils::Terminate(); |
|
214 std::string msgStr = XMLString::transcode(aXmlException.getMessage()); |
|
215 int errCode = aXmlException.getCode(); |
|
216 throw CException(msgStr,errCode); |
|
217 } |
|
218 catch (CException& aXmlException) |
|
219 { |
|
220 XMLPlatformUtils::Terminate(); |
|
221 delete environmentDetails; |
|
222 throw aXmlException; |
|
223 } |
|
224 |
|
225 XMLPlatformUtils::Terminate(); |
|
226 |
|
227 LOGEXIT("CScrXmlParser::GetEnvironmentDetails()"); |
|
228 |
|
229 return environmentDetails; |
|
230 } |
|
231 |
|
232 |
|
233 /** |
|
234 Retrieves details from the s/w environment xml file. It retrieves details specific |
|
235 to the tags as specfied in the DTD which is part of the xml file. |
|
236 |
|
237 @param aElement the current Environment tag being processed. |
|
238 @param aParamDetails pointer to the vector to be populated with the details. |
|
239 |
|
240 */ |
|
241 XmlDetails::TScrEnvironmentDetails CScrXmlParser::GetEnvironmentData( const DOMElement* aEnvironment) |
|
242 { |
|
243 LOGENTER("CScrXmlParser::GetEnvironmentData()"); |
|
244 |
|
245 XmlDetails::TScrEnvironmentDetails scrEnvDetails; |
|
246 |
|
247 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSoftwareTypeNames( &XMLString::release, XMLString::transcode("SoftwareTypeNames") ); |
|
248 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagUniqueSoftwareTypeName( &XMLString::release, XMLString::transcode("UniqueSoftwareTypeName") ); |
|
249 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagLocalizableSwTypeName( &XMLString::release, XMLString::transcode("LocalizableSoftwareTypeName") ); |
|
250 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSifPluginUid( &XMLString::release, XMLString::transcode("SifPluginUid") ); |
|
251 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagInstallerSid( &XMLString::release, XMLString::transcode("InstallerSid") ); |
|
252 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagExecutionLayerSid( &XMLString::release, XMLString::transcode("ExecutionLayerSid") ); |
|
253 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagMIMEDetails( &XMLString::release, XMLString::transcode("MIMEDetails") ); |
|
254 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagMIMEType( &XMLString::release, XMLString::transcode("MIMEType") ); |
|
255 |
|
256 DOMNodeList* swTypeNames = aEnvironment->getElementsByTagName(tagSoftwareTypeNames.get()); |
|
257 DOMNode* swTypeNamesRoot = swTypeNames->item(0); |
|
258 DOMElement* swTypeNamesNode = static_cast< xercesc::DOMElement* >( swTypeNamesRoot ); |
|
259 |
|
260 DOMNodeList* uniqueSwTypeName = swTypeNamesNode->getElementsByTagName(tagUniqueSoftwareTypeName.get()); |
|
261 const XMLCh* textContent = uniqueSwTypeName->item(0)->getTextContent(); |
|
262 scrEnvDetails.iUniqueSoftwareTypeName = std::wstring(textContent); |
|
263 |
|
264 DOMNodeList* localizableSwTypeNames = swTypeNamesNode->getElementsByTagName(tagLocalizableSwTypeName.get()); |
|
265 const XMLSize_t localizableSwTypeNamesCount = localizableSwTypeNames->getLength(); |
|
266 for( XMLSize_t count=0 ; count<localizableSwTypeNamesCount ; ++count ) |
|
267 { |
|
268 DOMNode* localizableSwTypeNameRoot = localizableSwTypeNames->item(count); |
|
269 DOMElement* localizableSwTypeNameNode = static_cast< xercesc::DOMElement* >( localizableSwTypeNameRoot ); |
|
270 XmlDetails::TScrEnvironmentDetails::TLocalizedSoftwareTypeName localizedSwTypeName = GetLocalizedSoftwareTypeName(localizableSwTypeNameNode); |
|
271 scrEnvDetails.iLocalizedSoftwareTypeNames.push_back(localizedSwTypeName); |
|
272 } |
|
273 |
|
274 DOMNodeList* sifPluginUid = aEnvironment->getElementsByTagName(tagSifPluginUid.get()); |
|
275 textContent = (sifPluginUid->item(0))->getTextContent(); |
|
276 fn_auto_ptr<releaseChPtr,char> sifPluginUidText(&XMLString::release, XMLString::transcode(textContent)); |
|
277 int sifPluginUidValue = 0; |
|
278 sscanf(sifPluginUidText.get(),"%x",&sifPluginUidValue); |
|
279 scrEnvDetails.iSifPluginUid = sifPluginUidValue; |
|
280 |
|
281 DOMNodeList* installerSid = aEnvironment->getElementsByTagName(tagInstallerSid.get()); |
|
282 textContent = installerSid->item(0)->getTextContent(); |
|
283 fn_auto_ptr<releaseChPtr,char> installerSidText(&XMLString::release, XMLString::transcode(textContent)); |
|
284 int installerSidValue = 0; |
|
285 sscanf(installerSidText.get(),"%x",&installerSidValue); |
|
286 scrEnvDetails.iInstallerSid = installerSidValue; |
|
287 |
|
288 DOMNodeList* executionLayerSid = aEnvironment->getElementsByTagName(tagExecutionLayerSid.get()); |
|
289 textContent = executionLayerSid->item(0)->getTextContent(); |
|
290 fn_auto_ptr<releaseChPtr,char> executionLayerSidText(&XMLString::release, XMLString::transcode(textContent)); |
|
291 int executionLayerSidValue = 0; |
|
292 sscanf(executionLayerSidText.get(),"%x",&executionLayerSidValue); |
|
293 scrEnvDetails.iExecutionLayerSid = executionLayerSidValue; |
|
294 |
|
295 DOMNodeList* mimeDetails = aEnvironment->getElementsByTagName(tagMIMEDetails.get()); |
|
296 DOMNode* mimeDetailRoot = mimeDetails->item(0); |
|
297 DOMElement* mimeDetailNode = static_cast< xercesc::DOMElement* >( mimeDetailRoot ); |
|
298 DOMNodeList* mimes = mimeDetailNode->getElementsByTagName(tagMIMEType.get()); |
|
299 const XMLSize_t mimeCount = mimes->getLength(); |
|
300 for( XMLSize_t count=0 ; count<mimeCount ; ++count ) |
|
301 { |
|
302 const XMLCh* textContent = mimes->item(count)->getTextContent(); |
|
303 scrEnvDetails.iMIMEDetails.push_back(textContent); |
|
304 } |
|
305 |
|
306 LOGEXIT("CScrXmlParser::GetEnvironmentData()"); |
|
307 |
|
308 return scrEnvDetails; |
|
309 } |
|
310 |
|
311 |
|
312 XmlDetails::TScrPreProvisionDetail CScrXmlParser::GetPreProvisionDetails( const std::string aPreProvisionFile ) |
|
313 { |
|
314 XmlDetails::TScrPreProvisionDetail preProvisionDetail; |
|
315 try |
|
316 { |
|
317 |
|
318 LOGENTER("CScrXmlParser::GetPreProvisionDetails()"); |
|
319 |
|
320 XMLPlatformUtils::Initialize(); |
|
321 |
|
322 std::auto_ptr<xercesc::XercesDOMParser> configFileParser(new XercesDOMParser()); |
|
323 |
|
324 ConfigDomParser(*configFileParser); |
|
325 // set the error handler for the xml parser |
|
326 std::auto_ptr<SchemaErrorHandler> errHandler(new SchemaErrorHandler()); |
|
327 configFileParser->setErrorHandler(errHandler.get()); |
|
328 |
|
329 // Tags and attributes used in XML file. |
|
330 // Can't call transcode till after Xerces Initialize() |
|
331 // root tag |
|
332 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponent( &XMLString::release, XMLString::transcode("Component") ); |
|
333 fn_auto_ptr<releaseXmlChPtr, XMLCh> preProvisionFileName( &XMLString::release, XMLString::transcode(aPreProvisionFile.c_str()) ); |
|
334 |
|
335 LocalFileInputSource envFile( preProvisionFileName.get() ); |
|
336 configFileParser->parse( envFile ); |
|
337 |
|
338 // no need to free this pointer - owned by the parent parser object |
|
339 DOMDocument* xmlDoc = configFileParser->getDocument(); |
|
340 |
|
341 // Get the top-level element which is Component. |
|
342 DOMElement* elementRoot = xmlDoc->getDocumentElement(); |
|
343 |
|
344 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSoftwareTypeName( &XMLString::release, XMLString::transcode("SoftwareTypeName") ); |
|
345 |
|
346 DOMNodeList* softwaretype = elementRoot->getElementsByTagName(tagSoftwareTypeName.get()); |
|
347 const XMLCh* textContent = softwaretype->item(0)->getTextContent(); |
|
348 preProvisionDetail.iSoftwareTypeName = std::wstring(textContent); |
|
349 |
|
350 // Retrieve the nodes for Component. |
|
351 DOMNodeList* componentNodes = elementRoot->getElementsByTagName(tagComponent.get()); |
|
352 const XMLSize_t nodeCount = componentNodes->getLength(); |
|
353 |
|
354 |
|
355 // for each Component retrieve all tags |
|
356 for( XMLSize_t index = 0; index < nodeCount; ++index ) |
|
357 { |
|
358 DOMNode* currentNode = componentNodes->item(index); |
|
359 DOMElement* currentElement = static_cast< xercesc::DOMElement* >( currentNode ); |
|
360 |
|
361 preProvisionDetail.iComponents.push_back(GetPreProvisionData(currentElement)); |
|
362 } |
|
363 } |
|
364 catch(XMLException& aXmlException) |
|
365 { |
|
366 XMLPlatformUtils::Terminate(); |
|
367 std::string msgStr = XMLString::transcode(aXmlException.getMessage()); |
|
368 int errCode = aXmlException.getCode(); |
|
369 throw CException(msgStr,errCode); |
|
370 } |
|
371 catch (CException& aXmlException) |
|
372 { |
|
373 XMLPlatformUtils::Terminate(); |
|
374 throw aXmlException; |
|
375 } |
|
376 |
|
377 XMLPlatformUtils::Terminate(); |
|
378 |
|
379 return preProvisionDetail; |
|
380 } |
|
381 |
|
382 XmlDetails::TScrPreProvisionDetail::TComponent CScrXmlParser::GetPreProvisionData( const DOMElement* aDOMElement) |
|
383 { |
|
384 XmlDetails::TScrPreProvisionDetail::TComponent component; |
|
385 |
|
386 DOMNodeList* childNodes = aDOMElement->getChildNodes(); |
|
387 const XMLSize_t nodeCount = childNodes->getLength(); |
|
388 |
|
389 // tags contained in Component |
|
390 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentLocalizable( &XMLString::release, XMLString::transcode("ComponentLocalizable") ); |
|
391 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentProperty( &XMLString::release, XMLString::transcode("ComponentProperty") ); |
|
392 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentFile( &XMLString::release, XMLString::transcode("ComponentFile") ); |
|
393 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentDetails( &XMLString::release, XMLString::transcode("ComponentDetails") ); |
|
394 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentDependency( &XMLString::release, XMLString::transcode("ComponentDependency") ); |
|
395 |
|
396 XmlDetails::TScrPreProvisionDetail::TComponentDetails componentDetails = GetComponentDetails(aDOMElement); |
|
397 component.iComponentDetails = componentDetails; |
|
398 |
|
399 // for each ComponentProperty retrieve all tags |
|
400 for( XMLSize_t index = 0; index < nodeCount; ++index ) |
|
401 { |
|
402 DOMElement* currentElement = static_cast< xercesc::DOMElement* >( childNodes->item(index) ); |
|
403 |
|
404 // is not null and is an element |
|
405 if( XMLString::equals(currentElement->getTagName(), tagComponentLocalizable.get())) |
|
406 { |
|
407 XmlDetails::TScrPreProvisionDetail::TComponentLocalizable componentLocalizable = GetComponentLocalizable(currentElement); |
|
408 component.iComponentLocalizables.push_back(componentLocalizable); |
|
409 } |
|
410 else if( XMLString::equals(currentElement->getTagName(), tagComponentProperty.get())) |
|
411 { |
|
412 XmlDetails::TScrPreProvisionDetail::TComponentProperty componentProperty = GetComponentProperty(currentElement); |
|
413 component.iComponentProperties.push_back(componentProperty); |
|
414 } |
|
415 else if( XMLString::equals(currentElement->getTagName(), tagComponentFile.get())) |
|
416 { |
|
417 XmlDetails::TScrPreProvisionDetail::TComponentFile componentFile = GetComponentFile(currentElement); |
|
418 component.iComponentFiles.push_back(componentFile); |
|
419 } |
|
420 else if( XMLString::equals(currentElement->getTagName(), tagComponentDependency.get())) |
|
421 { |
|
422 XmlDetails::TScrPreProvisionDetail::TComponentDependency componentDependency = GetComponentDependency(currentElement); |
|
423 component.iComponentDependency = componentDependency; |
|
424 } |
|
425 } |
|
426 |
|
427 return component; |
|
428 } |
|
429 |
|
430 XmlDetails::TScrPreProvisionDetail::TComponentLocalizable CScrXmlParser::GetComponentLocalizable(const DOMElement* aDOMElement) |
|
431 { |
|
432 // tags in ComponentLocalizable |
|
433 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentLocalizableLocale( &XMLString::release, XMLString::transcode("ComponentLocalizable_Locale") ); |
|
434 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentLocalizableName( &XMLString::release, XMLString::transcode("ComponentLocalizable_Name") ); |
|
435 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentLocalizableVendor( &XMLString::release, XMLString::transcode("ComponentLocalizable_Vendor") ); |
|
436 |
|
437 DOMNodeList* locale = aDOMElement->getElementsByTagName(tagComponentLocalizableLocale.get()); |
|
438 DOMNodeList* name = aDOMElement->getElementsByTagName(tagComponentLocalizableName.get()); |
|
439 DOMNodeList* vendor = aDOMElement->getElementsByTagName(tagComponentLocalizableVendor.get()); |
|
440 |
|
441 XmlDetails::TScrPreProvisionDetail::TComponentLocalizable componentLocalizable; |
|
442 |
|
443 if(locale->getLength() != 0) |
|
444 { |
|
445 const XMLCh* textLocale = locale->item(0)->getTextContent(); |
|
446 componentLocalizable.iLocale = Util::WideCharToInteger(textLocale); |
|
447 } |
|
448 |
|
449 const XMLCh* textName = name->item(0)->getTextContent(); |
|
450 componentLocalizable.iName = textName; |
|
451 |
|
452 if(vendor->getLength() != 0) |
|
453 { |
|
454 const XMLCh* textVendor = vendor->item(0)->getTextContent(); |
|
455 componentLocalizable.iVendor = textVendor; |
|
456 } |
|
457 |
|
458 return componentLocalizable; |
|
459 |
|
460 } |
|
461 |
|
462 XmlDetails::TScrPreProvisionDetail::TComponentProperty CScrXmlParser::GetComponentProperty(const DOMElement* aEnvironment) |
|
463 { |
|
464 // tags in ComponentProperty |
|
465 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyName( &XMLString::release, XMLString::transcode("Name") ); |
|
466 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyLocale( &XMLString::release, XMLString::transcode("ComponentProperty_Locale") ); |
|
467 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyValue( &XMLString::release, XMLString::transcode("ComponentProperty_Value") ); |
|
468 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyIsBinary( &XMLString::release, XMLString::transcode("ComponentProperty_IsBinary") ); |
|
469 |
|
470 // tags of ComponentProperty_Value |
|
471 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyIntValue( &XMLString::release, XMLString::transcode("ComponentProperty_IntValue") ); |
|
472 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagComponentPropertyStrValue( &XMLString::release, XMLString::transcode("ComponentProperty_StrValue") ); |
|
473 |
|
474 // attribute - name |
|
475 DOMNamedNodeMap* attributes = aEnvironment->getAttributes(); |
|
476 DOMNode* name = attributes->getNamedItem(tagComponentPropertyName.get()); |
|
477 |
|
478 DOMNodeList* locale = aEnvironment->getElementsByTagName(tagComponentPropertyLocale.get()); |
|
479 DOMNodeList* value = aEnvironment->getElementsByTagName(tagComponentPropertyValue.get()); |
|
480 DOMNodeList* isBinary = aEnvironment->getElementsByTagName(tagComponentPropertyIsBinary.get()); |
|
481 |
|
482 XmlDetails::TScrPreProvisionDetail::TComponentProperty componentProperty; |
|
483 |
|
484 const XMLCh* textName = name->getTextContent(); |
|
485 componentProperty.iName = textName; |
|
486 |
|
487 if(locale->getLength() != 0) |
|
488 { |
|
489 const XMLCh* textLocale = locale->item(0)->getTextContent(); |
|
490 componentProperty.iLocale = Util::WideCharToInteger(textLocale); |
|
491 } |
|
492 |
|
493 DOMNodeList* childNodes = value->item(0)->getChildNodes(); |
|
494 const XMLSize_t nodeCount = childNodes->getLength(); |
|
495 |
|
496 for(int index = 0; index< nodeCount; ++index) |
|
497 { |
|
498 DOMElement* currentElement = static_cast< xercesc::DOMElement* >( childNodes->item(index) ); |
|
499 if( XMLString::equals(currentElement->getTagName(), tagComponentPropertyIntValue.get())) |
|
500 { |
|
501 componentProperty.iIsIntValue = true; |
|
502 componentProperty.iValue = currentElement->getTextContent(); |
|
503 break; |
|
504 } |
|
505 else if( XMLString::equals(currentElement->getTagName(), tagComponentPropertyStrValue.get())) |
|
506 { |
|
507 componentProperty.iIsIntValue = false; |
|
508 componentProperty.iValue = currentElement->getTextContent(); |
|
509 break; |
|
510 } |
|
511 } |
|
512 |
|
513 if(isBinary->getLength() != 0) |
|
514 { |
|
515 const XMLCh* textIsBinary = isBinary->item(0)->getTextContent(); |
|
516 componentProperty.iIsStr8Bit = Util::WideCharToInteger(textIsBinary); |
|
517 } |
|
518 |
|
519 return componentProperty; |
|
520 |
|
521 } |
|
522 |
|
523 XmlDetails::TScrPreProvisionDetail::TComponentFile CScrXmlParser::GetComponentFile( const DOMElement* aDOMElement) |
|
524 { |
|
525 XmlDetails::TScrPreProvisionDetail::TComponentFile componentFile; |
|
526 |
|
527 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagFileProperty( &XMLString::release, XMLString::transcode("FileProperty") ); |
|
528 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagLocation( &XMLString::release, XMLString::transcode("Location") ); |
|
529 |
|
530 DOMNodeList* fileProperties = aDOMElement->getElementsByTagName(tagFileProperty.get()); |
|
531 const XMLSize_t filePropCount = fileProperties->getLength(); |
|
532 |
|
533 // for each ComponentFile retrieve all tags |
|
534 for( XMLSize_t index = 0; index < filePropCount; ++index ) |
|
535 { |
|
536 DOMElement* currentFileProp = static_cast< xercesc::DOMElement* >( fileProperties->item(index) ); |
|
537 |
|
538 XmlDetails::TScrPreProvisionDetail::TComponentFile::TFileProperty fileProperty = GetFileProperty(currentFileProp); |
|
539 componentFile.iFileProperties.push_back(fileProperty); |
|
540 } |
|
541 |
|
542 // attribute - location |
|
543 DOMNamedNodeMap* attributes = aDOMElement->getAttributes(); |
|
544 DOMNode* location = attributes->getNamedItem(tagLocation.get()); |
|
545 componentFile.iLocation = location->getTextContent(); |
|
546 |
|
547 return componentFile; |
|
548 } |
|
549 |
|
550 XmlDetails::TScrPreProvisionDetail::TComponentDependency CScrXmlParser::GetComponentDependency( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement) |
|
551 { |
|
552 XmlDetails::TScrPreProvisionDetail::TComponentDependency componentDependency; |
|
553 |
|
554 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagDepList( &XMLString::release, XMLString::transcode("DependencyList") ); |
|
555 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagDependentId( &XMLString::release, XMLString::transcode("DependentId") ); |
|
556 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSupplierId( &XMLString::release, XMLString::transcode("SupplierId") ); |
|
557 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagFromVersion( &XMLString::release, XMLString::transcode("FromVersion") ); |
|
558 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagToVersion( &XMLString::release, XMLString::transcode("ToVersion") ); |
|
559 |
|
560 DOMNodeList* depList = aDOMElement->getElementsByTagName(tagDepList.get()); |
|
561 const XMLSize_t depListCount = depList->getLength(); |
|
562 |
|
563 // for each ComponentFile retrieve all tags |
|
564 for( XMLSize_t index = 0; index < depListCount; ++index ) |
|
565 { |
|
566 XmlDetails::TScrPreProvisionDetail::TComponentDependency::TComponentDependencyDetail componentDependencyDetail; |
|
567 DOMElement* currentDepDetail = static_cast< xercesc::DOMElement* >( depList->item(index) ); |
|
568 |
|
569 DOMNodeList* supplierId = currentDepDetail->getElementsByTagName(tagSupplierId.get()); |
|
570 const XMLCh* textSupplierId = supplierId->item(0)->getTextContent(); |
|
571 componentDependencyDetail.iSupplierId = std::wstring(textSupplierId); |
|
572 |
|
573 DOMNodeList* fromVersion = currentDepDetail->getElementsByTagName(tagFromVersion.get()); |
|
574 const XMLCh* textFromVersion = fromVersion->item(0)->getTextContent(); |
|
575 componentDependencyDetail.iFromVersion = std::wstring(textFromVersion); |
|
576 |
|
577 DOMNodeList* toVersion = currentDepDetail->getElementsByTagName(tagToVersion.get()); |
|
578 const XMLCh* textToVersion = toVersion->item(0)->getTextContent(); |
|
579 componentDependencyDetail.iToVersion = std::wstring(textToVersion); |
|
580 |
|
581 componentDependency.iComponentDependencyList.push_back(componentDependencyDetail); |
|
582 |
|
583 } |
|
584 |
|
585 // attribute - location |
|
586 DOMNamedNodeMap* attributes = aDOMElement->getAttributes(); |
|
587 DOMNode* dependentId = attributes->getNamedItem(tagDependentId.get()); |
|
588 componentDependency.iDependentId = dependentId->getTextContent(); |
|
589 |
|
590 return componentDependency; |
|
591 } |
|
592 |
|
593 XmlDetails::TScrPreProvisionDetail::TComponentFile::TFileProperty |
|
594 CScrXmlParser::GetFileProperty( const DOMElement* aDOMElement) |
|
595 { |
|
596 // tag for FileProperty |
|
597 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagFilePropertyName( &XMLString::release, XMLString::transcode("Name") ); |
|
598 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagFilePropertyValue( &XMLString::release, XMLString::transcode("FileProperty_Value") ); |
|
599 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagFilePropertyIsBinary( &XMLString::release, XMLString::transcode("FileProperty_IsBinary") ); |
|
600 |
|
601 // tags for FileProperty_Value |
|
602 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagFilePropertyIntValue( &XMLString::release, XMLString::transcode("FileProperty_IntValue") ); |
|
603 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagFilePropertyStrValue( &XMLString::release, XMLString::transcode("FileProperty_StrValue") ); |
|
604 |
|
605 XmlDetails::TScrPreProvisionDetail::TComponentFile::TFileProperty fileProperty; |
|
606 |
|
607 // attribute - name |
|
608 DOMNamedNodeMap* attributes = aDOMElement->getAttributes(); |
|
609 DOMNode* name = attributes->getNamedItem(tagFilePropertyName.get()); |
|
610 |
|
611 DOMNodeList* value = aDOMElement->getElementsByTagName(tagFilePropertyValue.get()); |
|
612 DOMNodeList* isBinary = aDOMElement->getElementsByTagName(tagFilePropertyIsBinary.get()); |
|
613 |
|
614 const XMLCh* textName = name->getTextContent(); |
|
615 fileProperty.iName = textName; |
|
616 |
|
617 int valueLength = value->getLength(); |
|
618 if(valueLength != 0) |
|
619 { |
|
620 for(int valIndex = 0; valIndex< valueLength; ++valIndex) |
|
621 { |
|
622 DOMElement* currentElement = static_cast< xercesc::DOMElement* >( value->item(valIndex) ); |
|
623 DOMNodeList* childNodes = currentElement->getChildNodes(); |
|
624 const XMLSize_t nodeCount = childNodes->getLength(); |
|
625 for(int index = 0; index< nodeCount; ++index) |
|
626 { |
|
627 DOMElement* valueElement = static_cast< xercesc::DOMElement* >( childNodes->item(index) ); |
|
628 if( XMLString::equals(valueElement->getTagName(), tagFilePropertyIntValue.get())) |
|
629 { |
|
630 fileProperty.iIsIntValue = true; |
|
631 fileProperty.iValue = currentElement->getTextContent(); |
|
632 } |
|
633 else if( XMLString::equals(valueElement->getTagName(), tagFilePropertyStrValue.get())) |
|
634 { |
|
635 fileProperty.iIsIntValue = false; |
|
636 fileProperty.iValue = currentElement->getTextContent(); |
|
637 } |
|
638 } |
|
639 } |
|
640 } |
|
641 return fileProperty; |
|
642 } |
|
643 |
|
644 XmlDetails::TScrPreProvisionDetail::TComponentDetails |
|
645 CScrXmlParser::GetComponentDetails( const DOMElement* aDOMElement) |
|
646 { |
|
647 // tags for ComponentDetails |
|
648 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagRemovable( &XMLString::release, XMLString::transcode("Removable") ); |
|
649 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSize( &XMLString::release, XMLString::transcode("Size") ); |
|
650 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagScomoState( &XMLString::release, XMLString::transcode("ScomoState") ); |
|
651 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagGlobalId( &XMLString::release, XMLString::transcode("GlobalId") ); |
|
652 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagVersion( &XMLString::release, XMLString::transcode("Version") ); |
|
653 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagOriginVerified( &XMLString::release, XMLString::transcode("OriginVerified") ); |
|
654 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagHidden( &XMLString::release, XMLString::transcode("Hidden") ); |
|
655 |
|
656 XmlDetails::TScrPreProvisionDetail::TComponentDetails componentDetails; |
|
657 |
|
658 DOMNodeList* removable = aDOMElement->getElementsByTagName(tagRemovable.get()); |
|
659 DOMNodeList* size = aDOMElement->getElementsByTagName(tagSize.get()); |
|
660 DOMNodeList* scomoState = aDOMElement->getElementsByTagName(tagScomoState.get()); |
|
661 DOMNodeList* globalId = aDOMElement->getElementsByTagName(tagGlobalId.get()); |
|
662 DOMNodeList* versionDetail = aDOMElement->getElementsByTagName(tagVersion.get()); |
|
663 DOMNodeList* originVerified = aDOMElement->getElementsByTagName(tagOriginVerified.get()); |
|
664 DOMNodeList* hidden = aDOMElement->getElementsByTagName(tagHidden.get()); |
|
665 |
|
666 if( removable->getLength() != 0) |
|
667 { |
|
668 const XMLCh* textRemovable = removable->item(0)->getTextContent(); |
|
669 componentDetails.iIsRemovable = Util::WideCharToInteger(textRemovable); |
|
670 } |
|
671 |
|
672 if( size->getLength() != 0) |
|
673 { |
|
674 const XMLCh* textSize = size->item(0)->getTextContent(); |
|
675 componentDetails.iSize = Util::WideCharToInteger(textSize); |
|
676 } |
|
677 |
|
678 if( scomoState->getLength() != 0) |
|
679 { |
|
680 const XMLCh* textScomoState = scomoState->item(0)->getTextContent(); |
|
681 componentDetails.iScomoState = Util::WideCharToInteger(textScomoState); |
|
682 } |
|
683 |
|
684 if( globalId->getLength() != 0) |
|
685 { |
|
686 const XMLCh* textGlobalId = globalId->item(0)->getTextContent(); |
|
687 componentDetails.iGlobalId = textGlobalId; |
|
688 } |
|
689 |
|
690 if( versionDetail->getLength() != 0) |
|
691 { |
|
692 // tags for Version |
|
693 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagMajor( &XMLString::release, XMLString::transcode("Major") ); |
|
694 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagMinor( &XMLString::release, XMLString::transcode("Minor") ); |
|
695 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagBuild( &XMLString::release, XMLString::transcode("Build") ); |
|
696 |
|
697 DOMElement* versionElement = static_cast< xercesc::DOMElement* > (versionDetail->item(0)); |
|
698 DOMNamedNodeMap* attributes = versionElement->getAttributes(); |
|
699 DOMNode* major = attributes->getNamedItem(tagMajor.get()); |
|
700 DOMNode* minor = attributes->getNamedItem(tagMinor.get()); |
|
701 DOMNode* build = attributes->getNamedItem(tagBuild.get()); |
|
702 |
|
703 componentDetails.iVersion.iMajor = major->getTextContent(); |
|
704 componentDetails.iVersion.iMinor = minor->getTextContent(); |
|
705 componentDetails.iVersion.iBuild = build->getTextContent(); |
|
706 } |
|
707 |
|
708 if( originVerified->getLength() != 0) |
|
709 { |
|
710 const XMLCh* textOriginVerified = originVerified->item(0)->getTextContent(); |
|
711 componentDetails.iOriginVerified = Util::WideCharToInteger(textOriginVerified); |
|
712 } |
|
713 |
|
714 if( hidden->getLength() != 0) |
|
715 { |
|
716 const XMLCh* textHidden = hidden->item(0)->getTextContent(); |
|
717 componentDetails.iIsHidden = Util::WideCharToInteger(textHidden); |
|
718 } |
|
719 |
|
720 return componentDetails; |
|
721 } |
|
722 |
|
723 XmlDetails::TScrEnvironmentDetails::TLocalizedSoftwareTypeName |
|
724 CScrXmlParser::GetLocalizedSoftwareTypeName(const DOMElement* aDOMElement) |
|
725 { |
|
726 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSwTypeNameLocale( &XMLString::release, XMLString::transcode("Locale") ); |
|
727 fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSwTypeNameValue( &XMLString::release, XMLString::transcode("Value") ); |
|
728 |
|
729 DOMNamedNodeMap* attributes = aDOMElement->getAttributes(); |
|
730 DOMNode* locale = attributes->getNamedItem(tagSwTypeNameLocale.get()); |
|
731 DOMNode* name = attributes->getNamedItem(tagSwTypeNameValue.get()); |
|
732 |
|
733 XmlDetails::TScrEnvironmentDetails::TLocalizedSoftwareTypeName localizedSwTypeName; |
|
734 |
|
735 const XMLCh* textLocale = locale->getTextContent(); |
|
736 localizedSwTypeName.iLocale = Util::WideCharToInteger(textLocale); |
|
737 |
|
738 const XMLCh* textName = name->getTextContent(); |
|
739 localizedSwTypeName.iName = textName; |
|
740 |
|
741 return localizedSwTypeName; |
|
742 } |
|
743 |
|
744 void CScrXmlParser::ConfigDomParser(xercesc::XercesDOMParser& aDomParser) |
|
745 { |
|
746 aDomParser.setValidationScheme( XercesDOMParser::Val_Always ); |
|
747 aDomParser.setValidationSchemaFullChecking(true); |
|
748 } |
|
749 |
|
750 /** |
|
751 * Handles all warnings received while xml parsing. |
|
752 */ |
|
753 void SchemaErrorHandler::warning (const SAXParseException &exc) |
|
754 { |
|
755 std::string msg( XMLString::transcode(exc.getMessage()) ); |
|
756 LOGWARN(msg); |
|
757 throw CException(msg,ExceptionCodes::EWarning); |
|
758 } |
|
759 |
|
760 /** |
|
761 * Handles all errors received while xml parsing. |
|
762 */ |
|
763 void SchemaErrorHandler::error (const SAXParseException &exc) |
|
764 { |
|
765 std::string msg( XMLString::transcode(exc.getMessage()) ); |
|
766 resetErrors(); |
|
767 LOGERROR(msg); |
|
768 throw CException(msg, ExceptionCodes::EParseError); |
|
769 } |
|
770 |
|
771 /** |
|
772 * Handles all fatal errors received while xml parsing. |
|
773 */ |
|
774 void SchemaErrorHandler::fatalError (const SAXParseException &exc) |
|
775 { |
|
776 std::string msg( XMLString::transcode(exc.getMessage()) ); |
|
777 resetErrors(); |
|
778 LOGERROR(msg); |
|
779 throw CException(msg,ExceptionCodes::EFatalError); |
|
780 } |
|
781 |
|
782 /** |
|
783 * Called if an error occurs while reintializing the current xml handler. |
|
784 */ |
|
785 void SchemaErrorHandler::resetErrors () |
|
786 { |
|
787 std::string msg( "Resetting error handler object" ); |
|
788 LOGINFO(msg); |
|
789 } |