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