1 martin 1.136 //%LICENSE////////////////////////////////////////////////////////////////
|
2 martin 1.137 //
|
3 martin 1.136 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
|
9 martin 1.137 //
|
10 martin 1.136 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
|
16 martin 1.137 //
|
17 martin 1.136 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
|
19 martin 1.137 //
|
20 martin 1.136 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
21 martin 1.137 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
22 martin 1.136 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
27 martin 1.137 //
|
28 martin 1.136 //////////////////////////////////////////////////////////////////////////
|
29 mike 1.23 //
30 //%/////////////////////////////////////////////////////////////////////////////
|
31 mday 1.45 #include <Pegasus/Common/Config.h>
|
32 thilo.boehm 1.131 #include <Pegasus/Common/Constants.h>
|
33 mike 1.120 #include <errno.h>
|
34 mike 1.23 #include <cctype>
35 #include <cstdio>
36 #include <cstdlib>
|
37 gs.keenan 1.107 #if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
|
38 kumpf 1.122 # include <errno.h>
|
39 mday 1.45 #endif
|
40 mike 1.23 #include "CIMName.h"
|
41 kumpf 1.135 #include "CIMNameCast.h"
|
42 mike 1.23 #include "XmlReader.h"
43 #include "XmlWriter.h"
44 #include "CIMQualifier.h"
45 #include "CIMQualifierDecl.h"
46 #include "CIMClass.h"
47 #include "CIMInstance.h"
48 #include "CIMObject.h"
|
49 mike 1.25 #include "CIMParamValue.h"
|
50 kumpf 1.72 #include "System.h"
|
51 humberto 1.91 #include "XmlConstants.h"
|
52 kumpf 1.122
|
53 humberto 1.85 #include <Pegasus/Common/MessageLoader.h>
|
54 kumpf 1.126 #include <Pegasus/Common/StringConversion.h>
|
55 joyce.j 1.112 #include <Pegasus/Common/AutoPtr.h>
|
56 humberto 1.85
|
57 mike 1.25 PEGASUS_USING_STD;
|
58 mike 1.23 PEGASUS_NAMESPACE_BEGIN
59
60 static const Uint32 MESSAGE_SIZE = 128;
61
62 //------------------------------------------------------------------------------
63 //
|
64 kumpf 1.49 // getXmlDeclaration()
65 //
66 // <?xml version="1.0" encoding="utf-8"?>
|
67 mike 1.23 //
68 //------------------------------------------------------------------------------
69
|
70 kumpf 1.49 void XmlReader::getXmlDeclaration(
|
71 kumpf 1.122 XmlParser& parser,
|
72 kumpf 1.49 const char*& xmlVersion,
73 const char*& xmlEncoding)
|
74 mike 1.23 {
|
75 kumpf 1.49 XmlEntry entry;
76
|
77 mike 1.23 if (!parser.next(entry) ||
|
78 kumpf 1.122 entry.type != XmlEntry::XML_DECLARATION ||
79 strcmp(entry.text, "xml") != 0)
|
80 mike 1.23 {
|
81 kumpf 1.122 MessageLoaderParms mlParms(
82 "Common.XmlReader.EXPECTED_XML_STYLE",
83 "Expected <?xml ... ?> style declaration");
84 throw XmlValidationError(parser.getLine(), mlParms);
|
85 kumpf 1.49 }
86
|
87 kumpf 1.122 if (!entry.getAttributeValue("version", xmlVersion))
88 {
89 MessageLoaderParms mlParms(
90 "Common.XmlReader.MISSING_XML_ATTRIBUTE",
91 "missing xml.version attribute");
92 throw XmlValidationError(parser.getLine(), mlParms);
|
93 humberto 1.85 }
|
94 kumpf 1.49
95 if (!entry.getAttributeValue("encoding", xmlEncoding))
96 {
97 // ATTN-RK-P3-20020403: Is there a default encoding?
|
98 mike 1.23 }
99 }
100
101 //------------------------------------------------------------------------------
102 //
|
103 mike 1.25 // testXmlDeclaration ()
104 //
105 //------------------------------------------------------------------------------
106
107 Boolean XmlReader::testXmlDeclaration (
108 XmlParser& parser,
109 XmlEntry& entry)
110 {
111 if (!parser.next (entry) ||
112 entry.type != XmlEntry::XML_DECLARATION ||
113 strcmp (entry.text, "xml") != 0)
114 {
115 parser.putBack (entry);
116 return false;
117 }
118
119 return true;
120 }
121
122 //------------------------------------------------------------------------------
123 //
|
124 mike 1.23 // expectStartTag()
125 //
126 //------------------------------------------------------------------------------
127
128 void XmlReader::expectStartTag(
|
129 kumpf 1.122 XmlParser& parser,
|
130 mike 1.23 XmlEntry& entry,
131 const char* tagName)
132 {
133 if (!parser.next(entry) ||
|
134 kumpf 1.122 entry.type != XmlEntry::START_TAG ||
135 strcmp(entry.text, tagName) != 0)
|
136 mike 1.23 {
|
137 kumpf 1.122 MessageLoaderParms mlParms(
138 "Common.XmlReader.EXPECTED_OPEN",
139 "Expected open of $0 element",
140 tagName);
141 throw XmlValidationError(parser.getLine(), mlParms);
|
142 mike 1.23 }
143 }
144
145 //------------------------------------------------------------------------------
146 //
147 // expectEndTag()
148 //
149 //------------------------------------------------------------------------------
150
151 void XmlReader::expectEndTag(XmlParser& parser, const char* tagName)
152 {
153 XmlEntry entry;
154
155 if (!parser.next(entry) ||
|
156 kumpf 1.122 entry.type != XmlEntry::END_TAG ||
157 strcmp(entry.text, tagName) != 0)
|
158 mike 1.23 {
|
159 kumpf 1.122 MessageLoaderParms mlParms(
160 "Common.XmlReader.EXPECTED_CLOSE",
161 "Expected close of $0 element, got $1 instead",
162 tagName,entry.text);
163 throw XmlValidationError(parser.getLine(), mlParms);
|
164 mike 1.23 }
165 }
166
167 //------------------------------------------------------------------------------
168 //
169 // expectStartTagOrEmptyTag()
170 //
171 //------------------------------------------------------------------------------
172
173 void XmlReader::expectStartTagOrEmptyTag(
|
174 kumpf 1.122 XmlParser& parser,
|
175 mike 1.23 XmlEntry& entry,
176 const char* tagName)
177 {
178 if (!parser.next(entry) ||
|
179 kumpf 1.122 (entry.type != XmlEntry::START_TAG &&
180 entry.type != XmlEntry::EMPTY_TAG) ||
181 strcmp(entry.text, tagName) != 0)
182 {
183 MessageLoaderParms mlParms(
184 "Common.XmlReader.EXPECTED_OPENCLOSE",
185 "Expected either open or open/close $0 element",
186 tagName);
187 throw XmlValidationError(parser.getLine(), mlParms);
|
188 mike 1.23 }
189 }
190
191 //------------------------------------------------------------------------------
192 //
193 // expectContentOrCData()
194 //
195 //------------------------------------------------------------------------------
196
197 Boolean XmlReader::expectContentOrCData(
|
198 kumpf 1.122 XmlParser& parser,
|
199 mike 1.23 XmlEntry& entry)
200 {
201 if (!parser.next(entry) ||
|
202 kumpf 1.122 (entry.type != XmlEntry::CONTENT &&
203 entry.type != XmlEntry::CDATA))
|
204 mike 1.23 {
|
205 kumpf 1.122 MessageLoaderParms mlParms(
206 "Common.XmlReader.EXPECTED_CDATA",
|
207 mike 1.143 "Expected content or CDATA");
|
208 kumpf 1.122 throw XmlValidationError(parser.getLine(), mlParms);
|
209 mike 1.23 }
210
211 return true;
212 }
213
214 //------------------------------------------------------------------------------
215 //
216 // testStartTag()
217 //
218 //------------------------------------------------------------------------------
219
220 Boolean XmlReader::testStartTag(
|
221 kumpf 1.122 XmlParser& parser,
|
222 mike 1.23 XmlEntry& entry,
223 const char* tagName)
224 {
225 if (!parser.next(entry) ||
|
226 kumpf 1.122 entry.type != XmlEntry::START_TAG ||
227 strcmp(entry.text, tagName) != 0)
|
228 mike 1.23 {
|
229 kumpf 1.122 parser.putBack(entry);
230 return false;
|
231 mike 1.23 }
232
233 return true;
234 }
235
236 //------------------------------------------------------------------------------
237 //
|
238 kumpf 1.48 // testEndTag()
|
239 mike 1.23 //
240 //------------------------------------------------------------------------------
241
242 Boolean XmlReader::testEndTag(XmlParser& parser, const char* tagName)
243 {
244 XmlEntry entry;
245
246 if (!parser.next(entry) ||
|
247 kumpf 1.122 entry.type != XmlEntry::END_TAG ||
248 strcmp(entry.text, tagName) != 0)
|
249 mike 1.23 {
|
250 kumpf 1.122 parser.putBack(entry);
251 return false;
|
252 mike 1.23 }
253
254 return true;
255 }
256
257 //------------------------------------------------------------------------------
258 //
259 // testStartTagOrEmptyTag()
260 //
261 //------------------------------------------------------------------------------
262
263 Boolean XmlReader::testStartTagOrEmptyTag(
|
264 kumpf 1.122 XmlParser& parser,
|
265 mike 1.23 XmlEntry& entry,
266 const char* tagName)
267 {
|
268 r.kieninger 1.142 if (!parser.next(entry))
269 {
270 return false;
271 }
272 if ((entry.type != XmlEntry::START_TAG &&
273 entry.type != XmlEntry::EMPTY_TAG) ||
|
274 kumpf 1.122 strcmp(entry.text, tagName) != 0)
|
275 mike 1.23 {
|
276 kumpf 1.122 parser.putBack(entry);
277 return false;
|
278 mike 1.23 }
279
280 return true;
281 }
282
283 //------------------------------------------------------------------------------
284 //
|
285 kumpf 1.95 // testStartTagOrEmptyTag()
286 //
287 //------------------------------------------------------------------------------
288
289 Boolean XmlReader::testStartTagOrEmptyTag(
|
290 kumpf 1.122 XmlParser& parser,
|
291 kumpf 1.95 XmlEntry& entry)
292 {
293 if (!parser.next(entry) ||
|
294 kumpf 1.122 (entry.type != XmlEntry::START_TAG &&
295 entry.type != XmlEntry::EMPTY_TAG))
|
296 kumpf 1.95 {
|
297 kumpf 1.122 parser.putBack(entry);
298 return false;
|
299 kumpf 1.95 }
300
301 return true;
302 }
303
304 //------------------------------------------------------------------------------
305 //
|
306 mike 1.23 // testContentOrCData()
307 //
308 //------------------------------------------------------------------------------
309
310 Boolean XmlReader::testContentOrCData(
|
311 kumpf 1.122 XmlParser& parser,
|
312 mike 1.23 XmlEntry& entry)
313 {
314 if (!parser.next(entry) ||
|
315 kumpf 1.122 (entry.type != XmlEntry::CONTENT &&
316 entry.type != XmlEntry::CDATA))
|
317 mike 1.23 {
|
318 kumpf 1.122 parser.putBack(entry);
319 return false;
|
320 mike 1.23 }
321
322 return true;
323 }
324
325 //------------------------------------------------------------------------------
326 //
|
327 kumpf 1.34 // getCimStartTag()
|
328 mike 1.23 //
329 // <!ELEMENT CIM (MESSAGE|DECLARATION)>
|
330 kumpf 1.122 // <!ATTRLIST CIM
|
331 mike 1.23 // CIMVERSION CDATA #REQUIRED
332 // DTDVERSION CDATA #REQUIRED>
333 //
334 //------------------------------------------------------------------------------
335
|
336 kumpf 1.34 void XmlReader::getCimStartTag(
|
337 kumpf 1.122 XmlParser& parser,
|
338 kumpf 1.34 const char*& cimVersion,
339 const char*& dtdVersion)
|
340 mike 1.23 {
341 XmlEntry entry;
342 XmlReader::expectStartTag(parser, entry, "CIM");
343
|
344 kumpf 1.122 if (!entry.getAttributeValue("CIMVERSION", cimVersion))
345 {
346 MessageLoaderParms mlParms(
347 "Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",
348 "missing CIM.CIMVERSION attribute");
349 throw XmlValidationError(parser.getLine(), mlParms);
|
350 humberto 1.85 }
351
|
352 kumpf 1.122 if (!entry.getAttributeValue("DTDVERSION", dtdVersion))
353 {
354 MessageLoaderParms mlParms(
355 "Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",
356 "missing CIM.DTDVERSION attribute");
357 throw XmlValidationError(parser.getLine(), mlParms);
|
358 humberto 1.85 }
|
359 mike 1.23 }
360
361 //------------------------------------------------------------------------------
362 //
363 // getCimNameAttribute()
364 //
365 // <!ENTITY % CIMName "NAME CDATA #REQUIRED">
366 //
367 //------------------------------------------------------------------------------
368
|
369 kumpf 1.74 CIMName XmlReader::getCimNameAttribute(
|
370 kumpf 1.122 Uint32 lineNumber,
|
371 mike 1.23 const XmlEntry& entry,
372 const char* elementName,
373 Boolean acceptNull)
374 {
|
375 mike 1.134 const char* name;
|
376 mike 1.23
377 if (!entry.getAttributeValue("NAME", name))
|
378 kumpf 1.122 {
379 char buffer[MESSAGE_SIZE];
380 sprintf(buffer, "%s.NAME", elementName);
381 MessageLoaderParms mlParms(
382 "Common.XmlReader.MISSING_ATTRIBUTE",
383 "missing $0 attribute",
384 buffer);
|
385 humberto 1.85
|
386 kumpf 1.122 throw XmlValidationError(lineNumber, mlParms);
|
387 mike 1.23 }
388
|
389 mike 1.134 if (acceptNull && *name == '\0')
390 return CIMName();
391
392 Uint32 size = CIMNameLegalASCII(name);
393
394 if (size)
395 {
396 String tmp(name, size);
397 return CIMName(CIMNameCast(tmp));
398 }
|
399 kumpf 1.122
|
400 mike 1.23 if (!CIMName::legal(name))
401 {
|
402 marek 1.145 char buffer[MESSAGE_SIZE];
403 sprintf(buffer, "%s.NAME", elementName);
|
404 karl 1.148
|
405 marek 1.145 MessageLoaderParms mlParms(
406 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
407 "Illegal value for $0 attribute",
408 buffer);
|
409 karl 1.148
|
410 marek 1.145 throw XmlSemanticError(lineNumber, mlParms);
|
411 mike 1.23 }
|
412 mike 1.134
|
413 mike 1.133 return CIMNameCast(name);
|
414 mike 1.23 }
415
416 //------------------------------------------------------------------------------
417 //
418 // getClassNameAttribute()
419 //
420 // <!ENTITY % CIMName "CLASSNAME CDATA #REQUIRED">
421 //
422 //------------------------------------------------------------------------------
423
424 String XmlReader::getClassNameAttribute(
|
425 kumpf 1.122 Uint32 lineNumber,
|
426 mike 1.23 const XmlEntry& entry,
427 const char* elementName)
428 {
429 String name;
430
431 if (!entry.getAttributeValue("CLASSNAME", name))
432 {
|
433 kumpf 1.122 char buffer[MESSAGE_SIZE];
434 sprintf(buffer, "%s.CLASSNAME", elementName);
|
435 humberto 1.85
|
436 kumpf 1.122 MessageLoaderParms mlParms(
437 "Common.XmlReader.MISSING_ATTRIBUTE",
438 "missing $0 attribute",
439 buffer);
|
440 humberto 1.85
|
441 kumpf 1.122 throw XmlValidationError(lineNumber, mlParms);
|
442 mike 1.23 }
443
444 if (!CIMName::legal(name))
445 {
|
446 kumpf 1.122 char buffer[MESSAGE_SIZE];
447 sprintf(buffer, "%s.CLASSNAME", elementName);
|
448 humberto 1.85
|
449 kumpf 1.122 MessageLoaderParms mlParms(
450 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
451 "Illegal value for $0 attribute",
452 buffer);
453 throw XmlSemanticError(lineNumber, mlParms);
|
454 mike 1.23 }
455
456 return name;
457 }
458
459 //------------------------------------------------------------------------------
460 //
461 // getClassOriginAttribute()
462 //
463 // <!ENTITY % ClassOrigin "CLASSORIGIN CDATA #IMPLIED">
464 //
465 //------------------------------------------------------------------------------
466
|
467 kumpf 1.62 CIMName XmlReader::getClassOriginAttribute(
|
468 kumpf 1.122 Uint32 lineNumber,
|
469 mike 1.23 const XmlEntry& entry,
470 const char* tagName)
471 {
472 String name;
473
474 if (!entry.getAttributeValue("CLASSORIGIN", name))
|
475 kumpf 1.122 return CIMName();
|
476 mike 1.23
|
477 marek 1.140 /* Interoperability hack to make the C++ client of OpenPegasus able
478 to deal with the wbemservices CIMOM delivered with Sun Solaris.
479 The issue is that the wbemservices delivers Xml responses with
480 CLASSORIGIN=""
481 Originally this had been reported with Bug#537.
482 */
483 if (name.size()==0)
484 {
485 return CIMName();
486 }
487
|
488 mike 1.23 if (!CIMName::legal(name))
489 {
|
490 kumpf 1.122 char buffer[MESSAGE_SIZE];
491 sprintf(buffer, "%s.CLASSORIGIN", tagName);
|
492 humberto 1.85
|
493 kumpf 1.122 MessageLoaderParms mlParms(
494 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
495 "Illegal value for $0 attribute",
496 buffer);
497 throw XmlSemanticError(lineNumber, mlParms);
|
498 mike 1.23 }
|
499 kumpf 1.139 // The CIMName was already checked with legal() + String()
|
500 mike 1.133 return CIMNameCast(name);
|
501 mike 1.23 }
502
503 //------------------------------------------------------------------------------
504 //
|
505 dave.sudlik 1.109 // getEmbeddedObjectAttribute()
506 //
|
507 karl 1.129 // <!ENTITY % EmbeddedObject "EmbeddedObject (object | instance) #IMPLIED">
|
508 dave.sudlik 1.109 //
|
509 thilo.boehm 1.131 // EmbeddedObjectAttributeType:
510 // NO_EMBEDDED_OBJECT = 0,
511 // EMBEDDED_OBJECT_ATTR = 1,
512 // EMBEDDED_INSTANCE_ATTR = 2
513 //
|
514 dave.sudlik 1.109 //------------------------------------------------------------------------------
515
|
516 thilo.boehm 1.131 XmlReader::EmbeddedObjectAttributeType XmlReader::getEmbeddedObjectAttribute(
|
517 kumpf 1.122 Uint32 lineNumber,
|
518 dave.sudlik 1.109 const XmlEntry& entry,
|
519 thilo.boehm 1.131 const char* tagName)
|
520 dave.sudlik 1.109 {
|
521 thilo.boehm 1.131 const char* embeddedObject;
|
522 dave.sudlik 1.109
|
523 karl 1.129 // Check for both upper case and mixed case "EmbeddedObject"
524 // because of an error in an earlier pegasus version where we
525 // used upper case in the generation of the attribute name
526 // whereas the DMTF spec calls for mixed case.
527 if (!entry.getAttributeValue("EmbeddedObject", embeddedObject) &&
528 !entry.getAttributeValue("EMBEDDEDOBJECT", embeddedObject))
|
529 thilo.boehm 1.131 return NO_EMBEDDED_OBJECT;
|
530 dave.sudlik 1.109
531 // The embeddedObject attribute, if present, must have the string
532 // value "object" or "instance".
|
533 thilo.boehm 1.131 if (strcmp(embeddedObject, "object") == 0)
|
534 kumpf 1.122 {
|
535 thilo.boehm 1.131 return EMBEDDED_OBJECT_ATTR;
536 }
|
537 kumpf 1.139
|
538 thilo.boehm 1.131 if (strcmp(embeddedObject, "instance") == 0)
539 {
540 return EMBEDDED_INSTANCE_ATTR;
541 }
|
542 kumpf 1.122
|
543 thilo.boehm 1.131 char buffer[MESSAGE_SIZE];
544 sprintf(buffer, "%s.EmbeddedObject", tagName);
|
545 dave.sudlik 1.109
|
546 thilo.boehm 1.131 MessageLoaderParms mlParms(
547 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
548 "Illegal value for $0 attribute",
549 buffer);
550 throw XmlSemanticError(lineNumber, mlParms);
|
551 kumpf 1.139
|
552 thilo.boehm 1.131 return NO_EMBEDDED_OBJECT;
|
553 dave.sudlik 1.109 }
554
555 //------------------------------------------------------------------------------
556 //
|
557 mike 1.23 // getReferenceClassAttribute()
558 //
559 // <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">
560 //
561 //------------------------------------------------------------------------------
562
|
563 kumpf 1.62 CIMName XmlReader::getReferenceClassAttribute(
|
564 kumpf 1.122 Uint32 lineNumber,
|
565 mike 1.23 const XmlEntry& entry,
566 const char* elementName)
567 {
568 String name;
569
570 if (!entry.getAttributeValue("REFERENCECLASS", name))
|
571 kumpf 1.122 return CIMName();
|
572 mike 1.23
573 if (!CIMName::legal(name))
574 {
|
575 kumpf 1.122 char buffer[MESSAGE_SIZE];
576 sprintf(buffer, "%s.REFERENCECLASS", elementName);
|
577 humberto 1.85
|
578 kumpf 1.122 MessageLoaderParms mlParms(
579 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
580 "Illegal value for $0 attribute",
581 buffer);
582 throw XmlSemanticError(lineNumber, mlParms);
|
583 mike 1.23 }
|
584 kumpf 1.139 // The CIMName was already checked with legal() + String()
|
585 mike 1.133 return CIMNameCast(name);
|
586 mike 1.23 }
587
588 //------------------------------------------------------------------------------
589 //
590 // getSuperClassAttribute()
591 //
592 // <!ENTITY % SuperClass "SUPERCLASS CDATA #IMPLIED">
593 //
594 //------------------------------------------------------------------------------
595
|
596 kumpf 1.62 CIMName XmlReader::getSuperClassAttribute(
|
597 kumpf 1.122 Uint32 lineNumber,
|
598 mike 1.23 const XmlEntry& entry,
599 const char* tagName)
600 {
601 String superClass;
602
603 if (!entry.getAttributeValue("SUPERCLASS", superClass))
|
604 kumpf 1.122 return CIMName();
|
605 mike 1.23
606 if (!CIMName::legal(superClass))
607 {
|
608 kumpf 1.122 char buffer[MESSAGE_SIZE];
609 sprintf(buffer, "%s.SUPERCLASS", tagName);
|
610 humberto 1.85
|
611 kumpf 1.122 MessageLoaderParms mlParms(
612 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
613 "Illegal value for $0 attribute",
614 buffer);
615 throw XmlSemanticError(lineNumber, mlParms);
|
616 mike 1.23 }
|
617 kumpf 1.139 // The CIMName was already checked with legal() + String()
|
618 mike 1.133 return CIMNameCast(superClass);
|
619 mike 1.23 }
620
621 //------------------------------------------------------------------------------
622 //
623 // getCimTypeAttribute()
624 //
|
625 kumpf 1.26 // This method can be used to get a TYPE attribute or a PARAMTYPE attribute.
626 // The only significant difference is that PARAMTYPE may specify a value of
627 // "reference" type. This method recognizes these attributes by name, and
628 // does not allow a "TYPE" attribute to be of "reference" type.
629 //
|
630 mike 1.23 // <!ENTITY % CIMType "TYPE (boolean|string|char16|uint8|sint8|uint16
631 // |sint16|uint32|sint32|uint64|sint64|datetime|real32|real64)">
632 //
|
633 kumpf 1.26 // <!ENTITY % ParamType "PARAMTYPE (boolean|string|char16|uint8|sint8
634 // |uint16|sint16|uint32|sint32|uint64|sint64|datetime|real32|real64
635 // |reference)">
636 //
|
637 mike 1.23 //------------------------------------------------------------------------------
638
|
639 kumpf 1.67 Boolean XmlReader::getCimTypeAttribute(
|
640 kumpf 1.122 Uint32 lineNumber,
641 const XmlEntry& entry,
|
642 kumpf 1.67 CIMType& cimType, // Output parameter
|
643 kumpf 1.26 const char* tagName,
644 const char* attributeName,
645 Boolean required)
|
646 mike 1.23 {
647 const char* typeName;
648
|
649 kumpf 1.26 if (!entry.getAttributeValue(attributeName, typeName))
|
650 mike 1.23 {
|
651 kumpf 1.26 if (required)
|
652 kumpf 1.122 {
653 char message[MESSAGE_SIZE];
654 sprintf(message, "%s.%s", tagName, attributeName);
|
655 humberto 1.85
|
656 kumpf 1.122 MessageLoaderParms mlParms(
657 "Common.XmlReader.MISSING_ATTRIBUTE",
658 "missing $0 attribute",
659 message);
660 throw XmlValidationError(lineNumber, mlParms);
661 }
662 else
663 {
664 return false;
665 }
|
666 mike 1.23 }
667
|
668 kumpf 1.67 CIMType type = CIMTYPE_BOOLEAN;
669 Boolean unrecognizedType = false;
|
670 mike 1.23
671 if (strcmp(typeName, "boolean") == 0)
|
672 kumpf 1.122 type = CIMTYPE_BOOLEAN;
|
673 mike 1.23 else if (strcmp(typeName, "string") == 0)
|
674 kumpf 1.122 type = CIMTYPE_STRING;
|
675 mike 1.23 else if (strcmp(typeName, "char16") == 0)
|
676 kumpf 1.122 type = CIMTYPE_CHAR16;
|
677 mike 1.23 else if (strcmp(typeName, "uint8") == 0)
|
678 kumpf 1.122 type = CIMTYPE_UINT8;
|
679 mike 1.23 else if (strcmp(typeName, "sint8") == 0)
|
680 kumpf 1.122 type = CIMTYPE_SINT8;
|
681 mike 1.23 else if (strcmp(typeName, "uint16") == 0)
|
682 kumpf 1.122 type = CIMTYPE_UINT16;
|
683 mike 1.23 else if (strcmp(typeName, "sint16") == 0)
|
684 kumpf 1.122 type = CIMTYPE_SINT16;
|
685 mike 1.23 else if (strcmp(typeName, "uint32") == 0)
|
686 kumpf 1.122 type = CIMTYPE_UINT32;
|
687 mike 1.23 else if (strcmp(typeName, "sint32") == 0)
|
688 kumpf 1.122 type = CIMTYPE_SINT32;
|
689 mike 1.23 else if (strcmp(typeName, "uint64") == 0)
|
690 kumpf 1.122 type = CIMTYPE_UINT64;
|
691 mike 1.23 else if (strcmp(typeName, "sint64") == 0)
|
692 kumpf 1.122 type = CIMTYPE_SINT64;
|
693 mike 1.23 else if (strcmp(typeName, "datetime") == 0)
|
694 kumpf 1.122 type = CIMTYPE_DATETIME;
|
695 mike 1.23 else if (strcmp(typeName, "real32") == 0)
|
696 kumpf 1.122 type = CIMTYPE_REAL32;
|
697 mike 1.23 else if (strcmp(typeName, "real64") == 0)
|
698 kumpf 1.122 type = CIMTYPE_REAL64;
|
699 kumpf 1.26 else if (strcmp(typeName, "reference") == 0)
|
700 kumpf 1.122 type = CIMTYPE_REFERENCE;
|
701 dave.sudlik 1.109 // PEP 194:
702 // Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a
|
703 kumpf 1.122 // Pegasus internal representation of an embedded object, so it won't be
704 // found here.
|
705 kumpf 1.67 else unrecognizedType = true;
|
706 mike 1.23
|
707 kumpf 1.67 if (unrecognizedType ||
|
708 kumpf 1.61 ((type == CIMTYPE_REFERENCE) &&
|
709 kumpf 1.26 (strcmp(attributeName, "PARAMTYPE") != 0)))
|
710 mike 1.23 {
|
711 kumpf 1.122 char buffer[MESSAGE_SIZE];
712 sprintf(buffer, "%s.%s", tagName, attributeName);
|
713 humberto 1.85
|
714 kumpf 1.122 MessageLoaderParms mlParms(
715 "Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
716 "Illegal value for $0 attribute",
717 buffer);
718
719 throw XmlSemanticError(lineNumber, mlParms);
|
720 mike 1.23 }
721
|
722 kumpf 1.67 cimType = type;
723 return true;
|
724 mike 1.23 }
725
726 //------------------------------------------------------------------------------
727 //
728 // getCimBooleanAttribute()
729 //
730 //------------------------------------------------------------------------------
731
732 Boolean XmlReader::getCimBooleanAttribute(
733 Uint32 lineNumber,
734 const XmlEntry& entry,
735 const char* tagName,
736 const char* attributeName,
737 Boolean defaultValue,
738 Boolean required)
739 {
740 const char* tmp;
741
742 if (!entry.getAttributeValue(attributeName, tmp))
743 {
|
744 kumpf 1.122 if (!required)
745 return defaultValue;
|
746 humberto 1.85
|
747 kumpf 1.126 char buffer[MESSAGE_SIZE];
|
748 kumpf 1.122 sprintf(buffer, "%s.%s", attributeName, tagName);
|
749 mike 1.23
|
750 kumpf 1.122 MessageLoaderParms mlParms(
751 "Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",
752 "missing required $0 attribute",
753 buffer);
754 throw XmlValidationError(lineNumber, mlParms);
|
755 mike 1.23 }
756
757 if (strcmp(tmp, "true") == 0)
|
758 kumpf 1.122 return true;
|
759 mike 1.23 else if (strcmp(tmp, "false") == 0)
|
760 kumpf 1.122 return false;
|
761 humberto 1.85
|
762 kumpf 1.126 char buffer[MESSAGE_SIZE];
|
763 humberto 1.85 sprintf(buffer, "%s.%s", attributeName, tagName);
764
|
765 kumpf 1.122 MessageLoaderParms mlParms(
766 "Common.XmlReader.INVALID_ATTRIBUTE",
767 "Invalid $0 attribute value",
768 buffer);
|
769 humberto 1.85
770 throw XmlSemanticError(lineNumber, mlParms);
771
|
772 mike 1.23 return false;
773 }
774
|
775 kumpf 1.82 // See http://www.ietf.org/rfc/rfc2396.txt section 2
|
776 chuck 1.88 //
777 // Also see the "CIM Operations over HTTP" spec, section 3.3.2 and
778 // 3.3.3, for the treatment of non US-ASCII chars (UTF-8)
|
779 kumpf 1.82 String XmlReader::decodeURICharacters(String uriString)
780 {
781 Uint32 i;
782
|
783 kumpf 1.138 Buffer utf8Chars;
|
784 chuck 1.88
|
785 kumpf 1.82 for (i=0; i<uriString.size(); i++)
786 {
787 if (uriString[i] == '%')
788 {
789 if (i+2 >= uriString.size())
790 {
|
791 kumpf 1.122 MessageLoaderParms mlParms(
792 "Common.XmlReader.INVALID_URI_ENCODING",
793 "Invalid URI encoding");
794 throw ParseError(MessageLoader::getMessage(mlParms));
|
795 kumpf 1.82 }
796
|
797 kumpf 1.126 Uint8 digit1 =
798 StringConversion::hexCharToNumeric(char(uriString[++i]));
799 Uint8 digit2 =
800 StringConversion::hexCharToNumeric(char(uriString[++i]));
|
801 kumpf 1.82 if ( (digit1 > 15) || (digit2 > 15) )
802 {
|
803 kumpf 1.122 MessageLoaderParms mlParms(
804 "Common.XmlReader.INVALID_URI_ENCODING",
805 "Invalid URI encoding");
806 throw ParseError(MessageLoader::getMessage(mlParms));
|
807 kumpf 1.82 }
808
809 Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);
|
810 kumpf 1.138 utf8Chars.append((char)decodedChar);
|
811 kumpf 1.82 }
812 else
813 {
|
814 kumpf 1.138 utf8Chars.append((char)uriString[i]);
|
815 kumpf 1.82 }
816 }
817
|
818 chuck 1.88 // If there was a string to decode...
819 if (uriString.size() > 0)
820 {
821 // Convert UTF-8 to UTF-16 and return the String
|
822 kumpf 1.138 return String(utf8Chars.getData(), utf8Chars.size());
|
823 chuck 1.88 }
824 else
825 {
826 return String();
827 }
|
828 kumpf 1.41 }
829
|
830 mike 1.23 //------------------------------------------------------------------------------
831 //
832 // stringToValue()
833 //
|
834 karl 1.35 // Return: CIMValue. If the string input is zero length creates a CIMValue
835 // with value defined by the type. Else the value is inserted.
|
836 kumpf 1.122 //
|
837 karl 1.35 // Note that this does not set the CIMValue Null if the string is empty.
838 //
|
839 mike 1.23 //------------------------------------------------------------------------------
840
841 CIMValue XmlReader::stringToValue(
|
842 kumpf 1.122 Uint32 lineNumber,
843 const char* valueString,
|
844 mike 1.23 CIMType type)
845 {
|
846 venkat.puvvada 1.141 return stringToValue(lineNumber, valueString, strlen(valueString), type);
847 }
848
849 CIMValue XmlReader::stringToValue(
850 Uint32 lineNumber,
851 const char* valueString,
852 Uint32 valueStringLen,
853 CIMType type)
854 {
|
855 mike 1.23 // ATTN-B: accepting only UTF-8 for now! (affects string and char16):
856
|
857 venkat.puvvada 1.141 // Char string must have been null terminated.
858 PEGASUS_ASSERT (!valueString[valueStringLen]);
859
|
860 karl 1.35 // Create value per type
|
861 mike 1.23 switch (type)
862 {
|
863 kumpf 1.122 case CIMTYPE_BOOLEAN:
864 {
865 if (System::strcasecmp(valueString, "TRUE") == 0)
866 return CIMValue(true);
867 else if (System::strcasecmp(valueString, "FALSE") == 0)
868 return CIMValue(false);
869 else
870 {
871 MessageLoaderParms mlParms(
872 "Common.XmlReader.INVALID_BOOLEAN_VALUE",
873 "Invalid boolean value");
874 throw XmlSemanticError(lineNumber, mlParms);
875 }
876 }
|
877 mike 1.23
|
878 kumpf 1.122 case CIMTYPE_STRING:
879 {
|
880 venkat.puvvada 1.141 return CIMValue(String(valueString, valueStringLen));
|
881 kumpf 1.122 }
882
883 case CIMTYPE_CHAR16:
884 {
885 // Converts UTF-8 to UTF-16
|
886 venkat.puvvada 1.141 String tmp(valueString, valueStringLen);
|
887 kumpf 1.122 if (tmp.size() != 1)
888 {
889 MessageLoaderParms mlParms(
890 "Common.XmlReader.INVALID_CHAR16_VALUE",
891 "Invalid char16 value");
892 throw XmlSemanticError(lineNumber, mlParms);
893 }
894
895 return CIMValue(tmp[0]);
896 }
897
898 case CIMTYPE_UINT8:
899 case CIMTYPE_UINT16:
900 case CIMTYPE_UINT32:
901 case CIMTYPE_UINT64:
902 {
903 Uint64 x;
904
|
905 thilo.boehm 1.144 if (!StringConversion::stringToUnsignedInteger(valueString, x))
|
906 kumpf 1.122 {
907 MessageLoaderParms mlParms(
908 "Common.XmlReader.INVALID_UI_VALUE",
909 "Invalid unsigned integer value");
910 throw XmlSemanticError(lineNumber, mlParms);
911 }
|
912 humberto 1.85
|
913 kumpf 1.122 switch (type)
914 {
915 case CIMTYPE_UINT8:
|
916 kumpf 1.37 {
|
917 kumpf 1.126 if (!StringConversion::checkUintBounds(x, type))
|
918 kumpf 1.122 {
919 MessageLoaderParms mlParms(
920 "Common.XmlReader.U8_VALUE_OUT_OF_RANGE",
921 "Uint8 value out of range");
922 throw XmlSemanticError(lineNumber, mlParms);
923 }
924 return CIMValue(Uint8(x));
|
925 kumpf 1.37 }
|
926 kumpf 1.122 case CIMTYPE_UINT16:
|
927 kumpf 1.37 {
|
928 kumpf 1.126 if (!StringConversion::checkUintBounds(x, type))
|
929 kumpf 1.122 {
930 MessageLoaderParms mlParms(
931 "Common.XmlReader.U16_VALUE_OUT_OF_RANGE",
932 "Uint16 value out of range");
933 throw XmlSemanticError(lineNumber, mlParms);
934 }
935 return CIMValue(Uint16(x));
|
936 kumpf 1.37 }
|
937 kumpf 1.122 case CIMTYPE_UINT32:
|
938 kumpf 1.37 {
|
939 kumpf 1.126 if (!StringConversion::checkUintBounds(x, type))
|
940 kumpf 1.122 {
941 MessageLoaderParms mlParms(
942 "Common.XmlReader.U32_VALUE_OUT_OF_RANGE",
943 "Uint32 value out of range");
944 throw XmlSemanticError(lineNumber, mlParms);
945 }
946 return CIMValue(Uint32(x));
947 }
948 case CIMTYPE_UINT64: return CIMValue(Uint64(x));
949 default: break;
950 }
951 }
|
952 humberto 1.85
|
953 kumpf 1.122 case CIMTYPE_SINT8:
954 case CIMTYPE_SINT16:
955 case CIMTYPE_SINT32:
956 case CIMTYPE_SINT64:
957 {
958 Sint64 x;
|
959 humberto 1.85
|
960 thilo.boehm 1.144 if (!StringConversion::stringToSignedInteger(valueString, x))
|
961 kumpf 1.122 {
962 MessageLoaderParms mlParms(
963 "Common.XmlReader.INVALID_SI_VALUE",
964 "Invalid signed integer value");
965 throw XmlSemanticError(lineNumber, mlParms);
966 }
|
967 humberto 1.85
|
968 kumpf 1.122 switch (type)
969 {
970 case CIMTYPE_SINT8:
971 {
|
972 kumpf 1.126 if (!StringConversion::checkSintBounds(x, type))
|
973 kumpf 1.122 {
974 MessageLoaderParms mlParms(
975 "Common.XmlReader.S8_VALUE_OUT_OF_RANGE",
976 "Sint8 value out of range");
977 throw XmlSemanticError(lineNumber, mlParms);
978 }
979 return CIMValue(Sint8(x));
|
980 kumpf 1.37 }
|
981 kumpf 1.122 case CIMTYPE_SINT16:
|
982 kumpf 1.37 {
|
983 kumpf 1.126 if (!StringConversion::checkSintBounds(x, type))
|
984 kumpf 1.122 {
985 MessageLoaderParms mlParms(
986 "Common.XmlReader.S16_VALUE_OUT_OF_RANGE",
987 "Sint16 value out of range");
988 throw XmlSemanticError(lineNumber, mlParms);
989 }
990 return CIMValue(Sint16(x));
|
991 kumpf 1.37 }
|
992 kumpf 1.122 case CIMTYPE_SINT32:
|
993 kumpf 1.37 {
|
994 kumpf 1.126 if (!StringConversion::checkSintBounds(x, type))
|
995 kumpf 1.122 {
996 MessageLoaderParms mlParms(
997 "Common.XmlReader.S32_VALUE_OUT_OF_RANGE",
998 "Sint32 value out of range");
999 throw XmlSemanticError(lineNumber, mlParms);
1000 }
1001 return CIMValue(Sint32(x));
|
1002 kumpf 1.37 }
|
1003 kumpf 1.122 case CIMTYPE_SINT64: return CIMValue(Sint64(x));
1004 default: break;
1005 }
1006 }
|
1007 humberto 1.85
|
1008 kumpf 1.122 case CIMTYPE_DATETIME:
1009 {
1010 CIMDateTime tmp;
|
1011 humberto 1.85
|
1012 kumpf 1.122 try
1013 {
|
1014 venkat.puvvada 1.141 if (valueStringLen != 0)
|
1015 marek 1.145 {
|
1016 kumpf 1.122 tmp.set(valueString);
|
1017 marek 1.145 }
|
1018 kumpf 1.122 }
1019 catch (InvalidDateTimeFormatException&)
1020 {
1021 MessageLoaderParms mlParms(
1022 "Common.XmlReader.INVALID_DATETIME_VALUE",
1023 "Invalid datetime value");
1024 throw XmlSemanticError(lineNumber, mlParms);
1025 }
|
1026 humberto 1.85
|
1027 kumpf 1.122 return CIMValue(tmp);
1028 }
|
1029 humberto 1.85
|
1030 kumpf 1.122 case CIMTYPE_REAL32:
1031 {
1032 Real64 x;
|
1033 humberto 1.85
|
1034 kumpf 1.126 if (!StringConversion::stringToReal64(valueString, x))
|
1035 kumpf 1.122 {
1036 MessageLoaderParms mlParms(
1037 "Common.XmlReader.INVALID_RN_VALUE",
1038 "Invalid real number value");
1039 throw XmlSemanticError(lineNumber, mlParms);
1040 }
1041 return CIMValue(Real32(x));
1042 }
|
1043 mike 1.23
|
1044 kumpf 1.122 case CIMTYPE_REAL64:
1045 {
1046 Real64 x;
|
1047 mike 1.23
|
1048 kumpf 1.126 if (!StringConversion::stringToReal64(valueString, x))
|
1049 kumpf 1.122 {
1050 MessageLoaderParms mlParms(
1051 "Common.XmlReader.INVALID_RN_VALUE",
1052 "Invalid real number value");
1053 throw XmlSemanticError(lineNumber, mlParms);
1054 }
1055 return CIMValue(x);
1056 }
|
1057 mike 1.23
|
1058 dave.sudlik 1.109 // PEP 194:
|
1059 kumpf 1.122 // Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but
1060 // just a Pegasus internal representation of an embedded object. However,
1061 // this case is used when decoding string representations of embedded objects.
1062 case CIMTYPE_OBJECT:
1063 case CIMTYPE_INSTANCE:
|
1064 dave.sudlik 1.109 {
|
1065 kumpf 1.122 CIMObject x;
|
1066 dave.sudlik 1.109
|
1067 kumpf 1.122 if (*valueString == '\0')
|
1068 dave.sudlik 1.109 {
|
1069 kumpf 1.122 return CIMValue(type, false, 0);
|
1070 dave.sudlik 1.109 }
1071 else
1072 {
|
1073 kumpf 1.122 // Convert the non-NULL string to a CIMObject (containing
1074 // either a CIMInstance or a CIMClass).
|
1075 dave.sudlik 1.109
|
1076 kumpf 1.122 // First we need to create a new "temporary" XmlParser that is
1077 // just the value of the Embedded Object in String
1078 // representation.
1079 AutoArrayPtr<char> tmp_buffer(
|
1080 venkat.puvvada 1.141 new char[valueStringLen + 1]);
1081 memcpy(tmp_buffer.get(), valueString, valueStringLen + 1);
|
1082 kumpf 1.122 XmlParser tmp_parser(tmp_buffer.get());
1083
1084 // The next bit of logic constructs a CIMObject from the
1085 // Embedded Object String. It is similar to the method
1086 // XmlReader::getValueObjectElement().
1087 CIMInstance cimInstance;
1088 CIMClass cimClass;
1089
1090 if (XmlReader::getInstanceElement(tmp_parser, cimInstance))
1091 {
1092 if (type == CIMTYPE_INSTANCE)
1093 return CIMValue(cimInstance);
1094 x = CIMObject(cimInstance);
1095 }
1096 else if (XmlReader::getClassElement(tmp_parser, cimClass))
|
1097 a.dunfey 1.118 {
|
1098 kumpf 1.122 x = CIMObject(cimClass);
|
1099 a.dunfey 1.118 }
1100 else
1101 {
|
1102 kumpf 1.122 if (type == CIMTYPE_OBJECT)
1103 {
1104 // change "element" to "embedded object"
1105 MessageLoaderParms mlParms(
1106 "Common.XmlReader."
1107 "EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
1108 "Expected INSTANCE or CLASS element");
1109 throw XmlValidationError(lineNumber, mlParms);
1110 }
1111 else
1112 {
1113 // change "element" to "embedded object"
1114 MessageLoaderParms mlParms(
1115 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
1116 "Expected INSTANCE element");
1117 throw XmlValidationError(lineNumber, mlParms);
1118 }
|
1119 a.dunfey 1.118 }
|
1120 kumpf 1.122 // Ok, now we can delete the storage for the temporary
1121 // XmlParser.
1122 tmp_buffer.reset();
|
1123 dave.sudlik 1.109 }
|
1124 kumpf 1.122 return CIMValue(x);
|
1125 dave.sudlik 1.109 }
1126
|
1127 kumpf 1.122 default:
1128 break;
|
1129 mike 1.23 }
1130
|
1131 kumpf 1.122 MessageLoaderParms mlParms(
1132 "Common.XmlReader.MALFORMED_XML",
1133 "malformed XML");
|
1134 humberto 1.85 throw XmlSemanticError(lineNumber, mlParms);
1135
|
1136 mike 1.23 return false;
1137 }
1138
1139 //------------------------------------------------------------------------------
1140 //
|
1141 kumpf 1.95 // skipElement()
1142 //
1143 //------------------------------------------------------------------------------
1144 void XmlReader::skipElement(
1145 XmlParser& parser,
1146 XmlEntry& entry)
1147 {
1148 const char * tag_name = entry.text;
1149
1150 if (entry.type == XmlEntry::EMPTY_TAG)
1151 {
|
1152 kumpf 1.122 return;
|
1153 kumpf 1.95 }
1154
1155 while (testStartTagOrEmptyTag(parser, entry))
1156 {
|
1157 kumpf 1.122 skipElement(parser, entry);
|
1158 kumpf 1.95 }
1159
1160 if (testContentOrCData(parser, entry))
1161 {
1162 ; // skip
1163 }
1164
1165 expectEndTag(parser, tag_name);
1166 return;
1167 }
1168
1169 //------------------------------------------------------------------------------
1170 //
|
1171 mike 1.23 // getValueElement()
1172 //
1173 // <!ELEMENT VALUE (#PCDATA)>
1174 //
|
1175 karl 1.35 // Return: false if no value element.
1176 //
|
1177 mike 1.23 //------------------------------------------------------------------------------
1178
1179 Boolean XmlReader::getValueElement(
|
1180 kumpf 1.122 XmlParser& parser,
1181 CIMType type,
|
1182 mike 1.23 CIMValue& value)
1183 {
|
1184 karl 1.35 // Get VALUE start tag: Return false if no VALUE start Tag
|
1185 mike 1.23
1186 XmlEntry entry;
1187 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
|
1188 dave.sudlik 1.111 {
|
1189 kumpf 1.122 return false;
|
1190 dave.sudlik 1.111 }
|
1191 mike 1.23
1192 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1193
|
1194 dave.sudlik 1.111 const char* valueString = "";
|
1195 venkat.puvvada 1.141 Uint32 valueStringLen = 0;
|
1196 dave.sudlik 1.111 if (!empty)
|
1197 mike 1.23 {
|
1198 dave.sudlik 1.111 if (testContentOrCData(parser, entry))
|
1199 dave.sudlik 1.109 {
1200 valueString = entry.text;
|
1201 venkat.puvvada 1.141 valueStringLen = entry.textLen;
|
1202 dave.sudlik 1.111 }
|
1203 mike 1.23
|
1204 dave.sudlik 1.109 expectEndTag(parser, "VALUE");
|
1205 mike 1.23 }
|
1206 marek 1.145 value = stringToValue(parser.getLine(),valueString,valueStringLen,type);
|
1207 kumpf 1.122
|
1208 mike 1.23 return true;
1209 }
1210
1211 //------------------------------------------------------------------------------
1212 //
1213 // getStringValueElement()
1214 //
1215 // <!ELEMENT VALUE (#PCDATA)>
1216 //
1217 //------------------------------------------------------------------------------
1218
1219 Boolean XmlReader::getStringValueElement(
|
1220 kumpf 1.122 XmlParser& parser,
|
1221 mike 1.23 String& str,
1222 Boolean required)
1223 {
1224 XmlEntry entry;
1225
1226 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
1227 {
|
1228 kumpf 1.122 if (required)
1229 {
1230 MessageLoaderParms mlParms(
1231 "Common.XmlReader.EXPECTED_VALUE_ELEMENT",
1232 "Expected VALUE element");
1233 throw XmlValidationError(parser.getLine(), mlParms);
1234 }
1235 return false;
|
1236 mike 1.23 }
1237
1238 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1239
1240 const char* valueString = "";
|
1241 venkat.puvvada 1.141 Uint32 valueStringLen = 0;
|
1242 mike 1.23
1243 if (!empty)
1244 {
|
1245 kumpf 1.122 if (testContentOrCData(parser, entry))
|
1246 venkat.puvvada 1.141 {
|
1247 kumpf 1.122 valueString = entry.text;
|
1248 venkat.puvvada 1.141 valueStringLen = entry.textLen;
1249 }
|
1250 mike 1.23
|
1251 kumpf 1.122 expectEndTag(parser, "VALUE");
|
1252 mike 1.23 }
1253
|
1254 venkat.puvvada 1.141 str = String(valueString, valueStringLen);
|
1255 mike 1.23 return true;
1256 }
1257
1258 //----------------------------------------------------------------------------
1259 //
1260 // getPropertyValue
|
1261 kumpf 1.30 // Use: Decode property value from SetProperty request and
1262 // GetProperty response.
|
1263 mike 1.23 //
|
1264 kumpf 1.30 // PropertyValue is one of:
|
1265 mike 1.23 //
1266 //
|
1267 kumpf 1.122 // <!ELEMENT VALUE.ARRAY (VALUE*)>
|
1268 karl 1.33 //
|
1269 kumpf 1.122 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
|
1270 kumpf 1.30 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1271 //
1272 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
|
1273 mike 1.23 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
1274 //
|
1275 kumpf 1.30 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
1276 //
|
1277 mike 1.23 //----------------------------------------------------------------------------
1278 Boolean XmlReader::getPropertyValue(
|
1279 kumpf 1.122 XmlParser& parser,
|
1280 mike 1.23 CIMValue& cimValue)
1281 {
|
1282 kumpf 1.30 // Can not test for value type, so assume String
|
1283 kumpf 1.61 const CIMType type = CIMTYPE_STRING;
|
1284 mike 1.23
|
1285 kumpf 1.30 // Test for VALUE element
|
1286 mike 1.23 if (XmlReader::getValueElement(parser, type, cimValue))
1287 {
|
1288 kumpf 1.122 return true;
|
1289 mike 1.23 }
1290
|
1291 kumpf 1.30 // Test for VALUE.ARRAY element
1292 if (XmlReader::getValueArrayElement(parser, type, cimValue))
1293 {
|
1294 mike 1.23 return true;
|
1295 kumpf 1.30 }
|
1296 mike 1.23
|
1297 kumpf 1.30 // Test for VALUE.REFERENCE element
|
1298 kumpf 1.54 CIMObjectPath reference;
|
1299 kumpf 1.30 if (XmlReader::getValueReferenceElement(parser, reference))
|
1300 mike 1.25 {
1301 cimValue.set(reference);
1302 return true;
1303 }
|
1304 mike 1.23
|
1305 kumpf 1.30 // Test for VALUE.REFARRAY element
1306 if (XmlReader::getValueReferenceArrayElement(parser, cimValue))
1307 {
1308 return true;
1309 }
1310
1311 return false;
|
1312 mike 1.23 }
1313
1314 //------------------------------------------------------------------------------
1315 //
1316 // stringArrayToValue()
1317 //
1318 //------------------------------------------------------------------------------
1319
1320 template<class T>
1321 CIMValue StringArrayToValueAux(
|
1322 kumpf 1.122 Uint32 lineNumber,
|
1323 venkat.puvvada 1.141 const Array<CharString>& stringArray,
|
1324 mike 1.23 CIMType type,
1325 T*)
1326 {
1327 Array<T> array;
1328
1329 for (Uint32 i = 0, n = stringArray.size(); i < n; i++)
1330 {
|
1331 kumpf 1.122 CIMValue value = XmlReader::stringToValue(
|
1332 thilo.boehm 1.144 lineNumber,
|
1333 venkat.puvvada 1.141 stringArray[i].value,
1334 stringArray[i].length,
1335 type);
|
1336 mike 1.23
|
1337 kumpf 1.122 T x;
1338 value.get(x);
1339 array.append(x);
|
1340 mike 1.23 }
1341
1342 return CIMValue(array);
1343 }
1344
1345 CIMValue XmlReader::stringArrayToValue(
|
1346 kumpf 1.122 Uint32 lineNumber,
|
1347 venkat.puvvada 1.141 const Array<const char*> &array,
1348 CIMType type)
1349 {
1350 Array<CharString> strArray;
1351
1352 for (Uint32 i = 0, n = array.size() ; i < n ; ++i)
1353 {
1354 strArray.append(CharString(array[i], strlen(array[i])));
1355 }
1356
1357 return _stringArrayToValue(lineNumber, strArray, type);
1358 }
1359
1360 CIMValue XmlReader::_stringArrayToValue(
1361 Uint32 lineNumber,
1362 const Array<CharString> &array,
|
1363 mike 1.23 CIMType type)
1364 {
1365 switch (type)
1366 {
|
1367 kumpf 1.122 case CIMTYPE_BOOLEAN:
1368 return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);
|
1369 mike 1.23
|
1370 kumpf 1.122 case CIMTYPE_STRING:
1371 return StringArrayToValueAux(lineNumber, array, type, (String*)0);
|
1372 mike 1.23
|
1373 kumpf 1.122 case CIMTYPE_CHAR16:
1374 return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);
|
1375 mike 1.23
|
1376 kumpf 1.122 case CIMTYPE_UINT8:
1377 return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);
|
1378 mike 1.23
|
1379 kumpf 1.122 case CIMTYPE_UINT16:
1380 return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);
|
1381 mike 1.23
|
1382 kumpf 1.122 case CIMTYPE_UINT32:
1383 return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);
|
1384 mike 1.23
|
1385 kumpf 1.122 case CIMTYPE_UINT64:
1386 return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);
|
1387 mike 1.23
|
1388 kumpf 1.122 case CIMTYPE_SINT8:
1389 return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);
|
1390 mike 1.23
|
1391 kumpf 1.122 case CIMTYPE_SINT16:
1392 return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);
|
1393 mike 1.23
|
1394 kumpf 1.122 case CIMTYPE_SINT32:
1395 return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);
|
1396 mike 1.23
|
1397 kumpf 1.122 case CIMTYPE_SINT64:
1398 return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);
|
1399 mike 1.23
|
1400 kumpf 1.122 case CIMTYPE_DATETIME:
1401 return StringArrayToValueAux(
1402 lineNumber, array, type, (CIMDateTime*)0);
|
1403 mike 1.23
|
1404 kumpf 1.122 case CIMTYPE_REAL32:
1405 return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);
|
1406 mike 1.23
|
1407 kumpf 1.122 case CIMTYPE_REAL64:
1408 return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);
|
1409 mike 1.23
|
1410 dave.sudlik 1.109 // PEP 194:
|
1411 kumpf 1.122 // Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but
1412 // just a Pegasus internal representation of an embedded object. However,
1413 // this case is used when decoding string representations of embedded objects.
1414 case CIMTYPE_OBJECT:
1415 return StringArrayToValueAux(
1416 lineNumber, array, type, (CIMObject*)0);
1417 case CIMTYPE_INSTANCE:
1418 return StringArrayToValueAux(
1419 lineNumber, array, type, (CIMInstance*)0);
1420 default:
1421 break;
|
1422 mike 1.23 }
1423
1424 // Unreachable:
1425 return CIMValue();
1426 }
1427
1428 //------------------------------------------------------------------------------
1429 //
1430 // getValueArrayElement()
1431 //
1432 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1433 //
|
1434 karl 1.35 // Return: Boolean. Returns false if there is no VALUE.ARRAY start element
1435 //
|
1436 mike 1.23 //------------------------------------------------------------------------------
1437
1438 Boolean XmlReader::getValueArrayElement(
|
1439 kumpf 1.122 XmlParser& parser,
1440 CIMType type,
|
1441 mike 1.23 CIMValue& value)
1442 {
|
1443 karl 1.35 // Clears any values from the Array. Assumes this is array CIMValue
|
1444 mike 1.23 value.clear();
1445
1446 // Get VALUE.ARRAY open tag:
1447
1448 XmlEntry entry;
|
1449 venkat.puvvada 1.141 Array<CharString> stringArray;
|
1450 mike 1.23
|
1451 karl 1.35 // If no VALUE.ARRAY start tag, return false
|
1452 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))
|
1453 kumpf 1.122 return false;
|
1454 karl 1.33
|
1455 kumpf 1.32 if (entry.type != XmlEntry::EMPTY_TAG)
1456 {
|
1457 dave.sudlik 1.111 // For each VALUE element:
1458
1459 while (testStartTagOrEmptyTag(parser, entry, "VALUE"))
|
1460 dave.sudlik 1.109 {
|
1461 venkat.puvvada 1.141 // ATTN: NULL values in array will have VALUE.NULL subelement
1462 // See DSP0201 Version 2.3.0, Section 5.2.3.2
|
1463 dave.sudlik 1.111 if (entry.type == XmlEntry::EMPTY_TAG)
|
1464 dave.sudlik 1.109 {
|
1465 venkat.puvvada 1.141 stringArray.append(CharString("", 0));
|
1466 dave.sudlik 1.111 continue;
1467 }
|
1468 mike 1.23
|
1469 dave.sudlik 1.111 if (testContentOrCData(parser, entry))
|
1470 venkat.puvvada 1.141 {
1471 stringArray.append(CharString(entry.text, entry.textLen));
1472 }
|
1473 dave.sudlik 1.111 else
|
1474 venkat.puvvada 1.141 {
1475 stringArray.append(CharString("", 0));
1476 }
|
1477 dave.sudlik 1.111 expectEndTag(parser, "VALUE");
|
1478 dave.sudlik 1.109 }
|
1479 mike 1.23
|
1480 kumpf 1.32 expectEndTag(parser, "VALUE.ARRAY");
|
1481 mike 1.23 }
1482
|
1483 venkat.puvvada 1.141 value = _stringArrayToValue(parser.getLine(), stringArray, type);
|
1484 mike 1.23 return true;
1485 }
1486
1487 //------------------------------------------------------------------------------
1488 //
1489 // getFlavor()
1490 //
|
1491 kumpf 1.122 // <!ENTITY % QualifierFlavor
|
1492 mike 1.23 // "OVERRIDABLE (true|false) 'true'
1493 // TOSUBCLASS (true|false) 'true'
1494 // TOINSTANCE (true|false) 'false'
1495 // TRANSLATABLE (true|false) 'false'">
1496 //
1497 //------------------------------------------------------------------------------
1498
|
1499 kumpf 1.64 CIMFlavor XmlReader::getFlavor(
|
1500 kumpf 1.122 XmlEntry& entry,
1501 Uint32 lineNumber,
|
1502 mike 1.23 const char* tagName)
1503 {
1504 // Get QUALIFIER.OVERRIDABLE
1505
1506 Boolean overridable = getCimBooleanAttribute(
|
1507 kumpf 1.122 lineNumber, entry, tagName, "OVERRIDABLE", true, false);
|
1508 mike 1.23
1509 // Get QUALIFIER.TOSUBCLASS
1510
1511 Boolean toSubClass = getCimBooleanAttribute(
|
1512 kumpf 1.122 lineNumber, entry, tagName, "TOSUBCLASS", true, false);
|
1513 mike 1.23
1514 // Get QUALIFIER.TOINSTANCE
1515
1516 Boolean toInstance = getCimBooleanAttribute(
|
1517 kumpf 1.122 lineNumber, entry, tagName, "TOINSTANCE", false, false);
|
1518 mike 1.23
1519 // Get QUALIFIER.TRANSLATABLE
1520
1521 Boolean translatable = getCimBooleanAttribute(
|
1522 kumpf 1.122 lineNumber, entry, tagName, "TRANSLATABLE", false, false);
|
1523 mike 1.23
|
1524 kumpf 1.44 // Start with CIMFlavor::NONE. Defaults are specified in the
1525 // getCimBooleanAttribute() calls above.
|
1526 kumpf 1.64 CIMFlavor flavor = CIMFlavor (CIMFlavor::NONE);
|
1527 mike 1.23
1528 if (overridable)
|
1529 kumpf 1.64 flavor.addFlavor (CIMFlavor::OVERRIDABLE);
1530 else
1531 flavor.addFlavor (CIMFlavor::DISABLEOVERRIDE);
|
1532 mike 1.23
1533 if (toSubClass)
|
1534 kumpf 1.64 flavor.addFlavor (CIMFlavor::TOSUBCLASS);
1535 else
1536 flavor.addFlavor (CIMFlavor::RESTRICTED);
|
1537 mike 1.23
1538 if (toInstance)
|
1539 kumpf 1.64 flavor.addFlavor (CIMFlavor::TOINSTANCE);
|
1540 mike 1.23
1541 if (translatable)
|
1542 kumpf 1.64 flavor.addFlavor (CIMFlavor::TRANSLATABLE);
|
1543 mike 1.23
1544 return flavor;
1545 }
1546
1547 //------------------------------------------------------------------------------
1548 //
1549 // getOptionalScope()
1550 //
1551 // DTD:
1552 // <!ELEMENT SCOPE EMPTY>
|
1553 kumpf 1.122 // <!ATTLIST SCOPE
|
1554 mike 1.23 // CLASS (true|false) 'false'
1555 // ASSOCIATION (true|false) 'false'
1556 // REFERENCE (true|false) 'false'
1557 // PROPERTY (true|false) 'false'
1558 // METHOD (true|false) 'false'
1559 // PARAMETER (true|false) 'false'
1560 // INDICATION (true|false) 'false'>
1561 //
1562 //------------------------------------------------------------------------------
1563
|
1564 kumpf 1.63 CIMScope XmlReader::getOptionalScope(XmlParser& parser)
|
1565 mike 1.23 {
1566 XmlEntry entry;
|
1567 kumpf 1.65 CIMScope scope;
|
1568 mike 1.23
1569 if (!parser.next(entry))
|
1570 kumpf 1.122 return scope; // No SCOPE element found; return the empty scope
|
1571 mike 1.23
1572 Boolean isEmptyTag = entry.type == XmlEntry::EMPTY_TAG;
1573
|
1574 kumpf 1.122 if ((!isEmptyTag &&
1575 entry.type != XmlEntry::START_TAG) ||
1576 strcmp(entry.text, "SCOPE") != 0)
1577 {
1578 // No SCOPE element found; return the empty scope
1579 parser.putBack(entry);
1580 return scope;
|
1581 mike 1.23 }
1582
1583 Uint32 line = parser.getLine();
1584
1585 if (getCimBooleanAttribute(line, entry, "SCOPE", "CLASS", false, false))
|
1586 kumpf 1.122 scope.addScope (CIMScope::CLASS);
|
1587 mike 1.23
1588 if (getCimBooleanAttribute(
|
1589 kumpf 1.122 line, entry, "SCOPE", "ASSOCIATION", false, false))
1590 scope.addScope (CIMScope::ASSOCIATION);
|
1591 mike 1.23
1592 if (getCimBooleanAttribute(
|
1593 kumpf 1.122 line, entry, "SCOPE", "REFERENCE", false, false))
1594 scope.addScope (CIMScope::REFERENCE);
|
1595 mike 1.23
1596 if (getCimBooleanAttribute(line, entry, "SCOPE", "PROPERTY", false, false))
|
1597 kumpf 1.122 scope.addScope (CIMScope::PROPERTY);
|
1598 mike 1.23
1599 if (getCimBooleanAttribute(line, entry, "SCOPE", "METHOD", false, false))
|
1600 kumpf 1.122 scope.addScope (CIMScope::METHOD);
|
1601 mike 1.23
1602 if (getCimBooleanAttribute(line, entry, "SCOPE", "PARAMETER", false, false))
|
1603 kumpf 1.122 scope.addScope (CIMScope::PARAMETER);
|
1604 mike 1.23
1605 if (getCimBooleanAttribute(line, entry, "SCOPE", "INDICATION",false, false))
|
1606 kumpf 1.122 scope.addScope (CIMScope::INDICATION);
|
1607 mike 1.23
1608 if (!isEmptyTag)
|
1609 kumpf 1.122 expectEndTag(parser, "SCOPE");
|
1610 mike 1.23
1611 return scope;
1612 }
1613
1614 //------------------------------------------------------------------------------
1615 //
1616 // getQualifierElement()
1617 //
|
1618 kumpf 1.52 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)?>
|
1619 mike 1.23 // <!ATTLIST QUALIFIER
1620 // %CIMName;
1621 // %CIMType; #REQUIRED
1622 // %Propagated;
1623 // %QualifierFlavor;>
1624 //
1625 //------------------------------------------------------------------------------
1626
1627 Boolean XmlReader::getQualifierElement(
|
1628 kumpf 1.122 XmlParser& parser,
|
1629 mike 1.23 CIMQualifier& qualifier)
1630 {
1631 // Get QUALIFIER element:
1632
1633 XmlEntry entry;
|
1634 kumpf 1.103 if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER"))
|
1635 kumpf 1.122 return false;
|
1636 mike 1.23
|
1637 kumpf 1.103 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1638
|
1639 mike 1.23 // Get QUALIFIER.NAME attribute:
1640
|
1641 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
|
1642 mike 1.23
1643 // Get QUALIFIER.TYPE attribute:
1644
|
1645 kumpf 1.67 CIMType type;
1646 getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER");
|
1647 mike 1.23
1648 // Get QUALIFIER.PROPAGATED
1649
1650 Boolean propagated = getCimBooleanAttribute(
|
1651 kumpf 1.122 parser.getLine(), entry, "QUALIFIER", "PROPAGATED", false, false);
|
1652 mike 1.23
1653 // Get flavor oriented attributes:
1654
|
1655 kumpf 1.64 CIMFlavor flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");
|
1656 mike 1.23
1657 // Get VALUE or VALUE.ARRAY element:
1658
1659 CIMValue value;
1660
|
1661 kumpf 1.103 if (empty)
|
1662 mike 1.23 {
|
1663 kumpf 1.52 value.setNullValue(type, false);
|
1664 mike 1.23 }
|
1665 kumpf 1.103 else
1666 {
1667 if (!getValueElement(parser, type, value) &&
|
1668 kumpf 1.122 !getValueArrayElement(parser, type, value))
|
1669 kumpf 1.103 {
1670 value.setNullValue(type, false);
1671 }
|
1672 mike 1.23
|
1673 kumpf 1.103 // Expect </QUALIFIER>:
|
1674 mike 1.23
|
1675 kumpf 1.103 expectEndTag(parser, "QUALIFIER");
1676 }
|
1677 mike 1.23
1678 // Build qualifier:
1679
1680 qualifier = CIMQualifier(name, value, flavor, propagated);
1681 return true;
1682 }
1683
1684 //------------------------------------------------------------------------------
1685 //
1686 // getQualifierElements()
1687 //
1688 //------------------------------------------------------------------------------
1689
1690 template<class CONTAINER>
1691 void getQualifierElements(XmlParser& parser, CONTAINER& container)
1692 {
1693 CIMQualifier qualifier;
1694
1695 while (XmlReader::getQualifierElement(parser, qualifier))
1696 {
|
1697 kumpf 1.122 try
1698 {
1699 container.addQualifier(qualifier);
1700 }
1701 catch (AlreadyExistsException&)
1702 {
1703 MessageLoaderParms mlParms(
1704 "Common.XmlReader.DUPLICATE_QUALIFIER",
1705 "duplicate qualifier");
1706 throw XmlSemanticError(parser.getLine(), mlParms);
1707 }
|
1708 mike 1.23 }
1709 }
1710
1711 //------------------------------------------------------------------------------
1712 //
1713 // getPropertyElement()
1714 //
1715 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
1716 // <!ATTLIST PROPERTY
1717 // %CIMName;
1718 // %ClassOrigin;
1719 // %Propagated;
|
1720 dave.sudlik 1.109 // %EmbeddedObject; #IMPLIED
|
1721 mike 1.23 // %CIMType; #REQUIRED>
1722 //
1723 //------------------------------------------------------------------------------
1724
1725 Boolean XmlReader::getPropertyElement(XmlParser& parser, CIMProperty& property)
1726 {
1727 XmlEntry entry;
1728
1729 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY"))
|
1730 kumpf 1.122 return false;
|
1731 mike 1.23
1732 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1733
1734 // Get PROPERTY.NAME attribute:
1735
|
1736 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
|
1737 mike 1.23
1738 // Get PROPERTY.CLASSORIGIN attribute:
1739
|
1740 kumpf 1.122 CIMName classOrigin =
1741 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
|
1742 mike 1.23
1743 // Get PROPERTY.PROPAGATED
1744
1745 Boolean propagated = getCimBooleanAttribute(
|
1746 kumpf 1.122 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
|
1747 mike 1.23
|
1748 karl 1.129 // Get PROPERTY.EmbeddedObject attribute:
|
1749 dave.sudlik 1.109
|
1750 kumpf 1.139 EmbeddedObjectAttributeType embeddedObject =
|
1751 thilo.boehm 1.131 getEmbeddedObjectAttribute(parser.getLine(), entry, "PROPERTY");
|
1752 dave.sudlik 1.109
|
1753 mike 1.23 // Get PROPERTY.TYPE attribute:
1754
|
1755 kumpf 1.67 CIMType type;
1756 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");
|
1757 mike 1.23
|
1758 karl 1.35 // Create property: Sets type and !isarray
|
1759 mike 1.23
|
1760 kumpf 1.56 CIMValue value(type, false);
|
1761 kumpf 1.62 property = CIMProperty(name, value, 0, CIMName(), classOrigin, propagated);
|
1762 mike 1.23
1763 if (!empty)
1764 {
|
1765 kumpf 1.122 // Get qualifiers. We need to do this before checking for the
1766 // property as an embedded object, because we need to also check
1767 // for the EmbeddedObject qualifier.
1768 getQualifierElements(parser, property);
|
1769 dave.sudlik 1.109 }
|
1770 mike 1.23
|
1771 dave.sudlik 1.110 Boolean embeddedObjectQualifierValue = false;
|
1772 thilo.boehm 1.131 Uint32 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT);
|
1773 dave.sudlik 1.110 if (ix != PEG_NOT_FOUND)
1774 {
1775 property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);
1776 }
|
1777 a.dunfey 1.118 String embeddedInstanceQualifierValue;
|
1778 thilo.boehm 1.131 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE);
|
1779 a.dunfey 1.118 if (ix != PEG_NOT_FOUND)
1780 {
|
1781 kumpf 1.122 property.getQualifier(ix).getValue().get(
1782 embeddedInstanceQualifierValue);
|
1783 a.dunfey 1.118 }
|
1784 karl 1.129 // If the EmbeddedObject attribute is present with value "object"
|
1785 dave.sudlik 1.110 // or the EmbeddedObject qualifier exists on this property with value "true"
|
1786 karl 1.129 // then convert the EmbeddedObject-encoded string into a CIMObject
|
1787 thilo.boehm 1.131 Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) ||
|
1788 kumpf 1.122 embeddedObjectQualifierValue;
|
1789 thilo.boehm 1.131 Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) ||
|
1790 kumpf 1.122 embeddedInstanceQualifierValue.size() > 0;
|
1791 a.dunfey 1.118 if (isEmbeddedObject || isEmbeddedInstance)
1792 {
|
1793 karl 1.129 // The EmbeddedObject attribute is only valid on Properties of type
|
1794 kumpf 1.122 // string
|
1795 a.dunfey 1.118 if (type == CIMTYPE_STRING)
1796 {
|
1797 kumpf 1.122 if (isEmbeddedObject)
1798 type = CIMTYPE_OBJECT;
|
1799 a.dunfey 1.118 else
|
1800 kumpf 1.122 type = CIMTYPE_INSTANCE;
|
1801 a.dunfey 1.118 CIMValue new_value(type, false);
|
1802 kumpf 1.122 CIMProperty new_property = CIMProperty(
1803 name, new_value, 0, CIMName(), classOrigin, propagated);
1804
1805 // Copy the qualifiers from the String property to the CIMObject
1806 // property.
|
1807 kumpf 1.130 for (Uint32 i = 0; i < property.getQualifierCount(); ++i)
|
1808 a.dunfey 1.118 {
|
1809 kumpf 1.122 // All properties are copied, including the EmbeddedObject
1810 // qualifier. This way we don't have to keep track to know
1811 // that the EmbeddedObject qualifier needs to be added back
1812 // during the encode step.
|
1813 kumpf 1.130 new_property.addQualifier(property.getQualifier(i));
|
1814 a.dunfey 1.118 }
1815
1816 value = new_value;
1817 property = new_property;
1818 }
1819 else
1820 {
|
1821 kumpf 1.122 MessageLoaderParms mlParms(
1822 "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
|
1823 karl 1.129 "The EmbeddedObject attribute is only valid on string types.");
|
1824 a.dunfey 1.118 throw XmlValidationError(parser.getLine(), mlParms);
1825 }
1826 }
|
1827 dave.sudlik 1.109 // Continue on to get property value, if not empty.
1828 if (!empty)
1829 {
1830 if (getValueElement(parser, type, value))
1831 property.setValue(value);
1832 expectEndTag(parser, "PROPERTY");
|
1833 mike 1.23 }
1834
1835 return true;
1836 }
1837
1838 //------------------------------------------------------------------------------
1839 //
1840 // getArraySizeAttribute()
1841 //
1842 // Returns true if able to get array-size. Note that array size will
1843 // always be a positive integer.
1844 //
1845 // <!ENTITY % ArraySize "ARRAYSIZE CDATA #IMPLIED">
1846 //
1847 //------------------------------------------------------------------------------
1848
1849 Boolean XmlReader::getArraySizeAttribute(
1850 Uint32 lineNumber,
1851 const XmlEntry& entry,
1852 const char* tagName,
1853 Uint32& value)
1854 mike 1.23 {
1855 const char* tmp;
1856
1857 if (!entry.getAttributeValue("ARRAYSIZE", tmp))
|
1858 kumpf 1.122 return false;
|
1859 mike 1.23
1860 Uint64 arraySize;
1861
|
1862 thilo.boehm 1.144 if (!StringConversion::stringToUnsignedInteger(tmp, arraySize) ||
1863 (arraySize == 0) ||
|
1864 kumpf 1.126 !StringConversion::checkUintBounds(arraySize, CIMTYPE_UINT32))
|
1865 mike 1.23 {
|
1866 kumpf 1.122 char message[128];
1867 sprintf(message, "%s.%s", tagName, "ARRAYSIZE");
1868
1869 MessageLoaderParms mlParms(
1870 "Common.XmlReader.ILLEGAL_VALUE",
1871 "Illegal value for $0",
1872 message);
1873 throw XmlSemanticError(lineNumber, mlParms);
|
1874 mike 1.23 }
1875
1876 value = Uint32(arraySize);
1877 return true;
1878 }
1879
1880 //------------------------------------------------------------------------------
1881 //
1882 // getPropertyArrayElement()
1883 //
1884 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
1885 // <!ATTLIST PROPERTY.ARRAY
1886 // %CIMName;
1887 // %CIMType; #REQUIRED
1888 // %ArraySize;
1889 // %ClassOrigin;
|
1890 dave.sudlik 1.109 // %Propagated;
1891 // %EmbeddedObject; #IMPLIED>
|
1892 mike 1.23 //
1893 //------------------------------------------------------------------------------
1894
1895 Boolean XmlReader::getPropertyArrayElement(
|
1896 kumpf 1.122 XmlParser& parser,
|
1897 mike 1.23 CIMProperty& property)
1898 {
1899 // Get PROPERTY element:
1900
1901 XmlEntry entry;
1902
1903 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.ARRAY"))
|
1904 kumpf 1.122 return false;
|
1905 mike 1.23
1906 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1907
1908 // Get PROPERTY.NAME attribute:
1909
|
1910 kumpf 1.122 CIMName name =
1911 getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
|
1912 mike 1.23
1913 // Get PROPERTY.TYPE attribute:
1914
|
1915 kumpf 1.67 CIMType type;
1916 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY.ARRAY");
|
1917 mike 1.23
1918 // Get PROPERTY.ARRAYSIZE attribute:
1919
1920 Uint32 arraySize = 0;
1921 getArraySizeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY", arraySize);
1922
1923 // Get PROPERTY.CLASSORIGIN attribute:
1924
|
1925 kumpf 1.122 CIMName classOrigin =
1926 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
|
1927 mike 1.23
1928 // Get PROPERTY.ARRAY.PROPAGATED
1929
|
1930 kumpf 1.122 Boolean propagated = getCimBooleanAttribute(
1931 parser.getLine(),
1932 entry,
1933 "PROPERTY.ARRAY",
1934 "PROPAGATED",
1935 false,
1936 false);
|
1937 dave.sudlik 1.109
|
1938 karl 1.129 // Get PROPERTY.EmbeddedObject attribute:
|
1939 dave.sudlik 1.109
|
1940 thilo.boehm 1.131 EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(
|
1941 kumpf 1.122 parser.getLine(), entry, "PROPERTY.ARRAY");
|
1942 mike 1.23
1943 // Create property:
1944
|
1945 kumpf 1.56 CIMValue value(type, true, arraySize);
|
1946 kumpf 1.122 property = CIMProperty(
1947 name, value, arraySize, CIMName(), classOrigin, propagated);
|
1948 mike 1.23
1949 if (!empty)
1950 {
|
1951 dave.sudlik 1.109 // Get qualifiers:
1952 getQualifierElements(parser, property);
1953 }
|
1954 mike 1.23
|
1955 dave.sudlik 1.110 Boolean embeddedObjectQualifierValue = false;
|
1956 thilo.boehm 1.131 Uint32 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT);
|
1957 dave.sudlik 1.110 if (ix != PEG_NOT_FOUND)
1958 {
1959 property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);
1960 }
|
1961 a.dunfey 1.118 String embeddedInstanceQualifierValue;
|
1962 thilo.boehm 1.131 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE);
|
1963 a.dunfey 1.118 if (ix != PEG_NOT_FOUND)
1964 {
|
1965 kumpf 1.122 property.getQualifier(ix).getValue().get(
1966 embeddedInstanceQualifierValue);
|
1967 a.dunfey 1.118 }
|
1968 karl 1.129 // If the EmbeddedObject attribute is present with value "object"
|
1969 dave.sudlik 1.110 // or the EmbeddedObject qualifier exists on this property with value "true"
|
1970 dave.sudlik 1.109 // then
1971 // Convert the EmbeddedObject-encoded string into a CIMObject
|
1972 thilo.boehm 1.131 Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) ||
|
1973 kumpf 1.122 embeddedObjectQualifierValue;
|
1974 thilo.boehm 1.131 Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) ||
|
1975 kumpf 1.122 embeddedInstanceQualifierValue.size() > 0;
|
1976 a.dunfey 1.118 if (isEmbeddedObject || isEmbeddedInstance)
1977 {
|
1978 karl 1.129 // The EmbeddedObject attribute is only valid on Properties of type
|
1979 kumpf 1.122 // string
|
1980 a.dunfey 1.118 if (type == CIMTYPE_STRING)
1981 {
|
1982 kumpf 1.122 if (isEmbeddedObject)
1983 type = CIMTYPE_OBJECT;
|
1984 a.dunfey 1.118 else
|
1985 kumpf 1.122 type = CIMTYPE_INSTANCE;
|
1986 a.dunfey 1.118 CIMValue new_value(type, true, arraySize);
|
1987 kumpf 1.122 CIMProperty new_property = CIMProperty(
1988 name, new_value, arraySize, CIMName(), classOrigin, propagated);
1989
1990 // Copy the qualifiers from the String property to the CIMObject
1991 // property.
|
1992 kumpf 1.130 for (Uint32 i = 0; i < property.getQualifierCount(); ++i)
|
1993 a.dunfey 1.118 {
|
1994 kumpf 1.122 // All properties are copied, including the EmbeddedObject
1995 // qualifier. This way we don't have to keep track to know
1996 // that the EmbeddedObject qualifier needs to be added back
1997 // during the encode step.
|
1998 kumpf 1.130 new_property.addQualifier(property.getQualifier(i));
|
1999 a.dunfey 1.118 }
|
2000 kumpf 1.122
|
2001 a.dunfey 1.118 value = new_value;
2002 property = new_property;
2003 }
2004 else
2005 {
|
2006 kumpf 1.122 MessageLoaderParms mlParms(
2007 "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
|
2008 karl 1.129 "The EmbeddedObject attribute is only valid on string types.");
|
2009 a.dunfey 1.118 throw XmlValidationError(parser.getLine(), mlParms);
2010 }
2011 }
|
2012 dave.sudlik 1.109 // Continue on to get property array value, if not empty.
2013 // Else not an embedded object, if not empty, get the property array value.
2014 if (!empty)
2015 {
2016 if (getValueArrayElement(parser, type, value))
2017 {
2018 if (arraySize && arraySize != value.getArraySize())
2019 {
|
2020 kumpf 1.122 MessageLoaderParms mlParms(
2021 "Common.XmlReader.ARRAY_SIZE_DIFFERENT",
2022 "ARRAYSIZE attribute and value-array size are different");
2023 throw XmlSemanticError(parser.getLine(), mlParms);
|
2024 dave.sudlik 1.109 }
|
2025 mike 1.23
|
2026 dave.sudlik 1.109 property.setValue(value);
2027 }
2028 expectEndTag(parser, "PROPERTY.ARRAY");
|
2029 mike 1.23 }
|
2030 kumpf 1.122
|
2031 mike 1.23 return true;
2032 }
2033
2034 //------------------------------------------------------------------------------
2035 //
2036 // getHostElement()
2037 //
2038 // <!ELEMENT HOST (#PCDATA)>
2039 //
2040 //------------------------------------------------------------------------------
2041
2042 Boolean XmlReader::getHostElement(
2043 XmlParser& parser,
2044 String& host)
2045 {
2046 XmlEntry entry;
2047
2048 if (!testStartTag(parser, entry, "HOST"))
|
2049 kumpf 1.122 return false;
|
2050 karl 1.148
|
2051 mike 1.23 if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)
2052 {
|
2053 kumpf 1.122 MessageLoaderParms mlParms(
2054 "Common.XmlReader.EXPECTED_CONTENT_ELEMENT",
2055 "expected content of HOST element");
2056 throw XmlValidationError(parser.getLine(), mlParms);
|
2057 mike 1.23 }
2058
|
2059 chuck 1.98 host = String(entry.text);
|
2060 mike 1.23 expectEndTag(parser, "HOST");
2061 return true;
2062 }
2063
2064 //------------------------------------------------------------------------------
2065 //
2066 // getNameSpaceElement()
|
2067 kumpf 1.122 //
|
2068 mike 1.23 // <!ELEMENT NAMESPACE EMPTY>
2069 // <!ATTLIST NAMESPACE %CIMName;>
2070 //
2071 //------------------------------------------------------------------------------
2072
2073 Boolean XmlReader::getNameSpaceElement(
2074 XmlParser& parser,
|
2075 kumpf 1.74 CIMName& nameSpaceComponent)
|
2076 mike 1.23 {
2077 XmlEntry entry;
2078
2079 if (!testStartTagOrEmptyTag(parser, entry, "NAMESPACE"))
|
2080 kumpf 1.122 return false;
|
2081 mike 1.23
2082 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2083
2084 nameSpaceComponent = getCimNameAttribute(
|
2085 kumpf 1.122 parser.getLine(), entry, "NAMESPACE");
|
2086 mike 1.23
2087 if (!empty)
|
2088 kumpf 1.122 expectEndTag(parser, "NAMESPACE");
|
2089 mike 1.23
2090 return true;
2091 }
2092
2093 //------------------------------------------------------------------------------
2094 //
2095 // getLocalNameSpacePathElement()
|
2096 kumpf 1.122 //
|
2097 mike 1.23 // <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
2098 //
2099 //------------------------------------------------------------------------------
2100
2101 Boolean XmlReader::getLocalNameSpacePathElement(
2102 XmlParser& parser,
2103 String& nameSpace)
2104 {
2105 XmlEntry entry;
2106
2107 if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))
|
2108 kumpf 1.122 return false;
|
2109 mike 1.23
|
2110 kumpf 1.74 CIMName nameSpaceComponent;
|
2111 mike 1.23
2112 while (getNameSpaceElement(parser, nameSpaceComponent))
2113 {
|
2114 kumpf 1.122 if (nameSpace.size())
2115 nameSpace.append('/');
|
2116 mike 1.23
|
2117 kumpf 1.122 nameSpace.append(nameSpaceComponent.getString());
|
2118 mike 1.23 }
2119
2120 if (!nameSpace.size())
2121 {
|
2122 kumpf 1.122 MessageLoaderParms mlParms(
2123 "Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",
2124 "Expected one or more NAMESPACE elements within "
2125 "LOCALNAMESPACEPATH element");
2126 throw XmlValidationError(parser.getLine(), mlParms);
|
2127 mike 1.23 }
2128
2129 expectEndTag(parser, "LOCALNAMESPACEPATH");
2130 return true;
2131 }
2132
2133 //------------------------------------------------------------------------------
2134 //
2135 // getNameSpacePathElement()
2136 //
2137 // <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
2138 //
2139 //------------------------------------------------------------------------------
2140
2141 Boolean XmlReader::getNameSpacePathElement(
2142 XmlParser& parser,
2143 String& host,
2144 String& nameSpace)
2145 {
2146 host.clear();
2147 nameSpace.clear();
2148 mike 1.23
2149 XmlEntry entry;
2150
2151 if (!testStartTag(parser, entry, "NAMESPACEPATH"))
|
2152 kumpf 1.122 return false;
|
2153 mike 1.23
|
2154 kumpf 1.122 if (!getHostElement(parser, host))
2155 {
2156 MessageLoaderParms mlParms(
2157 "Common.XmlReader.EXPECTED_HOST_ELEMENT",
2158 "expected HOST element");
2159 throw XmlValidationError(parser.getLine(), mlParms);
|
2160 humberto 1.85 }
|
2161 mike 1.23
2162 if (!getLocalNameSpacePathElement(parser, nameSpace))
2163 {
|
2164 kumpf 1.122 MessageLoaderParms mlParms(
2165 "Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2166 "expected LOCALNAMESPACEPATH element");
2167 throw XmlValidationError(parser.getLine(), mlParms);
|
2168 mike 1.23 }
2169
2170 expectEndTag(parser, "NAMESPACEPATH");
2171
2172 return true;
2173 }
2174
2175 //------------------------------------------------------------------------------
2176 //
2177 // getClassNameElement()
2178 //
2179 // <!ELEMENT CLASSNAME EMPTY>
2180 // <!ATTLIST CLASSNAME %CIMName;>
2181 //
2182 //------------------------------------------------------------------------------
2183
2184 Boolean XmlReader::getClassNameElement(
2185 XmlParser& parser,
|
2186 kumpf 1.74 CIMName& className,
|
2187 mike 1.23 Boolean required)
2188 {
2189 XmlEntry entry;
2190
2191 if (!testStartTagOrEmptyTag(parser, entry, "CLASSNAME"))
2192 {
|
2193 kumpf 1.122 if (required)
2194 {
2195 MessageLoaderParms mlParms(
2196 "Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2197 "expected CLASSNAME element");
2198 throw XmlValidationError(parser.getLine(), mlParms);
2199 }
2200 else
2201 return false;
|
2202 mike 1.23 }
2203 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2204
2205 className = getCimNameAttribute(
|
2206 kumpf 1.122 parser.getLine(), entry, "CLASSNAME", false);
|
2207 mike 1.23
2208 if (!empty)
|
2209 kumpf 1.122 expectEndTag(parser, "CLASSNAME");
|
2210 mike 1.23
2211 return true;
2212 }
2213
2214 //------------------------------------------------------------------------------
2215 //
2216 // getValueTypeAttribute()
2217 //
2218 // VALUETYPE (string|boolean|numeric) 'string'
2219 //
2220 //------------------------------------------------------------------------------
2221
|
2222 kumpf 1.73 CIMKeyBinding::Type XmlReader::getValueTypeAttribute(
|
2223 kumpf 1.122 Uint32 lineNumber,
|
2224 mike 1.23 const XmlEntry& entry,
2225 const char* elementName)
2226 {
|
2227 thilo.boehm 1.131 const char* tmp;
|
2228 mike 1.23
2229 if (!entry.getAttributeValue("VALUETYPE", tmp))
|
2230 kumpf 1.122 return CIMKeyBinding::STRING;
|
2231 mike 1.23
|
2232 thilo.boehm 1.131 if (strcmp(tmp, "string") == 0)
|
2233 kumpf 1.122 return CIMKeyBinding::STRING;
|
2234 thilo.boehm 1.131 else if (strcmp(tmp, "boolean") == 0)
|
2235 kumpf 1.122 return CIMKeyBinding::BOOLEAN;
|
2236 thilo.boehm 1.131 else if (strcmp(tmp, "numeric") == 0)
|
2237 kumpf 1.122 return CIMKeyBinding::NUMERIC;
|
2238 humberto 1.85
|
2239 mike 1.23 char buffer[MESSAGE_SIZE];
|
2240 humberto 1.85 sprintf(buffer, "%s.VALUETYPE", elementName);
|
2241 kumpf 1.122
2242 MessageLoaderParms mlParms(
2243 "Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",
2244 "Illegal value for $0 attribute; CIMValue must be one of \"string\", "
2245 "\"boolean\", or \"numeric\"",
2246 buffer);
|
2247 humberto 1.85 throw XmlSemanticError(lineNumber, mlParms);
|
2248 mike 1.23
|
2249 kumpf 1.73 return CIMKeyBinding::BOOLEAN;
|
2250 mike 1.23 }
2251
2252 //------------------------------------------------------------------------------
2253 //
2254 // getKeyValueElement()
2255 //
2256 // <!ELEMENT KEYVALUE (#PCDATA)>
2257 // <!ATTLIST KEYVALUE
2258 // VALUETYPE (string|boolean|numeric) 'string'>
2259 //
2260 //------------------------------------------------------------------------------
2261
2262 Boolean XmlReader::getKeyValueElement(
2263 XmlParser& parser,
|
2264 kumpf 1.73 CIMKeyBinding::Type& type,
|
2265 mike 1.23 String& value)
2266 {
2267 XmlEntry entry;
2268
2269 if (!testStartTagOrEmptyTag(parser, entry, "KEYVALUE"))
|
2270 kumpf 1.122 return false;
|
2271 mike 1.23
2272 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2273
2274 type = getValueTypeAttribute(parser.getLine(), entry, "KEYVALUE");
2275
2276 value.clear();
2277
2278 if (!empty)
2279 {
|
2280 kumpf 1.122 if (!parser.next(entry))
2281 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
|
2282 mike 1.23
|
2283 kumpf 1.122 if (entry.type == XmlEntry::CONTENT)
2284 value = String(entry.text);
2285 else
2286 parser.putBack(entry);
|
2287 mike 1.23
|
2288 kumpf 1.122 expectEndTag(parser, "KEYVALUE");
|
2289 mike 1.23 }
2290
2291 return true;
2292 }
2293
2294 //------------------------------------------------------------------------------
2295 //
2296 // getKeyBindingElement()
2297 //
2298 // <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>
2299 // <!ATTLIST KEYBINDING
2300 // %CIMName;>
2301 //
2302 //------------------------------------------------------------------------------
2303
2304 Boolean XmlReader::getKeyBindingElement(
2305 XmlParser& parser,
|
2306 kumpf 1.74 CIMName& name,
|
2307 mike 1.23 String& value,
|
2308 kumpf 1.73 CIMKeyBinding::Type& type)
|
2309 mike 1.23 {
2310 XmlEntry entry;
2311
2312 if (!testStartTag(parser, entry, "KEYBINDING"))
|
2313 kumpf 1.122 return false;
|
2314 mike 1.23
2315 name = getCimNameAttribute(parser.getLine(), entry, "KEYBINDING");
2316
2317 if (!getKeyValueElement(parser, type, value))
|
2318 mike 1.25 {
|
2319 kumpf 1.54 CIMObjectPath reference;
|
2320 mike 1.25
2321 if (!getValueReferenceElement(parser, reference))
2322 {
|
2323 kumpf 1.122 MessageLoaderParms mlParms(
2324 "Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",
2325 "Expected KEYVALUE or VALUE.REFERENCE element");
2326 throw XmlValidationError(parser.getLine(), mlParms);
|
2327 mike 1.25 }
2328
|
2329 kumpf 1.73 type = CIMKeyBinding::REFERENCE;
|
2330 mike 1.25 value = reference.toString();
2331 }
|
2332 mike 1.23
2333 expectEndTag(parser, "KEYBINDING");
2334 return true;
2335 }
2336
2337 //------------------------------------------------------------------------------
2338 //
2339 // getInstanceNameElement()
2340 //
2341 // <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
2342 // <!ATTLIST INSTANCENAME
2343 // %ClassName;>
2344 //
|
2345 mike 1.25 // Note: An empty key name is used in the keyBinding when the INSTANCENAME is
2346 // specified using a KEYVALUE or a VALUE.REFERENCE.
|
2347 mike 1.23 //
2348 //------------------------------------------------------------------------------
2349
2350 Boolean XmlReader::getInstanceNameElement(
2351 XmlParser& parser,
2352 String& className,
|
2353 kumpf 1.73 Array<CIMKeyBinding>& keyBindings)
|
2354 mike 1.23 {
2355 className.clear();
2356 keyBindings.clear();
2357
2358 XmlEntry entry;
2359
2360 if (!testStartTagOrEmptyTag(parser, entry, "INSTANCENAME"))
|
2361 kumpf 1.122 return false;
|
2362 mike 1.23
2363 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2364
2365 className = getClassNameAttribute(parser.getLine(), entry, "INSTANCENAME");
2366
|
2367 mike 1.25 if (empty)
|
2368 mike 1.23 {
|
2369 mike 1.25 return true;
2370 }
|
2371 mike 1.23
|
2372 kumpf 1.74 CIMName name;
|
2373 kumpf 1.73 CIMKeyBinding::Type type;
|
2374 mike 1.25 String value;
|
2375 kumpf 1.54 CIMObjectPath reference;
|
2376 mike 1.25
2377 if (getKeyValueElement(parser, type, value))
2378 {
2379 // Use empty key name because none was specified
|
2380 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2381 mike 1.25 }
2382 else if (getValueReferenceElement(parser, reference))
2383 {
2384 // Use empty key name because none was specified
|
2385 kumpf 1.73 type = CIMKeyBinding::REFERENCE;
|
2386 mike 1.25 value = reference.toString();
|
2387 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2388 mike 1.25 }
2389 else
2390 {
|
2391 kumpf 1.122 while (getKeyBindingElement(parser, name, value, type))
|
2392 marek 1.146 {
|
2393 kumpf 1.122 keyBindings.append(CIMKeyBinding(name, value, type));
|
2394 marek 1.146 if (keyBindings.size() > PEGASUS_MAXELEMENTS_NUM)
2395 {
2396 MessageLoaderParms mlParms(
2397 "Common.XmlReader.TOO_MANY_KEYBINDINGS",
2398 "More than $0 key-value pairs per object path"
2399 " are not supported.",
2400 PEGASUS_MAXELEMENTS_NUM);
2401 throw XmlValidationError(parser.getLine(), mlParms);
2402 }
2403 }
|
2404 mike 1.25 }
|
2405 mike 1.23
|
2406 mike 1.25 expectEndTag(parser, "INSTANCENAME");
|
2407 mike 1.23
2408 return true;
2409 }
2410
2411 Boolean XmlReader::getInstanceNameElement(
2412 XmlParser& parser,
|
2413 kumpf 1.54 CIMObjectPath& instanceName)
|
2414 mike 1.23 {
2415 String className;
|
2416 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2417 mike 1.23
2418 if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
|
2419 kumpf 1.122 return false;
|
2420 mike 1.23
|
2421 kumpf 1.62 instanceName.set(String(), CIMNamespaceName(), className, keyBindings);
|
2422 mike 1.23 return true;
2423 }
2424
2425 //------------------------------------------------------------------------------
2426 //
2427 // getInstancePathElement()
2428 //
2429 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2430 //
2431 //------------------------------------------------------------------------------
2432
2433 Boolean XmlReader::getInstancePathElement(
2434 XmlParser& parser,
|
2435 kumpf 1.54 CIMObjectPath& reference)
|
2436 mike 1.23 {
2437 XmlEntry entry;
2438
2439 if (!testStartTag(parser, entry, "INSTANCEPATH"))
|
2440 kumpf 1.122 return false;
|
2441 mike 1.23
2442 String host;
2443 String nameSpace;
2444
2445 if (!getNameSpacePathElement(parser, host, nameSpace))
2446 {
|
2447 kumpf 1.122 MessageLoaderParms mlParms(
2448 "Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
2449 "expected NAMESPACEPATH element");
2450 throw XmlValidationError(parser.getLine(), mlParms);
|
2451 mike 1.23 }
2452
2453 String className;
|
2454 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2455 mike 1.23
2456 if (!getInstanceNameElement(parser, className, keyBindings))
2457 {
|
2458 kumpf 1.122 MessageLoaderParms mlParms(
2459 "Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
2460 "expected INSTANCENAME element");
2461 throw XmlValidationError(parser.getLine(), mlParms);
|
2462 mike 1.23 }
2463
2464 reference.set(host, nameSpace, className, keyBindings);
2465
2466 expectEndTag(parser, "INSTANCEPATH");
2467 return true;
2468 }
2469
2470 //------------------------------------------------------------------------------
2471 //
2472 // getLocalInstancePathElement()
2473 //
2474 // <!ELEMENT LOCALINSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2475 //
2476 //------------------------------------------------------------------------------
2477
2478 Boolean XmlReader::getLocalInstancePathElement(
2479 XmlParser& parser,
|
2480 kumpf 1.54 CIMObjectPath& reference)
|
2481 mike 1.23 {
2482 XmlEntry entry;
2483
2484 if (!testStartTag(parser, entry, "LOCALINSTANCEPATH"))
|
2485 kumpf 1.122 return false;
|
2486 mike 1.23
2487 String nameSpace;
2488
2489 if (!getLocalNameSpacePathElement(parser, nameSpace))
2490 {
|
2491 kumpf 1.122 MessageLoaderParms mlParms(
2492 "Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2493 "expected LOCALNAMESPACEPATH element");
2494 throw XmlValidationError(parser.getLine(), mlParms);
|
2495 mike 1.23 }
2496
2497 String className;
|
2498 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2499 mike 1.23
2500 if (!getInstanceNameElement(parser, className, keyBindings))
2501 {
|
2502 kumpf 1.122 MessageLoaderParms mlParms(
2503 "Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
2504 "expected INSTANCENAME element");
2505 throw XmlValidationError(parser.getLine(), mlParms);
|
2506 mike 1.23 }
2507
2508 reference.set(String(), nameSpace, className, keyBindings);
2509
2510 expectEndTag(parser, "LOCALINSTANCEPATH");
2511 return true;
2512 }
2513
2514 //------------------------------------------------------------------------------
2515 //
2516 // getClassPathElement()
2517 //
2518 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
2519 //
2520 //------------------------------------------------------------------------------
2521
2522 Boolean XmlReader::getClassPathElement(
2523 XmlParser& parser,
|
2524 kumpf 1.54 CIMObjectPath& reference)
|
2525 mike 1.23 {
2526 XmlEntry entry;
2527
2528 if (!testStartTag(parser, entry, "CLASSPATH"))
|
2529 kumpf 1.122 return false;
|
2530 mike 1.23
2531 String host;
2532 String nameSpace;
2533
2534 if (!getNameSpacePathElement(parser, host, nameSpace))
2535 {
|
2536 kumpf 1.122 MessageLoaderParms mlParms(
2537 "Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
2538 "expected NAMESPACEPATH element");
2539 throw XmlValidationError(parser.getLine(), mlParms);
|
2540 mike 1.23 }
2541
|
2542 kumpf 1.74 CIMName className;
|
2543 mike 1.23
2544 if (!getClassNameElement(parser, className))
2545 {
|
2546 kumpf 1.122 MessageLoaderParms mlParms(
2547 "Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2548 "expected CLASSNAME element");
2549 throw XmlValidationError(parser.getLine(), mlParms);
|
2550 mike 1.23 }
2551
2552 reference.set(host, nameSpace, className);
2553
2554 expectEndTag(parser, "CLASSPATH");
2555 return true;
2556 }
2557
2558 //------------------------------------------------------------------------------
2559 //
2560 // getLocalClassPathElement()
2561 //
2562 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH,CLASSNAME)>
2563 //
2564 //------------------------------------------------------------------------------
2565
2566 Boolean XmlReader::getLocalClassPathElement(
2567 XmlParser& parser,
|
2568 kumpf 1.54 CIMObjectPath& reference)
|
2569 mike 1.23 {
2570 XmlEntry entry;
2571
2572 if (!testStartTag(parser, entry, "LOCALCLASSPATH"))
|
2573 kumpf 1.122 return false;
|
2574 mike 1.23
2575 String nameSpace;
2576
2577 if (!getLocalNameSpacePathElement(parser, nameSpace))
2578 {
|
2579 kumpf 1.122 MessageLoaderParms mlParms(
2580 "Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2581 "expected LOCALNAMESPACEPATH element");
2582 throw XmlValidationError(parser.getLine(), mlParms);
|
2583 mike 1.23 }
2584
|
2585 kumpf 1.74 CIMName className;
|
2586 mike 1.23
2587 if (!getClassNameElement(parser, className))
2588 {
|
2589 kumpf 1.122 MessageLoaderParms mlParms(
2590 "Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2591 "expected CLASSNAME element");
2592 throw XmlValidationError(parser.getLine(), mlParms);
|
2593 mike 1.23 }
2594
2595 reference.set(String(), nameSpace, className);
2596
2597 expectEndTag(parser, "LOCALCLASSPATH");
2598
2599 return true;
2600 }
2601
2602 //------------------------------------------------------------------------------
2603 //
2604 // getValueReferenceElement()
2605 //
2606 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
2607 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
2608 //
2609 //
2610 //------------------------------------------------------------------------------
|
2611 karl 1.149 //
2612 // Parses the input to a CIMObjectPath. Note that today the differences
2613 // between ClassPath and InstancePath are lost in this mapping because
2614 // Pegasus uses the existence of keys as separator . See BUG_3302
|
2615 mike 1.23 Boolean XmlReader::getValueReferenceElement(
2616 XmlParser& parser,
|
2617 kumpf 1.54 CIMObjectPath& reference)
|
2618 mike 1.23 {
2619 XmlEntry entry;
2620
2621 if (!testStartTag(parser, entry, "VALUE.REFERENCE"))
|
2622 kumpf 1.122 return false;
|
2623 mike 1.23
2624 if (!parser.next(entry))
|
2625 kumpf 1.122 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
|
2626 mike 1.23
|
2627 kumpf 1.122 if (entry.type != XmlEntry::START_TAG &&
2628 entry.type != XmlEntry::EMPTY_TAG)
|
2629 mike 1.23 {
|
2630 kumpf 1.122 MessageLoaderParms mlParms(
2631 "Common.XmlReader.EXPECTED_START_TAGS",
2632 "Expected one of the following start tags: CLASSPATH, "
2633 "LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, "
2634 "INSTANCENAME");
2635 throw XmlValidationError(parser.getLine(), mlParms);
|
2636 mike 1.23 }
2637
2638 if (strcmp(entry.text, "CLASSPATH") == 0)
2639 {
|
2640 kumpf 1.122 parser.putBack(entry);
2641 getClassPathElement(parser, reference);
|
2642 mike 1.23 }
2643 else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)
2644 {
|
2645 kumpf 1.122 parser.putBack(entry);
2646 getLocalClassPathElement(parser, reference);
|
2647 mike 1.23 }
2648 else if (strcmp(entry.text, "CLASSNAME") == 0)
2649 {
|
2650 kumpf 1.122 parser.putBack(entry);
2651 CIMName className;
2652 getClassNameElement(parser, className);
2653 reference.set(String(), CIMNamespaceName(), className);
|
2654 mike 1.23 }
2655 else if (strcmp(entry.text, "INSTANCEPATH") == 0)
2656 {
|
2657 kumpf 1.122 parser.putBack(entry);
2658 getInstancePathElement(parser, reference);
|
2659 mike 1.23 }
2660 else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)
2661 {
|
2662 kumpf 1.122 parser.putBack(entry);
2663 getLocalInstancePathElement(parser, reference);
|
2664 mike 1.23 }
2665 else if (strcmp(entry.text, "INSTANCENAME") == 0)
2666 {
|
2667 kumpf 1.122 parser.putBack(entry);
2668 String className;
2669 Array<CIMKeyBinding> keyBindings;
2670 getInstanceNameElement(parser, className, keyBindings);
2671 reference.set(String(), CIMNamespaceName(), className, keyBindings);
|
2672 mike 1.23 }
2673
2674 expectEndTag(parser, "VALUE.REFERENCE");
2675 return true;
2676 }
2677
2678 //------------------------------------------------------------------------------
2679 //
|
2680 kumpf 1.28 // getValueReferenceArrayElement()
2681 //
2682 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
2683 //
2684 //------------------------------------------------------------------------------
2685
2686 Boolean XmlReader::getValueReferenceArrayElement(
|
2687 kumpf 1.122 XmlParser& parser,
|
2688 kumpf 1.28 CIMValue& value)
2689 {
2690 XmlEntry entry;
|
2691 kumpf 1.54 Array<CIMObjectPath> referenceArray;
2692 CIMObjectPath reference;
|
2693 kumpf 1.28
2694 value.clear();
2695
2696 // Get VALUE.REFARRAY open tag:
2697
2698 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.REFARRAY"))
|
2699 kumpf 1.122 return false;
|
2700 kumpf 1.28
|
2701 kumpf 1.32 if (entry.type != XmlEntry::EMPTY_TAG)
2702 {
2703 // For each VALUE.REFERENCE element:
|
2704 kumpf 1.28
|
2705 kumpf 1.32 while (getValueReferenceElement(parser, reference))
2706 {
|
2707 kumpf 1.122 referenceArray.append(reference);
|
2708 kumpf 1.32 }
|
2709 kumpf 1.28
|
2710 kumpf 1.32 expectEndTag(parser, "VALUE.REFARRAY");
|
2711 kumpf 1.28 }
2712
2713 value.set(referenceArray);
2714 return true;
2715 }
2716
2717 //------------------------------------------------------------------------------
2718 //
|
2719 mike 1.23 // getPropertyReferenceElement()
2720 //
2721 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)>
2722 // <!ATTLIST PROPERTY.REFERENCE
2723 // %CIMName;
2724 // %ReferenceClass;
2725 // %ClassOrigin;
2726 // %Propagated;>
2727 //
2728 //------------------------------------------------------------------------------
2729
2730 Boolean XmlReader::getPropertyReferenceElement(
|
2731 kumpf 1.122 XmlParser& parser,
|
2732 mike 1.23 CIMProperty& property)
2733 {
2734 XmlEntry entry;
2735
2736 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.REFERENCE"))
|
2737 kumpf 1.122 return false;
|
2738 mike 1.23
2739 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2740
2741 // Get PROPERTY.NAME attribute:
2742
|
2743 kumpf 1.74 CIMName name = getCimNameAttribute(
|
2744 kumpf 1.122 parser.getLine(), entry, "PROPERTY.REFERENCE");
|
2745 mike 1.23
2746 // Get PROPERTY.REFERENCECLASS attribute:
2747
|
2748 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
2749 kumpf 1.122 parser.getLine(), entry, "PROPERTY.REFERENCE");
|
2750 mike 1.23
2751 // Get PROPERTY.CLASSORIGIN attribute:
2752
|
2753 kumpf 1.122 CIMName classOrigin =
2754 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");
|
2755 mike 1.23
2756 // Get PROPERTY.PROPAGATED
2757
|
2758 kumpf 1.122 Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,
2759 "PROPERTY.REFERENCE", "PROPAGATED", false, false);
|
2760 mike 1.23
2761 // Create property:
2762
|
2763 kumpf 1.61 CIMValue value = CIMValue(CIMTYPE_REFERENCE, false, 0);
|
2764 kumpf 1.54 // value.set(CIMObjectPath());
|
2765 mike 1.23 property = CIMProperty(
|
2766 kumpf 1.122 name, value, 0, referenceClass, classOrigin, propagated);
|
2767 mike 1.23
2768 if (!empty)
2769 {
|
2770 kumpf 1.122 getQualifierElements(parser, property);
|
2771 mike 1.23
|
2772 kumpf 1.122 CIMObjectPath reference;
|
2773 mike 1.23
|
2774 kumpf 1.122 if (getValueReferenceElement(parser, reference))
2775 property.setValue(reference);
|
2776 mike 1.23
|
2777 kumpf 1.122 expectEndTag(parser, "PROPERTY.REFERENCE");
|
2778 mike 1.23 }
2779
2780 return true;
2781 }
2782
2783 //------------------------------------------------------------------------------
2784 //
2785 // GetPropertyElements()
2786 //
2787 //------------------------------------------------------------------------------
2788
2789 template<class CONTAINER>
2790 void GetPropertyElements(XmlParser& parser, CONTAINER& container)
2791 {
2792 CIMProperty property;
2793
2794 while (XmlReader::getPropertyElement(parser, property) ||
|
2795 kumpf 1.122 XmlReader::getPropertyArrayElement(parser, property) ||
2796 XmlReader::getPropertyReferenceElement(parser, property))
|
2797 mike 1.23 {
|
2798 kumpf 1.122 try
2799 {
2800 container.addProperty(property);
2801 }
2802 catch (AlreadyExistsException&)
2803 {
2804 MessageLoaderParms mlParms(
2805 "Common.XmlReader.DUPLICATE_PROPERTY",
2806 "duplicate property");
2807 throw XmlSemanticError(parser.getLine(), mlParms);
2808 }
|
2809 mike 1.23 }
2810 }
2811
2812 //------------------------------------------------------------------------------
2813 //
2814 // getParameterElement()
2815 //
2816 // <!ELEMENT PARAMETER (QUALIFIER*)>
2817 // <!ATTLIST PARAMETER
2818 // %CIMName;
2819 // %CIMType; #REQUIRED>
2820 //
2821 //------------------------------------------------------------------------------
2822
2823 Boolean XmlReader::getParameterElement(
|
2824 kumpf 1.122 XmlParser& parser,
|
2825 mike 1.23 CIMParameter& parameter)
2826 {
2827 XmlEntry entry;
2828
2829 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER"))
|
2830 kumpf 1.122 return false;
|
2831 mike 1.23
2832 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2833
2834 // Get PARAMETER.NAME attribute:
2835
|
2836 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");
|
2837 mike 1.23
2838 // Get PARAMETER.TYPE attribute:
2839
|
2840 kumpf 1.67 CIMType type;
2841 getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER");
|
2842 mike 1.23
2843 // Create parameter:
2844
2845 parameter = CIMParameter(name, type);
2846
2847 if (!empty)
2848 {
|
2849 kumpf 1.122 getQualifierElements(parser, parameter);
|
2850 mike 1.23
|
2851 kumpf 1.122 expectEndTag(parser, "PARAMETER");
|
2852 mike 1.23 }
2853
2854 return true;
2855 }
2856
2857 //------------------------------------------------------------------------------
2858 //
2859 // getParameterArrayElement()
2860 //
2861 // <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
2862 // <!ATTLIST PARAMETER.ARRAY
2863 // %CIMName;
2864 // %CIMType; #REQUIRED
2865 // %ArraySize;>
2866 //
2867 //------------------------------------------------------------------------------
2868
2869 Boolean XmlReader::getParameterArrayElement(
|
2870 kumpf 1.122 XmlParser& parser,
|
2871 mike 1.23 CIMParameter& parameter)
2872 {
2873 XmlEntry entry;
2874
2875 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.ARRAY"))
|
2876 kumpf 1.122 return false;
|
2877 mike 1.23
2878 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2879
2880 // Get PARAMETER.ARRAY.NAME attribute:
2881
|
2882 kumpf 1.74 CIMName name = getCimNameAttribute(
|
2883 kumpf 1.122 parser.getLine(), entry, "PARAMETER.ARRAY");
|
2884 mike 1.23
2885 // Get PARAMETER.ARRAY.TYPE attribute:
2886
|
2887 kumpf 1.67 CIMType type;
2888 getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER.ARRAY");
|
2889 mike 1.23
2890 // Get PARAMETER.ARRAYSIZE attribute:
2891
2892 Uint32 arraySize = 0;
2893 getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY",arraySize);
2894
2895 // Create parameter:
2896
2897 parameter = CIMParameter(name, type, true, arraySize);
2898
2899 if (!empty)
2900 {
|
2901 kumpf 1.122 getQualifierElements(parser, parameter);
|
2902 mike 1.23
|
2903 kumpf 1.122 expectEndTag(parser, "PARAMETER.ARRAY");
|
2904 mike 1.23 }
2905
2906 return true;
2907 }
2908
2909 //------------------------------------------------------------------------------
2910 //
2911 // getParameterReferenceElement()
2912 //
2913 // <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
2914 // <!ATTLIST PARAMETER.REFERENCE
2915 // %CIMName;
2916 // %ReferenceClass;>
2917 //
2918 //------------------------------------------------------------------------------
2919
2920 Boolean XmlReader::getParameterReferenceElement(
|
2921 kumpf 1.122 XmlParser& parser,
|
2922 mike 1.23 CIMParameter& parameter)
2923 {
2924 XmlEntry entry;
2925
2926 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFERENCE"))
|
2927 kumpf 1.122 return false;
|
2928 mike 1.23
2929 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2930
2931 // Get PARAMETER.NAME attribute:
2932
|
2933 kumpf 1.74 CIMName name = getCimNameAttribute(
|
2934 kumpf 1.122 parser.getLine(), entry, "PARAMETER.REFERENCE");
|
2935 mike 1.23
2936 // Get PARAMETER.REFERENCECLASS attribute:
2937
|
2938 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
2939 kumpf 1.122 parser.getLine(), entry, "PARAMETER.REFERENCE");
|
2940 mike 1.23
2941 // Create parameter:
2942
|
2943 kumpf 1.61 parameter = CIMParameter(name, CIMTYPE_REFERENCE, false, 0, referenceClass);
|
2944 mike 1.23
2945 if (!empty)
2946 {
|
2947 kumpf 1.122 getQualifierElements(parser, parameter);
2948 expectEndTag(parser, "PARAMETER.REFERENCE");
|
2949 mike 1.23 }
2950
2951 return true;
2952 }
2953
2954 //------------------------------------------------------------------------------
2955 //
|
2956 kumpf 1.26 // getParameterReferenceArrayElement()
2957 //
2958 // <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
2959 // <!ATTLIST PARAMETER.REFARRAY
2960 // %CIMName;
2961 // %ReferenceClass;
2962 // %ArraySize;>
2963 //
2964 //------------------------------------------------------------------------------
2965
2966 Boolean XmlReader::getParameterReferenceArrayElement(
|
2967 kumpf 1.122 XmlParser& parser,
|
2968 kumpf 1.26 CIMParameter& parameter)
2969 {
2970 XmlEntry entry;
2971
2972 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFARRAY"))
|
2973 kumpf 1.122 return false;
|
2974 kumpf 1.26
2975 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2976
2977 // Get PARAMETER.NAME attribute:
2978
|
2979 kumpf 1.74 CIMName name = getCimNameAttribute(
|
2980 kumpf 1.122 parser.getLine(), entry, "PARAMETER.REFARRAY");
|
2981 kumpf 1.26
2982 // Get PARAMETER.REFERENCECLASS attribute:
2983
|
2984 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
2985 kumpf 1.122 parser.getLine(), entry, "PARAMETER.REFARRAY");
|
2986 kumpf 1.26
2987 // Get PARAMETER.ARRAYSIZE attribute:
2988
2989 Uint32 arraySize = 0;
|
2990 kumpf 1.122 getArraySizeAttribute(
2991 parser.getLine(), entry, "PARAMETER.REFARRAY", arraySize);
|
2992 kumpf 1.26
2993 // Create parameter:
2994
|
2995 kumpf 1.122 parameter = CIMParameter(
2996 name, CIMTYPE_REFERENCE, true, arraySize, referenceClass);
|
2997 kumpf 1.26
2998 if (!empty)
2999 {
|
3000 kumpf 1.122 getQualifierElements(parser, parameter);
3001 expectEndTag(parser, "PARAMETER.REFARRAY");
|
3002 kumpf 1.26 }
3003
3004 return true;
3005 }
3006
3007 //------------------------------------------------------------------------------
3008 //
|
3009 mike 1.23 // GetParameterElements()
3010 //
3011 //------------------------------------------------------------------------------
3012
3013 template<class CONTAINER>
3014 void GetParameterElements(XmlParser& parser, CONTAINER& container)
3015 {
3016 CIMParameter parameter;
3017
3018 while (XmlReader::getParameterElement(parser, parameter) ||
|
3019 kumpf 1.122 XmlReader::getParameterArrayElement(parser, parameter) ||
3020 XmlReader::getParameterReferenceElement(parser, parameter) ||
3021 XmlReader::getParameterReferenceArrayElement(parser, parameter))
3022 {
3023 try
3024 {
3025 container.addParameter(parameter);
3026 }
3027 catch (AlreadyExistsException&)
3028 {
3029 MessageLoaderParms mlParms(
3030 "Common.XmlReader.DUPLICATE_PARAMETER",
3031 "duplicate parameter");
3032 throw XmlSemanticError(parser.getLine(), mlParms);
3033 }
|
3034 mike 1.23 }
3035 }
3036
3037 //------------------------------------------------------------------------------
3038 //
3039 // getQualifierDeclElement()
3040 //
3041 // <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
|
3042 kumpf 1.122 // <!ATTLIST QUALIFIER.DECLARATION
3043 // %CIMName;
|
3044 mike 1.23 // %CIMType; #REQUIRED
3045 // ISARRAY (true|false) #IMPLIED
3046 // %ArraySize;
3047 // %QualifierFlavor;>
|
3048 kumpf 1.122 //
|
3049 mike 1.23 //------------------------------------------------------------------------------
3050
3051 Boolean XmlReader::getQualifierDeclElement(
|
3052 kumpf 1.122 XmlParser& parser,
|
3053 mike 1.23 CIMQualifierDecl& qualifierDecl)
3054 {
3055 XmlEntry entry;
3056
3057 if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER.DECLARATION"))
|
3058 kumpf 1.122 return false;
|
3059 mike 1.23
3060 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3061
3062 // Get NAME attribute:
3063
|
3064 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3065 kumpf 1.122 parser.getLine(), entry, "QUALIFIER.DECLARATION");
|
3066 mike 1.23
3067 // Get TYPE attribute:
3068
|
3069 kumpf 1.67 CIMType type;
3070 getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER.DECLARATION");
|
3071 mike 1.23
3072 // Get ISARRAY attribute:
3073
|
3074 mike 1.25 Boolean isArray = getCimBooleanAttribute(
3075 parser.getLine(), entry, "QUALIFIER.DECLARATION", "ISARRAY",
|
3076 kumpf 1.122 false, false);
|
3077 mike 1.23
3078 // Get ARRAYSIZE attribute:
3079
3080 Uint32 arraySize = 0;
|
3081 marek 1.147 getArraySizeAttribute(parser.getLine(),
|
3082 kumpf 1.122 entry, "QUALIFIER.DECLARATION", arraySize);
|
3083 mike 1.23
3084 // Get flavor oriented attributes:
3085
|
3086 kumpf 1.122 CIMFlavor flavor = getFlavor (entry, parser.getLine (),
|
3087 kumpf 1.64 "QUALIFIER.DECLARATION");
|
3088 mike 1.23
3089 // No need to look for interior elements if empty tag:
3090
|
3091 kumpf 1.63 CIMScope scope = CIMScope ();
|
3092 mike 1.23 CIMValue value;
|
3093 kumpf 1.67 Boolean gotValue = false;
|
3094 mike 1.23
3095 if (!empty)
3096 {
|
3097 kumpf 1.122 // Get the option SCOPE element:
|
3098 mike 1.23
|
3099 kumpf 1.122 scope = getOptionalScope(parser);
|
3100 mike 1.23
|
3101 kumpf 1.122 // Get VALUE or VALUE.ARRAY element:
|
3102 mike 1.23
|
3103 kumpf 1.122 if (getValueArrayElement(parser, type, value))
3104 {
3105 if (!isArray)
3106 {
3107 MessageLoaderParms mlParms(
3108 "Common.XmlReader.ARRAY_WITHOUT_ISARRAY",
3109 "VALUE.ARRAY element encountered without ISARRAY "
3110 "attribute");
3111 throw XmlSemanticError(parser.getLine(), mlParms);
3112 }
|
3113 humberto 1.85
|
3114 kumpf 1.122 if (arraySize && arraySize != value.getArraySize())
3115 {
3116 MessageLoaderParms mlParms(
3117 "Common.XmlReader.ARRAY_SIZE_NOT_SAME",
3118 "VALUE.ARRAY size is not the same as ARRAYSIZE attribute");
3119 throw XmlSemanticError(parser.getLine(), mlParms);
3120 }
|
3121 kumpf 1.67
3122 gotValue = true;
|
3123 kumpf 1.122 }
3124 else if (getValueElement(parser, type, value))
3125 {
3126 if (isArray)
3127 {
3128 MessageLoaderParms mlParms(
3129 "Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",
3130 "ISARRAY attribute used but VALUE element encountered");
3131 throw XmlSemanticError(parser.getLine(), mlParms);
3132 }
|
3133 kumpf 1.67
3134 gotValue = true;
|
3135 kumpf 1.122 }
|
3136 mike 1.23
|
3137 kumpf 1.122 // Now get the closing tag:
|
3138 mike 1.23
|
3139 kumpf 1.122 expectEndTag(parser, "QUALIFIER.DECLARATION");
|
3140 mike 1.23 }
3141
|
3142 kumpf 1.67 if (!gotValue)
|
3143 mike 1.23 {
|
3144 kumpf 1.122 if (isArray)
3145 value.setNullValue(type, true, arraySize);
3146 else
3147 value.setNullValue(type, false);
|
3148 mike 1.23 }
3149
3150 CIMQualifierDecl tmp(name, value, scope, flavor, arraySize);
3151 qualifierDecl = CIMQualifierDecl(name, value, scope, flavor, arraySize);
3152 return true;
3153 }
3154
3155 //------------------------------------------------------------------------------
3156 // getMethodElement()
3157 //
3158 // <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|
3159 // PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
3160 // <!ATTLIST METHOD
3161 // %CIMName;
3162 // %CIMType; #IMPLIED
3163 // %ClassOrigin;
3164 // %Propagated;>
3165 //
3166 //------------------------------------------------------------------------------
3167
3168 Boolean XmlReader::getMethodElement(XmlParser& parser, CIMMethod& method)
3169 mike 1.23 {
3170 XmlEntry entry;
3171
3172 if (!testStartTagOrEmptyTag(parser, entry, "METHOD"))
|
3173 kumpf 1.122 return false;
|
3174 mike 1.23
3175 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3176
|
3177 kumpf 1.124 CIMName name = getCimNameAttribute(parser.getLine(), entry, "METHOD");
|
3178 mike 1.23
|
3179 kumpf 1.67 CIMType type;
|
3180 kumpf 1.124 getCimTypeAttribute(parser.getLine(), entry, type, "METHOD");
|
3181 mike 1.23
|
3182 kumpf 1.122 CIMName classOrigin =
|
3183 kumpf 1.124 getClassOriginAttribute(parser.getLine(), entry, "METHOD");
|
3184 mike 1.23
3185 Boolean propagated = getCimBooleanAttribute(
|
3186 kumpf 1.124 parser.getLine(), entry, "METHOD", "PROPAGATED", false, false);
|
3187 mike 1.23
3188 method = CIMMethod(name, type, classOrigin, propagated);
3189
3190 if (!empty)
3191 {
|
3192 kumpf 1.26 // ATTN-RK-P2-20020219: Decoding algorithm must not depend on the
3193 // ordering of qualifiers and parameters.
|
3194 kumpf 1.122 getQualifierElements(parser, method);
|
3195 mike 1.23
|
3196 kumpf 1.122 GetParameterElements(parser, method);
|
3197 mike 1.23
|
3198 kumpf 1.122 expectEndTag(parser, "METHOD");
|
3199 mike 1.23 }
3200
3201 return true;
3202 }
3203
3204 //------------------------------------------------------------------------------
3205 // getClassElement()
3206 //
3207 // <!ELEMENT CLASS (QUALIFIER*,
3208 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
3209 // <!ATTLIST CLASS %CIMName; %SuperClass;>
3210 //
3211 //------------------------------------------------------------------------------
3212
3213 Boolean XmlReader::getClassElement(XmlParser& parser, CIMClass& cimClass)
3214 {
3215 XmlEntry entry;
3216
|
3217 a.dunfey 1.96 if (!testStartTagOrEmptyTag(parser, entry, "CLASS"))
|
3218 kumpf 1.122 return false;
|
3219 mike 1.23
|
3220 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
|
3221 mike 1.23
|
3222 kumpf 1.122 CIMName superClass =
3223 getSuperClassAttribute(parser.getLine(), entry,"CLASS");
|
3224 mike 1.23
3225 cimClass = CIMClass(name, superClass);
3226
|
3227 kumpf 1.122 if (entry.type != XmlEntry::EMPTY_TAG)
3228 {
3229 // Get QUALIFIER elements:
|
3230 a.dunfey 1.97
|
3231 kumpf 1.122 getQualifierElements(parser, cimClass);
|
3232 mike 1.23
|
3233 kumpf 1.122 // Get PROPERTY elements:
|
3234 mike 1.23
|
3235 kumpf 1.122 GetPropertyElements(parser, cimClass);
|
3236 mike 1.23
|
3237 kumpf 1.122 // Get METHOD elements:
|
3238 mike 1.23
|
3239 kumpf 1.122 CIMMethod method;
|
3240 mike 1.23
|
3241 kumpf 1.122 while (getMethodElement(parser, method))
3242 cimClass.addMethod(method);
|
3243 mike 1.23
|
3244 kumpf 1.122 // Get CLASS end tag:
|
3245 mike 1.23
|
3246 kumpf 1.122 expectEndTag(parser, "CLASS");
3247 }
|
3248 mike 1.23
3249 return true;
3250 }
3251
3252 //------------------------------------------------------------------------------
3253 // getInstanceElement()
3254 //
3255 // <!ELEMENT INSTANCE (QUALIFIER*,
3256 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*) >
3257 // <!ATTLIST INSTANCE
3258 // %ClassName;>
3259 //
3260 //------------------------------------------------------------------------------
3261
3262 Boolean XmlReader::getInstanceElement(
|
3263 kumpf 1.122 XmlParser& parser,
|
3264 mike 1.23 CIMInstance& cimInstance)
3265 {
3266 XmlEntry entry;
3267
|
3268 kumpf 1.89 if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE"))
|
3269 kumpf 1.122 return false;
|
3270 mike 1.23
|
3271 kumpf 1.89 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3272
|
3273 mike 1.23 String className = getClassNameAttribute(
|
3274 kumpf 1.122 parser.getLine(), entry, "INSTANCE");
|
3275 mike 1.23
3276 cimInstance = CIMInstance(className);
3277
|
3278 kumpf 1.89 if (!empty)
3279 {
3280 // Get QUALIFIER elements:
3281 getQualifierElements(parser, cimInstance);
3282
3283 // Get PROPERTY elements:
3284 GetPropertyElements(parser, cimInstance);
3285
3286 // Get INSTANCE end tag:
3287 expectEndTag(parser, "INSTANCE");
3288 }
|
3289 mike 1.23
3290 return true;
3291 }
3292
3293 //------------------------------------------------------------------------------
|
3294 mike 1.25 // getNamedInstanceElement()
3295 //
3296 // <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
3297 //
3298 //------------------------------------------------------------------------------
3299
3300 Boolean XmlReader::getNamedInstanceElement(
|
3301 kumpf 1.122 XmlParser& parser,
|
3302 kumpf 1.55 CIMInstance& namedInstance)
|
3303 mike 1.25 {
3304 XmlEntry entry;
3305
3306 if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))
|
3307 kumpf 1.122 return false;
|
3308 mike 1.25
|
3309 kumpf 1.54 CIMObjectPath instanceName;
|
3310 mike 1.25
3311 // Get INSTANCENAME elements:
3312
3313 if (!getInstanceNameElement(parser, instanceName))
3314 {
|
3315 kumpf 1.122 MessageLoaderParms mlParms(
3316 "Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
3317 "expected INSTANCENAME element");
3318 throw XmlValidationError(parser.getLine(), mlParms);
|
3319 mike 1.25 }
3320
3321 // Get INSTANCE elements:
3322
|
3323 kumpf 1.55 if (!getInstanceElement(parser, namedInstance))
|
3324 mike 1.25 {
|
3325 kumpf 1.122 MessageLoaderParms mlParms(
3326 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3327 "expected INSTANCE element");
3328 throw XmlValidationError(parser.getLine(), mlParms);
|
3329 mike 1.25 }
3330
3331 // Get VALUE.NAMEDINSTANCE end tag:
3332
3333 expectEndTag(parser, "VALUE.NAMEDINSTANCE");
3334
|
3335 kumpf 1.55 namedInstance.setPath (instanceName);
|
3336 mike 1.25
3337 return true;
3338 }
3339
3340 //------------------------------------------------------------------------------
|
3341 mike 1.23 //
3342 // getObject()
3343 //
3344 //------------------------------------------------------------------------------
3345
3346 void XmlReader::getObject(XmlParser& parser, CIMClass& x)
3347 {
3348 if (!getClassElement(parser, x))
3349 {
|
3350 kumpf 1.122 MessageLoaderParms mlParms(
3351 "Common.XmlReader.EXPECTED_CLASS_ELEMENT",
3352 "expected CLASS element");
3353 throw XmlValidationError(parser.getLine(), mlParms);
|
3354 mike 1.23 }
3355 }
3356
3357 //------------------------------------------------------------------------------
3358 //
3359 // getObject()
3360 //
3361 //------------------------------------------------------------------------------
3362
3363 void XmlReader::getObject(XmlParser& parser, CIMInstance& x)
3364 {
3365 if (!getInstanceElement(parser, x))
3366 {
|
3367 kumpf 1.122 MessageLoaderParms mlParms(
3368 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3369 "expected INSTANCE element");
3370 throw XmlValidationError(parser.getLine(), mlParms);
|
3371 mike 1.23 }
3372 }
3373
3374 //------------------------------------------------------------------------------
3375 //
3376 // getObject()
3377 //
3378 //------------------------------------------------------------------------------
3379
3380 void XmlReader::getObject(XmlParser& parser, CIMQualifierDecl& x)
3381 {
3382 if (!getQualifierDeclElement(parser, x))
3383 {
|
3384 kumpf 1.122 MessageLoaderParms mlParms(
3385 "Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",
3386 "expected QUALIFIER.DECLARATION element");
3387 throw XmlValidationError(parser.getLine(), mlParms);
|
3388 mike 1.23 }
3389 }
3390
3391 //------------------------------------------------------------------------------
3392 //
3393 // getMessageStartTag()
3394 //
3395 //------------------------------------------------------------------------------
3396
3397 Boolean XmlReader::getMessageStartTag(
|
3398 kumpf 1.122 XmlParser& parser,
|
3399 mike 1.23 String& id,
|
3400 kumpf 1.34 String& protocolVersion)
|
3401 mike 1.23 {
3402 XmlEntry entry;
3403
3404 if (!testStartTag(parser, entry, "MESSAGE"))
|
3405 kumpf 1.122 return false;
|
3406 mike 1.23
3407 // Get MESSAGE.ID:
3408
|
3409 kumpf 1.122 if (!entry.getAttributeValue("ID", id))
3410 {
3411 MessageLoaderParms mlParms(
3412 "Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",
3413 "Invalid or missing MESSAGE.ID attribute");
3414 throw XmlValidationError(parser.getLine(), mlParms);
3415 }
|
3416 humberto 1.85
|
3417 mike 1.23
3418 // Get MESSAGE.PROTOCOLVERSION:
3419
|
3420 kumpf 1.122 if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))
3421 {
3422 MessageLoaderParms mlParms(
3423 "Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",
3424 "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
3425 throw XmlValidationError(parser.getLine(), mlParms);
3426 }
|
3427 humberto 1.85
|
3428 mike 1.23 return true;
3429 }
3430
3431 //------------------------------------------------------------------------------
3432 //
3433 // getIMethodCallStartTag()
3434 //
3435 //------------------------------------------------------------------------------
3436
3437 Boolean XmlReader::getIMethodCallStartTag(
|
3438 kumpf 1.122 XmlParser& parser,
|
3439 mike 1.23 const char*& name)
3440 {
3441 XmlEntry entry;
3442
3443 if (!testStartTag(parser, entry, "IMETHODCALL"))
|
3444 kumpf 1.122 return false;
|
3445 mike 1.23
3446 // Get IMETHODCALL.NAME attribute:
3447
|
3448 humberto 1.85
|
3449 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
3450 {
3451 MessageLoaderParms mlParms(
3452 "Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",
3453 "Missing IMETHODCALL.NAME attribute");
3454 throw XmlValidationError(parser.getLine(), mlParms);
|
3455 humberto 1.85 }
3456
|
3457 mike 1.23
3458 return true;
3459 }
3460
3461 //------------------------------------------------------------------------------
3462 //
3463 // getIMethodResponseStartTag()
3464 //
3465 //------------------------------------------------------------------------------
3466
3467 Boolean XmlReader::getIMethodResponseStartTag(
|
3468 kumpf 1.122 XmlParser& parser,
|
3469 kumpf 1.101 const char*& name,
3470 Boolean& isEmptyTag)
|
3471 mike 1.23 {
3472 XmlEntry entry;
3473
|
3474 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "IMETHODRESPONSE"))
|
3475 kumpf 1.122 return false;
|
3476 mike 1.23
|
3477 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
3478
|
3479 mike 1.23 // Get IMETHODRESPONSE.NAME attribute:
3480
|
3481 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
3482 {
3483 MessageLoaderParms mlParms(
3484 "Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",
3485 "Missing IMETHODRESPONSE.NAME attribute");
3486 throw XmlValidationError(parser.getLine(), mlParms);
|
3487 humberto 1.85 }
3488
|
3489 mike 1.23
3490 return true;
3491 }
3492
3493 //------------------------------------------------------------------------------
3494 //
3495 // getIParamValueTag()
3496 //
3497 //------------------------------------------------------------------------------
3498
3499 Boolean XmlReader::getIParamValueTag(
|
3500 kumpf 1.122 XmlParser& parser,
|
3501 kumpf 1.99 const char*& name,
3502 Boolean& isEmptyTag)
|
3503 mike 1.23 {
3504 XmlEntry entry;
3505
|
3506 kumpf 1.99 if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE"))
|
3507 kumpf 1.122 return false;
|
3508 mike 1.23
|
3509 kumpf 1.99 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
3510
|
3511 mike 1.23 // Get IPARAMVALUE.NAME attribute:
3512
|
3513 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
3514 {
3515 MessageLoaderParms mlParms(
3516 "Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",
3517 "Missing IPARAMVALUE.NAME attribute");
3518 throw XmlValidationError(parser.getLine(), mlParms);
|
3519 humberto 1.85 }
|
3520 mike 1.23
3521 return true;
3522 }
3523
3524 //------------------------------------------------------------------------------
3525 //
|
3526 kumpf 1.99 // rejectNullIParamValue()
3527 //
3528 //------------------------------------------------------------------------------
3529
3530 void XmlReader::rejectNullIParamValue(
|
3531 kumpf 1.122 XmlParser& parser,
|
3532 kumpf 1.99 Boolean isEmptyTag,
3533 const char* paramName)
3534 {
3535 if (isEmptyTag)
3536 {
3537 MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE",
3538 "A null value is not valid for IPARAMVALUE \"$0\".",
3539 paramName);
3540 throw XmlValidationError(parser.getLine(), mlParms);
3541 }
3542 }
3543
3544 //------------------------------------------------------------------------------
3545 //
|
3546 mike 1.23 // getBooleanValueElement()
3547 //
3548 // Get an elements like: "<VALUE>FALSE</VALUE>"
3549 //
3550 //------------------------------------------------------------------------------
3551
3552 Boolean XmlReader::getBooleanValueElement(
|
3553 kumpf 1.122 XmlParser& parser,
|
3554 mike 1.23 Boolean& result,
3555 Boolean required)
3556 {
3557 XmlEntry entry;
3558
3559 if (!testStartTag(parser, entry, "VALUE"))
3560 {
|
3561 kumpf 1.122 if (required)
3562 {
3563 MessageLoaderParms mlParms(
3564 "Common.XmlReader.EXPECTED_VALUE_ELEMENT",
3565 "Expected VALUE element");
3566 throw XmlValidationError(parser.getLine(), mlParms);
3567 }
3568 return false;
|
3569 mike 1.23 }
3570
3571 expectContentOrCData(parser, entry);
3572
|
3573 kumpf 1.72 if (System::strcasecmp(entry.text, "TRUE") == 0)
|
3574 kumpf 1.122 result = true;
|
3575 kumpf 1.72 else if (System::strcasecmp(entry.text, "FALSE") == 0)
|
3576 kumpf 1.122 result = false;
3577 else
3578 {
3579 MessageLoaderParms mlParms(
3580 "Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",
3581 "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
3582 throw XmlSemanticError(parser.getLine(), mlParms);
|
3583 humberto 1.85 }
|
3584 mike 1.23
3585 expectEndTag(parser, "VALUE");
3586
3587 return true;
3588 }
3589
3590 //------------------------------------------------------------------------------
3591 //
|
3592 kumpf 1.95 // DMTF CR Pending
|
3593 mike 1.23 //
|
3594 kumpf 1.95 // <!ELEMENT ERROR (INSTANCE*)>
|
3595 kumpf 1.122 // <!ATTLIST ERROR
|
3596 mike 1.23 // CODE CDATA #REQUIRED
3597 // DESCRIPTION CDATA #IMPLIED>
3598 //
3599 //------------------------------------------------------------------------------
3600
3601 Boolean XmlReader::getErrorElement(
|
3602 kumpf 1.122 XmlParser& parser,
|
3603 kumpf 1.50 CIMException& cimException,
|
3604 mike 1.23 Boolean required)
3605 {
3606 XmlEntry entry;
3607
3608 if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))
3609 {
|
3610 kumpf 1.122 if (required)
3611 {
3612 MessageLoaderParms mlParms(
3613 "Common.XmlReader.EXPECTED_ERROR_ELEMENT",
3614 "Expected ERROR element");
3615 throw XmlValidationError(parser.getLine(), mlParms);
3616 }
3617 return false;
|
3618 mike 1.23 }
3619
3620 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3621
3622 // Get ERROR.CODE
3623
3624 Uint32 tmpCode;
3625
|
3626 kumpf 1.122 if (!entry.getAttributeValue("CODE", tmpCode))
3627 {
3628 MessageLoaderParms mlParms(
3629 "Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",
3630 "missing ERROR.CODE attribute");
3631 throw XmlValidationError(parser.getLine(), mlParms);
|
3632 humberto 1.85 }
|
3633 mike 1.23
|
3634 kumpf 1.50 // Get ERROR.DESCRIPTION:
|
3635 mike 1.23
|
3636 kumpf 1.50 String tmpDescription;
|
3637 mike 1.23
|
3638 kumpf 1.50 entry.getAttributeValue("DESCRIPTION", tmpDescription);
|
3639 mike 1.23
|
3640 kumpf 1.122 cimException =
3641 PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);
|
3642 karl 1.121
|
3643 mike 1.23 if (!empty)
|
3644 kumpf 1.95 {
|
3645 kumpf 1.122 CIMInstance instance;
|
3646 karl 1.121
|
3647 kumpf 1.122 while (getInstanceElement(parser, instance))
3648 {
3649 cimException.addError(instance);
3650 }
|
3651 kumpf 1.95
|
3652 kumpf 1.122 expectEndTag(parser, "ERROR");
|
3653 kumpf 1.95 }
|
3654 mike 1.23
3655 return true;
3656 }
3657
3658 //------------------------------------------------------------------------------
|
3659 kumpf 1.48 // getValueObjectElement()
3660 //
3661 // <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>
3662 //
3663 //------------------------------------------------------------------------------
3664
3665 Boolean XmlReader::getValueObjectElement(
|
3666 kumpf 1.122 XmlParser& parser,
|
3667 kumpf 1.48 CIMObject& object)
3668 {
3669 XmlEntry entry;
3670
3671 if (!testStartTag(parser, entry, "VALUE.OBJECT"))
|
3672 kumpf 1.122 return false;
|
3673 kumpf 1.48
3674 CIMInstance cimInstance;
3675 CIMClass cimClass;
3676
3677 if (XmlReader::getInstanceElement(parser, cimInstance))
3678 {
|
3679 kumpf 1.122 object = CIMObject(cimInstance);
|
3680 kumpf 1.48 }
|
3681 dave.sudlik 1.104 else if (XmlReader::getClassElement(parser, cimClass))
|
3682 kumpf 1.48 {
|
3683 kumpf 1.122 object = CIMObject(cimClass);
|
3684 kumpf 1.48 }
3685 else
3686 {
|
3687 kumpf 1.122 MessageLoaderParms mlParms(
3688 "Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
3689 "Expected INSTANCE or CLASS element");
3690 throw XmlValidationError(parser.getLine(), mlParms);
|
3691 kumpf 1.48 }
3692
3693 expectEndTag(parser, "VALUE.OBJECT");
3694
3695 return true;
3696 }
3697
3698 //------------------------------------------------------------------------------
3699 // getValueObjectWithPathElement()
|
3700 mike 1.23 //
3701 // <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
3702 //
3703 //------------------------------------------------------------------------------
3704
|
3705 kumpf 1.48 Boolean XmlReader::getValueObjectWithPathElement(
|
3706 kumpf 1.122 XmlParser& parser,
|
3707 kumpf 1.57 CIMObject& objectWithPath)
|
3708 mike 1.23 {
3709 XmlEntry entry;
3710
3711 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))
|
3712 kumpf 1.122 return false;
|
3713 mike 1.23
|
3714 kumpf 1.54 CIMObjectPath reference;
|
3715 mike 1.23 Boolean isInstance = false;
3716
3717 if (XmlReader::getInstancePathElement(parser, reference))
|
3718 kumpf 1.122 isInstance = true;
|
3719 mike 1.23 else if (!XmlReader::getClassPathElement(parser, reference))
3720 {
|
3721 kumpf 1.122 MessageLoaderParms mlParms(
3722 "Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
3723 "Expected INSTANCEPATH or CLASSPATH element");
3724 throw XmlValidationError(parser.getLine(), mlParms);
|
3725 mike 1.23 }
3726
3727 if (isInstance)
3728 {
|
3729 kumpf 1.122 CIMInstance cimInstance;
|
3730 mike 1.23
|
3731 kumpf 1.122 if (!XmlReader::getInstanceElement(parser, cimInstance))
3732 {
3733 MessageLoaderParms mlParms(
3734 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3735 "Expected INSTANCE element");
3736 throw XmlValidationError(parser.getLine(), mlParms);
3737 }
3738 objectWithPath = CIMObject (cimInstance);
|
3739 kumpf 1.57 objectWithPath.setPath (reference);
|
3740 mike 1.23 }
3741 else
3742 {
|
3743 kumpf 1.122 CIMClass cimClass;
|
3744 mike 1.23
|
3745 kumpf 1.122 if (!XmlReader::getClassElement(parser, cimClass))
3746 {
3747 MessageLoaderParms mlParms(
3748 "Common.XmlReader.EXPECTED_CLASS_ELEMENT",
3749 "Expected CLASS element");
3750 throw XmlValidationError(parser.getLine(), mlParms);
3751 }
3752 objectWithPath = CIMObject (cimClass);
|
3753 kumpf 1.57 objectWithPath.setPath (reference);
|
3754 mike 1.23 }
3755
3756 expectEndTag(parser, "VALUE.OBJECTWITHPATH");
3757
3758 return true;
|
3759 kumpf 1.48 }
3760
3761 //------------------------------------------------------------------------------
3762 // getValueObjectWithLocalPathElement()
3763 //
3764 // <!ELEMENT VALUE.OBJECTWITHLOCALPATH
3765 // ((LOCALCLASSPATH,CLASS)|(LOCALINSTANCEPATH,INSTANCE))>
3766 //
3767 //------------------------------------------------------------------------------
3768
3769 Boolean XmlReader::getValueObjectWithLocalPathElement(
|
3770 kumpf 1.122 XmlParser& parser,
|
3771 kumpf 1.57 CIMObject& objectWithPath)
|
3772 kumpf 1.48 {
3773 XmlEntry entry;
3774
3775 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))
|
3776 kumpf 1.122 return false;
|
3777 kumpf 1.48
|
3778 kumpf 1.54 CIMObjectPath reference;
|
3779 kumpf 1.48 Boolean isInstance = false;
3780
3781 if (XmlReader::getLocalInstancePathElement(parser, reference))
|
3782 kumpf 1.122 isInstance = true;
|
3783 kumpf 1.48 else if (!XmlReader::getLocalClassPathElement(parser, reference))
3784 {
|
3785 kumpf 1.122 MessageLoaderParms mlParms(
3786 "Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
3787 MISSING_ELEMENT_LOCALPATH);
3788 throw XmlValidationError(parser.getLine(), mlParms);
|
3789 kumpf 1.48 }
3790
3791 if (isInstance)
3792 {
|
3793 kumpf 1.122 CIMInstance cimInstance;
|
3794 kumpf 1.48
|
3795 kumpf 1.122 if (!XmlReader::getInstanceElement(parser, cimInstance))
3796 {
3797 MessageLoaderParms mlParms(
3798 "Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3799 "Expected INSTANCE element");
3800 throw XmlValidationError(parser.getLine(), mlParms);
3801 }
3802 objectWithPath = CIMObject (cimInstance);
3803 objectWithPath.setPath (reference);
|
3804 kumpf 1.48 }
3805 else
3806 {
|
3807 kumpf 1.122 CIMClass cimClass;
|
3808 kumpf 1.48
|
3809 kumpf 1.122 if (!XmlReader::getClassElement(parser, cimClass))
3810 {
3811 MessageLoaderParms mlParms(
3812 "Common.XmlReader.EXPECTED_CLASS_ELEMENT",
3813 "Expected CLASS element");
3814 throw XmlValidationError(parser.getLine(), mlParms);
3815 }
3816 objectWithPath = CIMObject (cimClass);
3817 objectWithPath.setPath (reference);
|
3818 kumpf 1.48 }
3819
3820 expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");
3821
3822 return true;
3823 }
3824
3825 //------------------------------------------------------------------------------
3826 // getObjectArray()
3827 //
3828 // <object>
3829 // (VALUE.OBJECT|VALUE.OBJECTWITHLOCALPATH|VALUE.OBJECTWITHPATH)
3830 //
3831 //------------------------------------------------------------------------------
3832
3833 void XmlReader::getObjectArray(
|
3834 kumpf 1.122 XmlParser& parser,
|
3835 kumpf 1.57 Array<CIMObject>& objectArray)
|
3836 kumpf 1.48 {
3837 CIMObject object;
|
3838 kumpf 1.57 CIMObject objectWithPath;
|
3839 kumpf 1.48
3840 objectArray.clear();
3841
3842 if (getValueObjectElement(parser, object))
3843 {
|
3844 kumpf 1.57 objectArray.append(object);
|
3845 kumpf 1.48 while (getValueObjectElement(parser, object))
|
3846 kumpf 1.57 objectArray.append(object);
|
3847 kumpf 1.48 }
3848 else if (getValueObjectWithPathElement(parser, objectWithPath))
3849 {
3850 objectArray.append(objectWithPath);
3851 while (getValueObjectWithPathElement(parser, objectWithPath))
3852 objectArray.append(objectWithPath);
3853 }
3854 else if (getValueObjectWithLocalPathElement(parser, objectWithPath))
3855 {
3856 objectArray.append(objectWithPath);
3857 while (getValueObjectWithLocalPathElement(parser, objectWithPath))
3858 objectArray.append(objectWithPath);
3859 }
|
3860 mike 1.23 }
3861
3862 //------------------------------------------------------------------------------
3863 //
3864 // <objectName>: (CLASSNAME|INSTANCENAME)
3865 //
3866 //------------------------------------------------------------------------------
3867
|
3868 karl 1.148 // Returns true if ClassNameElement or false if InstanceNameElement
3869 // Parse errors always throw exception
|
3870 mike 1.23 Boolean XmlReader::getObjectNameElement(
|
3871 kumpf 1.122 XmlParser& parser,
|
3872 kumpf 1.54 CIMObjectPath& objectName)
|
3873 mike 1.23 {
|
3874 kumpf 1.74 CIMName className;
|
3875 mike 1.23
3876 if (getClassNameElement(parser, className, false))
3877 {
|
3878 kumpf 1.122 objectName.set(String(), CIMNamespaceName(), className);
|
3879 karl 1.148
3880 // Return flag indicating this is ClassNameElement
|
3881 kumpf 1.122 return true;
|
3882 mike 1.23 }
|
3883 kumpf 1.128
3884 if (!getInstanceNameElement(parser, objectName))
|
3885 mike 1.23 {
|
3886 kumpf 1.122 MessageLoaderParms mlParms(
3887 "Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",
3888 "Expected CLASSNAME or INSTANCENAME element");
3889 throw XmlValidationError(parser.getLine(), mlParms);
|
3890 mike 1.23 }
3891
|
3892 karl 1.148 // Return flag indicating this is InstanceNameElement
3893 return false;
|
3894 mike 1.23 }
3895
3896 //------------------------------------------------------------------------------
3897 //
3898 // <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>
3899 //
3900 //------------------------------------------------------------------------------
3901
3902 Boolean XmlReader::getObjectPathElement(
|
3903 kumpf 1.122 XmlParser& parser,
|
3904 kumpf 1.54 CIMObjectPath& objectPath)
|
3905 mike 1.23 {
3906 XmlEntry entry;
3907
3908 if (!testStartTag(parser, entry, "OBJECTPATH"))
|
3909 kumpf 1.122 return false;
|
3910 mike 1.23
|
3911 kumpf 1.128 if (!getClassPathElement(parser, objectPath) &&
3912 !getInstancePathElement(parser, objectPath))
|
3913 mike 1.23 {
|
3914 kumpf 1.122 MessageLoaderParms mlParms(
3915 "Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
3916 "expected INSTANCEPATH or CLASSPATH element");
3917 throw XmlValidationError(parser.getLine(), mlParms);
|
3918 mike 1.23 }
3919
|
3920 kumpf 1.128 expectEndTag(parser, "OBJECTPATH");
3921 return true;
|
3922 mike 1.25 }
3923
3924 //------------------------------------------------------------------------------
3925 //
3926 // getEMethodCallStartTag()
3927 //
3928 //------------------------------------------------------------------------------
3929
3930 Boolean XmlReader::getEMethodCallStartTag(
|
3931 kumpf 1.122 XmlParser& parser,
|
3932 mike 1.25 const char*& name)
3933 {
3934 XmlEntry entry;
3935
3936 if (!testStartTag(parser, entry, "EXPMETHODCALL"))
|
3937 kumpf 1.122 return false;
|
3938 mike 1.25
3939 // Get EXPMETHODCALL.NAME attribute:
3940
|
3941 humberto 1.85
|
3942 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
3943 {
3944 MessageLoaderParms mlParms(
3945 "Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",
3946 "Missing EXPMETHODCALL.NAME attribute");
3947 throw XmlValidationError(parser.getLine(), mlParms);
3948 }
|
3949 mike 1.25
3950 return true;
3951 }
3952
3953 //------------------------------------------------------------------------------
3954 //
3955 // getEMethodResponseStartTag()
3956 //
3957 //------------------------------------------------------------------------------
3958
3959 Boolean XmlReader::getEMethodResponseStartTag(
|
3960 kumpf 1.122 XmlParser& parser,
|
3961 kumpf 1.101 const char*& name,
3962 Boolean& isEmptyTag)
|
3963 mike 1.25 {
3964 XmlEntry entry;
3965
|
3966 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "EXPMETHODRESPONSE"))
|
3967 kumpf 1.122 return false;
|
3968 mike 1.25
|
3969 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
3970
|
3971 mike 1.25 // Get EXPMETHODRESPONSE.NAME attribute:
3972
|
3973 humberto 1.85
|
3974 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
3975 {
3976 MessageLoaderParms mlParms(
3977 "Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",
3978 "Missing EXPMETHODRESPONSE.NAME attribute");
3979 throw XmlValidationError(parser.getLine(), mlParms);
3980 }
|
3981 mike 1.25
3982 return true;
3983 }
3984
3985 //------------------------------------------------------------------------------
3986 //
|
3987 kumpf 1.83 // getEParamValueTag()
3988 //
3989 //------------------------------------------------------------------------------
3990
3991 Boolean XmlReader::getEParamValueTag(
|
3992 kumpf 1.122 XmlParser& parser,
|
3993 kumpf 1.83 const char*& name)
3994 {
3995 XmlEntry entry;
3996
3997 if (!testStartTag(parser, entry, "EXPPARAMVALUE"))
|
3998 kumpf 1.122 return false;
|
3999 kumpf 1.83
4000 // Get EXPPARAMVALUE.NAME attribute:
4001
|
4002 humberto 1.85
|
4003 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4004 {
4005 MessageLoaderParms mlParms(
4006 "Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",
4007 "Missing EXPPARAMVALUE.NAME attribute");
4008 throw XmlValidationError(parser.getLine(), mlParms);
|
4009 humberto 1.85 }
4010
4011
|
4012 kumpf 1.83
4013 return true;
4014 }
4015
4016 //------------------------------------------------------------------------------
4017 //
|
4018 mike 1.25 // getMethodCallStartTag()
4019 //
4020 //------------------------------------------------------------------------------
4021
4022 Boolean XmlReader::getMethodCallStartTag(
|
4023 kumpf 1.122 XmlParser& parser,
|
4024 mike 1.25 const char*& name)
4025 {
4026 XmlEntry entry;
4027
4028 if (!testStartTag(parser, entry, "METHODCALL"))
|
4029 kumpf 1.122 return false;
|
4030 mike 1.25
4031 // Get METHODCALL.NAME attribute:
4032
|
4033 humberto 1.85
|
4034 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4035 {
4036 MessageLoaderParms mlParms(
4037 "Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",
4038 "Missing METHODCALL.NAME attribute");
4039 throw XmlValidationError(parser.getLine(), mlParms);
|
4040 humberto 1.85 }
4041
|
4042 mike 1.25
4043 return true;
4044 }
4045
4046 //------------------------------------------------------------------------------
4047 //
4048 // getMethodResponseStartTag()
4049 //
4050 //------------------------------------------------------------------------------
4051
4052 Boolean XmlReader::getMethodResponseStartTag(
|
4053 kumpf 1.122 XmlParser& parser,
|
4054 kumpf 1.101 const char*& name,
4055 Boolean& isEmptyTag)
|
4056 mike 1.25 {
4057 XmlEntry entry;
4058
|
4059 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "METHODRESPONSE"))
|
4060 kumpf 1.122 return false;
|
4061 mike 1.25
|
4062 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
4063
|
4064 mike 1.25 // Get METHODRESPONSE.NAME attribute:
4065
|
4066 humberto 1.85
|
4067 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4068 {
4069 MessageLoaderParms mlParms(
4070 "Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",
4071 "Missing METHODRESPONSE.NAME attribute");
4072 throw XmlValidationError(parser.getLine(), mlParms);
|
4073 humberto 1.85 }
|
4074 mike 1.25
4075 return true;
4076 }
4077
4078 //------------------------------------------------------------------------------
4079 //
|
4080 kumpf 1.26 // getParamValueElement()
4081 //
4082 // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
4083 // <!ATTLIST PARAMVALUE
4084 // %CIMName;
|
4085 dave.sudlik 1.109 // %EmbeddedObject; #IMPLIED
|
4086 kumpf 1.26 // %ParamType;>
|
4087 mike 1.25 //
4088 //------------------------------------------------------------------------------
4089
|
4090 kumpf 1.26 Boolean XmlReader::getParamValueElement(
|
4091 kumpf 1.122 XmlParser& parser,
|
4092 kumpf 1.26 CIMParamValue& paramValue)
|
4093 mike 1.25 {
4094 XmlEntry entry;
|
4095 kumpf 1.26 const char* name;
|
4096 marek 1.100 CIMType type=CIMTYPE_BOOLEAN;
|
4097 kumpf 1.26 CIMValue value;
|
4098 mike 1.25
|
4099 kumpf 1.26 if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))
|
4100 kumpf 1.122 return false;
|
4101 mike 1.25
|
4102 kumpf 1.26 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
4103
4104 // Get PARAMVALUE.NAME attribute:
|
4105 mike 1.25
|
4106 kumpf 1.122 if (!entry.getAttributeValue("NAME", name))
4107 {
4108 MessageLoaderParms mlParms(
4109 "Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",
4110 "Missing PARAMVALUE.NAME attribute");
4111 throw XmlValidationError(parser.getLine(), mlParms);
4112 }
|
4113 humberto 1.85
|
4114 karl 1.129 // Get PROPERTY.EmbeddedObject
|
4115 humberto 1.85
|
4116 thilo.boehm 1.131 EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(
|
4117 kumpf 1.122 parser.getLine(), entry, "PARAMVALUE");
|
4118 kumpf 1.26
4119 // Get PARAMVALUE.PARAMTYPE attribute:
4120
|
4121 kumpf 1.67 Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,
4122 "PARAMVALUE", "PARAMTYPE", false);
|
4123 kumpf 1.26
|
4124 kumpf 1.113 if (empty)
4125 {
4126 gotType = false; // Can't distinguish array and non-array types
4127 }
4128 else
|
4129 kumpf 1.26 {
4130 // Parse VALUE.REFERENCE and VALUE.REFARRAY type
|
4131 kumpf 1.67 if ( (type == CIMTYPE_REFERENCE) || !gotType )
|
4132 kumpf 1.26 {
|
4133 dave.sudlik 1.109 CIMObjectPath reference;
|
4134 kumpf 1.122 if (XmlReader::getValueReferenceElement(parser, reference))
4135 {
4136 value.set(reference);
4137 type = CIMTYPE_REFERENCE;
|
4138 kumpf 1.67 gotType = true;
|
4139 kumpf 1.122 }
|
4140 kumpf 1.28 else if (XmlReader::getValueReferenceArrayElement(parser, value))
|
4141 kumpf 1.122 {
4142 type = CIMTYPE_REFERENCE;
|
4143 kumpf 1.67 gotType = true;
|
4144 kumpf 1.122 }
|
4145 kumpf 1.139 else
|
4146 kumpf 1.127 {
4147 gotType = false; // Can't distinguish array and non-array types
4148 }
|
4149 kumpf 1.26 }
4150
4151 // Parse non-reference value
|
4152 kumpf 1.61 if ( type != CIMTYPE_REFERENCE )
|
4153 kumpf 1.26 {
|
4154 kumpf 1.67 CIMType effectiveType;
4155 if (!gotType)
|
4156 kumpf 1.122 {
4157 // If we don't know what type the value is, read it as a String
4158 effectiveType = CIMTYPE_STRING;
4159 }
|
4160 kumpf 1.67 else
|
4161 kumpf 1.122 {
4162 effectiveType = type;
4163 }
|
4164 dave.sudlik 1.109
|
4165 karl 1.129 // If the EmbeddedObject attribute is present with value "object"
|
4166 dave.sudlik 1.109 // then
4167 // Convert the EmbeddedObject-encoded string into a CIMObject
|
4168 thilo.boehm 1.131 if (embeddedObject != NO_EMBEDDED_OBJECT)
|
4169 a.dunfey 1.118 {
|
4170 karl 1.129 // The EmbeddedObject attribute is only valid on Parameters
|
4171 kumpf 1.122 // of type string
|
4172 a.dunfey 1.118 // The type must have been specified.
4173 if (gotType && (type == CIMTYPE_STRING))
4174 {
|
4175 thilo.boehm 1.131 if (embeddedObject == EMBEDDED_OBJECT_ATTR)
|
4176 kumpf 1.122 // Used below by getValueElement() or
4177 // getValueArrayElement()
4178 effectiveType = CIMTYPE_OBJECT;
|
4179 a.dunfey 1.118 else
|
4180 kumpf 1.122 effectiveType = CIMTYPE_INSTANCE;
|
4181 a.dunfey 1.118 }
4182 else
4183 {
|
4184 kumpf 1.122 MessageLoaderParms mlParms(
4185 "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
|
4186 karl 1.129 "The EmbeddedObject attribute is only valid on "
|
4187 kumpf 1.122 "string types.");
|
4188 a.dunfey 1.118 throw XmlValidationError(parser.getLine(), mlParms);
4189 }
4190 }
|
4191 kumpf 1.122
4192 if (!XmlReader::getValueArrayElement(parser, effectiveType, value)
4193 && !XmlReader::getValueElement(parser, effectiveType, value))
|
4194 dave.sudlik 1.109 {
|
4195 kumpf 1.113 gotType = false; // Can't distinguish array and non-array types
4196 value.clear(); // Isn't necessary; should already be cleared
|
4197 dave.sudlik 1.109 }
|
4198 kumpf 1.26 }
4199
4200 expectEndTag(parser, "PARAMVALUE");
4201 }
4202
|
4203 kumpf 1.67 paramValue = CIMParamValue(name, value, gotType);
|
4204 kumpf 1.27
4205 return true;
4206 }
4207
4208 //------------------------------------------------------------------------------
4209 //
4210 // getReturnValueElement()
4211 //
4212 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
4213 // <!ATTLIST RETURNVALUE
|
4214 dave.sudlik 1.109 // %EmbeddedObject; #IMPLIED
|
4215 kumpf 1.27 // %ParamType;>
4216 //
4217 //------------------------------------------------------------------------------
4218
4219 Boolean XmlReader::getReturnValueElement(
|
4220 kumpf 1.122 XmlParser& parser,
|
4221 kumpf 1.27 CIMValue& returnValue)
4222 {
4223 XmlEntry entry;
4224 CIMType type;
4225 CIMValue value;
4226
4227 if (!testStartTag(parser, entry, "RETURNVALUE"))
|
4228 kumpf 1.122 return false;
|
4229 kumpf 1.27
|
4230 karl 1.129 // Get PROPERTY.EmbeddedObject
|
4231 dave.sudlik 1.109
|
4232 thilo.boehm 1.131 EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(
|
4233 kumpf 1.122 parser.getLine(), entry, "RETURNVALUE");
|
4234 dave.sudlik 1.109
|
4235 kumpf 1.27 // Get RETURNVALUE.PARAMTYPE attribute:
4236 // NOTE: Array type return values are not allowed (2/20/02)
4237
|
4238 kumpf 1.67 Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,
4239 "RETURNVALUE", "PARAMTYPE", false);
|
4240 kumpf 1.27
4241 // Parse VALUE.REFERENCE type
|
4242 kumpf 1.67 if ( (type == CIMTYPE_REFERENCE) || !gotType )
|
4243 kumpf 1.27 {
|
4244 kumpf 1.54 CIMObjectPath reference;
|
4245 kumpf 1.27 if (XmlReader::getValueReferenceElement(parser, reference))
4246 {
4247 returnValue.set(reference);
|
4248 kumpf 1.61 type = CIMTYPE_REFERENCE;
|
4249 kumpf 1.67 gotType = true;
|
4250 kumpf 1.27 }
|
4251 kumpf 1.61 else if (type == CIMTYPE_REFERENCE)
|
4252 kumpf 1.27 {
|
4253 kumpf 1.122 MessageLoaderParms mlParms(
4254 "Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",
4255 "expected VALUE.REFERENCE element");
4256 throw XmlValidationError(parser.getLine(), mlParms);
|
4257 kumpf 1.27 }
4258 }
4259
4260 // Parse non-reference return value
|
4261 kumpf 1.61 if ( type != CIMTYPE_REFERENCE )
|
4262 kumpf 1.27 {
|
4263 kumpf 1.67 if (!gotType)
|
4264 kumpf 1.27 {
|
4265 kumpf 1.67 // If we don't know what type the value is, read it as a String
|
4266 kumpf 1.61 type = CIMTYPE_STRING;
|
4267 kumpf 1.27 }
|
4268 thilo.boehm 1.131 if (embeddedObject != NO_EMBEDDED_OBJECT)
|
4269 a.dunfey 1.118 {
4270 if (gotType && (type == CIMTYPE_STRING))
4271 {
|
4272 thilo.boehm 1.131 if (embeddedObject == EMBEDDED_OBJECT_ATTR)
|
4273 kumpf 1.122 // Used below by getValueElement() or getValueArrayElement()
4274 type = CIMTYPE_OBJECT;
|
4275 a.dunfey 1.118 else
4276 type = CIMTYPE_INSTANCE;
4277 }
4278 else
4279 {
|
4280 kumpf 1.122 MessageLoaderParms mlParms(
4281 "Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
|
4282 karl 1.129 "The EmbeddedObject attribute is only valid on string "
|
4283 kumpf 1.122 "types.");
|
4284 a.dunfey 1.118 throw XmlValidationError(parser.getLine(), mlParms);
4285 }
4286 }
|
4287 kumpf 1.27 if ( !XmlReader::getValueElement(parser, type, returnValue) )
4288 {
|
4289 kumpf 1.122 MessageLoaderParms mlParms(
4290 "Common.XmlReader.EXPECTED_VALUE_ELEMENT",
4291 "expected VALUE element");
4292 throw XmlValidationError(parser.getLine(), mlParms);
|
4293 kumpf 1.27 }
4294 }
4295
4296 expectEndTag(parser, "RETURNVALUE");
|
4297 mike 1.25
4298 return true;
|
4299 mike 1.23 }
4300
|
4301 karl 1.123 //-----------------------------------------------------------------------------
4302 //
4303 // The following is a common set of version tests used by the different
4304 // Pegasus Request and Response Decoders
|
4305 martin 1.137 //
|
4306 karl 1.123 //------------------------------------------------------------------------------
4307 //
4308 // isSupportedCIMVersion()
4309 // tests for valid CIMVersion number
4310 //
4311 // Reject cimVersion not in 2.[0-9]+
|
4312 martin 1.137 //
|
4313 karl 1.123 // CIMXML Secification, Version 2.2 Final, Sect 3.2.1.1
|
4314 kumpf 1.139 // The CIMVERSION attribute defines the version of the CIM Specification to
4315 // which the XML Document conforms. It MUST be in the form of "M.N". Where
4316 // M is the Major Version of the specification in numeric form and N is the
4317 // minor version of the specification in numeric form. For example, "2.0",
4318 // "2.1". Implementations must only validate the major version as all minor
4319 // versions are backward compatible. Implementations may look at the minor
4320 // version to determine additional capabilites.
|
4321 karl 1.123 //
4322 //------------------------------------------------------------------------------
4323 Boolean XmlReader::isSupportedCIMVersion(
4324 const char* cimVersion)
4325 {
4326 Boolean cimVersionAccepted = false;
4327 //printf("testCIMVersion %s \n", cimVersion);
4328 if ((cimVersion[0] == '2') &&
4329 (cimVersion[1] == '.') &&
4330 (cimVersion[2] != 0))
4331 {
4332 // Verify that all characters after the '.' are digits
4333 Uint32 index = 2;
4334 while (isdigit(cimVersion[index]))
4335 {
4336 index++;
4337 }
4338
4339 if (cimVersion[index] == 0)
4340 {
4341 cimVersionAccepted = true;
4342 karl 1.123 }
4343 }
4344 return cimVersionAccepted;
4345 }
4346
4347 //------------------------------------------------------------------------------
4348 //
4349 // isSupportedProtocolVersion()
4350 // tests for valid ProtocolVersion number
4351 //
4352 // Reject ProtocolVersion not 1.[0-9]
4353 //
4354 // cimxml spec 2.2 Final Section 3261
4355 // The PROTOCOLVERSION attribute defines the version of the CIM Operations to
4356 // which this message conforms. It MUST be in the form of "M.N". Where M is
4357 // the Major Version of the specification in numeric form and N is the minor
4358 // version of the specification in numeric form. For example, "1.0", "1.1".
4359 // Implementations must only validate the major version as all minor versions
4360 // are backward compatible. Implementations may look at the minor version to
4361 // determine additional capabilites.
|
4362 martin 1.137 //
|
4363 karl 1.123 //------------------------------------------------------------------------------
4364 Boolean XmlReader::isSupportedProtocolVersion(
4365 const String& protocolVersion)
4366 {
4367 Boolean protocolVersionAccepted = false;
4368
4369 //cout << "testProtocolVersion " << protocolVersion << endl;
4370 if ((protocolVersion.size() >= 3) &&
4371 (protocolVersion[0] == '1') &&
4372 (protocolVersion[1] == '.'))
4373 {
4374 // Verify that all characters after the '.' are digits
4375 Uint32 index = 2;
4376 while ((index < protocolVersion.size()) &&
4377 (protocolVersion[index] >= '0') &&
4378 (protocolVersion[index] <= '9'))
4379 {
4380 index++;
4381 }
4382
4383 if (index == protocolVersion.size())
4384 karl 1.123 {
4385 protocolVersionAccepted = true;
4386 }
4387 }
4388 return protocolVersionAccepted;
4389 }
4390
4391 //------------------------------------------------------------------------------
4392 //
4393 // isSupportedDTDVersion()
4394 // Tests for Valid dtdVersion number
4395 // We accept DTD version 2.[0-9]+ (see Bugzilla 1556)//
|
4396 martin 1.137 //
|
4397 karl 1.123 // CIM/XML Specification, V 2.2 Final, Section 3.2.1.1
|
4398 kumpf 1.139 // The DTDVERSION attribute defines the version of the CIM XML Mapping to
4399 // which the XML Document conforms. It MUST be in the form of "M.N". Where
4400 // M is the Major Version of the specification in numeric form and N is the
4401 // minor version of the specification in numeric form. For example, "2.0",
4402 // "2.1". Implementations must only validate the major version as all minor
4403 // versions are backward compatible. Implementations may look at the minor
4404 // version to determine additional capabilites.
|
4405 karl 1.123 //
4406 //------------------------------------------------------------------------------
4407 Boolean XmlReader::isSupportedDTDVersion(
4408 const char* dtdVersion)
4409 {
4410 Boolean dtdVersionAccepted = false;
4411
4412 //printf("testDTDVersion %s \n", dtdVersion);
4413 if ((dtdVersion[0] == '2') &&
4414 (dtdVersion[1] == '.') &&
4415 (dtdVersion[2] != 0))
4416 {
4417 // Verify that all characters after the '.' are digits
4418 Uint32 index = 2;
4419 while (isdigit(dtdVersion[index]))
4420 {
4421 index++;
4422 }
4423
4424 if (dtdVersion[index] == 0)
4425 {
4426 karl 1.123 dtdVersionAccepted = true;
4427 }
4428 }
4429 return dtdVersionAccepted;
4430 }
|
4431 mike 1.23 PEGASUS_NAMESPACE_END
|
Return to
XmlReader.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common