1 mike 1.25 //%/////////////////////////////////////////////////////////////////////////////
|
2 mike 1.23 //
|
3 mike 1.25 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,
4 // The Open Group, Tivoli Systems
|
5 mike 1.23 //
6 // Permission is hereby granted, free of charge, to any person obtaining a copy
7 // 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 // 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 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
14 // 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 // 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 // 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 <cassert>
34 #include <cctype>
35 #include <cstdio>
36 #include <cstdlib>
|
37 ramnath 1.46 #if defined(PEGASUS_OS_TYPE_UNIX)
|
38 mday 1.45 #include <errno.h>
39 #endif
|
40 mike 1.23 #include "CIMName.h"
41 #include "XmlReader.h"
42 #include "XmlWriter.h"
43 #include "CIMQualifier.h"
44 #include "CIMQualifierDecl.h"
45 #include "CIMClass.h"
46 #include "CIMInstance.h"
47 #include "CIMObject.h"
|
48 mike 1.25 #include "CIMParamValue.h"
|
49 mike 1.23
|
50 mike 1.25 PEGASUS_USING_STD;
|
51 mike 1.23 PEGASUS_NAMESPACE_BEGIN
52
53 static const Uint32 MESSAGE_SIZE = 128;
54
55 //------------------------------------------------------------------------------
56 //
|
57 kumpf 1.49 // getXmlDeclaration()
58 //
59 // <?xml version="1.0" encoding="utf-8"?>
|
60 mike 1.23 //
61 //------------------------------------------------------------------------------
62
|
63 kumpf 1.49 void XmlReader::getXmlDeclaration(
|
64 mike 1.23 XmlParser& parser,
|
65 kumpf 1.49 const char*& xmlVersion,
66 const char*& xmlEncoding)
|
67 mike 1.23 {
|
68 kumpf 1.49 XmlEntry entry;
69
|
70 mike 1.23 if (!parser.next(entry) ||
71 entry.type != XmlEntry::XML_DECLARATION ||
72 strcmp(entry.text, "xml") != 0)
73 {
74 throw XmlValidationError(parser.getLine(),
75 "Expected <?xml ... ?> style declaration");
|
76 kumpf 1.49 }
77
78 if (!entry.getAttributeValue("version", xmlVersion))
79 throw XmlValidationError(
80 parser.getLine(), "missing xml.version attribute");
81
82 if (!entry.getAttributeValue("encoding", xmlEncoding))
83 {
84 // ATTN-RK-P3-20020403: Is there a default encoding?
|
85 mike 1.23 }
86 }
87
88 //------------------------------------------------------------------------------
89 //
|
90 mike 1.25 // testXmlDeclaration ()
91 //
92 //------------------------------------------------------------------------------
93
94 Boolean XmlReader::testXmlDeclaration (
95 XmlParser& parser,
96 XmlEntry& entry)
97 {
98 if (!parser.next (entry) ||
99 entry.type != XmlEntry::XML_DECLARATION ||
100 strcmp (entry.text, "xml") != 0)
101 {
102 parser.putBack (entry);
103 return false;
104 }
105
106 return true;
107 }
108
109 //------------------------------------------------------------------------------
110 //
|
111 mike 1.23 // expectStartTag()
112 //
113 //------------------------------------------------------------------------------
114
115 void XmlReader::expectStartTag(
116 XmlParser& parser,
117 XmlEntry& entry,
118 const char* tagName)
119 {
120 if (!parser.next(entry) ||
121 entry.type != XmlEntry::START_TAG ||
122 strcmp(entry.text, tagName) != 0)
123 {
124 char message[MESSAGE_SIZE];
125 sprintf(message, "Expected open of %s element", tagName);
126 throw XmlValidationError(parser.getLine(), message);
127 }
128 }
129
130 //------------------------------------------------------------------------------
131 //
132 mike 1.23 // expectEndTag()
133 //
134 //------------------------------------------------------------------------------
135
136 void XmlReader::expectEndTag(XmlParser& parser, const char* tagName)
137 {
138 XmlEntry entry;
139
140 if (!parser.next(entry) ||
141 entry.type != XmlEntry::END_TAG ||
142 strcmp(entry.text, tagName) != 0)
143 {
144 char message[MESSAGE_SIZE];
145 sprintf(message, "Expected close of %s element, got %s instead",
146 tagName,entry.text);
147 throw XmlValidationError(parser.getLine(), message);
148 }
149 }
150
151 //------------------------------------------------------------------------------
152 //
153 mike 1.23 // expectStartTagOrEmptyTag()
154 //
155 //------------------------------------------------------------------------------
156
157 void XmlReader::expectStartTagOrEmptyTag(
158 XmlParser& parser,
159 XmlEntry& entry,
160 const char* tagName)
161 {
162 if (!parser.next(entry) ||
163 (entry.type != XmlEntry::START_TAG &&
164 entry.type != XmlEntry::EMPTY_TAG) ||
165 strcmp(entry.text, tagName) != 0)
166 {
167 char message[MESSAGE_SIZE];
168 sprintf(message,
169 "Expected either open or open/close %s element", tagName);
170 throw XmlValidationError(parser.getLine(), message);
171 }
172 }
173
174 mike 1.23 //------------------------------------------------------------------------------
175 //
176 // expectContentOrCData()
177 //
178 //------------------------------------------------------------------------------
179
180 Boolean XmlReader::expectContentOrCData(
181 XmlParser& parser,
182 XmlEntry& entry)
183 {
184 if (!parser.next(entry) ||
185 (entry.type != XmlEntry::CONTENT &&
186 entry.type != XmlEntry::CDATA))
187 {
188 throw XmlValidationError(parser.getLine(),
189 "Expected content of CDATA");
190 }
191
192 return true;
193 }
194
195 mike 1.23 //------------------------------------------------------------------------------
196 //
197 // testStartTag()
198 //
199 //------------------------------------------------------------------------------
200
201 Boolean XmlReader::testStartTag(
202 XmlParser& parser,
203 XmlEntry& entry,
204 const char* tagName)
205 {
206 if (!parser.next(entry) ||
207 entry.type != XmlEntry::START_TAG ||
208 strcmp(entry.text, tagName) != 0)
209 {
210 parser.putBack(entry);
211 return false;
212 }
213
214 return true;
215 }
216 mike 1.23
217 //------------------------------------------------------------------------------
218 //
|
219 kumpf 1.48 // testEndTag()
|
220 mike 1.23 //
221 //------------------------------------------------------------------------------
222
223 Boolean XmlReader::testEndTag(XmlParser& parser, const char* tagName)
224 {
225 XmlEntry entry;
226
227 if (!parser.next(entry) ||
228 entry.type != XmlEntry::END_TAG ||
229 strcmp(entry.text, tagName) != 0)
230 {
231 parser.putBack(entry);
232 return false;
233 }
234
235 return true;
236 }
237
238 //------------------------------------------------------------------------------
239 //
240 // testStartTagOrEmptyTag()
241 mike 1.23 //
242 //------------------------------------------------------------------------------
243
244 Boolean XmlReader::testStartTagOrEmptyTag(
245 XmlParser& parser,
246 XmlEntry& entry,
247 const char* tagName)
248 {
249 if (!parser.next(entry) ||
250 (entry.type != XmlEntry::START_TAG &&
251 entry.type != XmlEntry::EMPTY_TAG) ||
252 strcmp(entry.text, tagName) != 0)
253 {
254 parser.putBack(entry);
255 return false;
256 }
257
258 return true;
259 }
260
261 //------------------------------------------------------------------------------
262 mike 1.23 //
263 // testContentOrCData()
264 //
265 //------------------------------------------------------------------------------
266
267 Boolean XmlReader::testContentOrCData(
268 XmlParser& parser,
269 XmlEntry& entry)
270 {
271 if (!parser.next(entry) ||
272 (entry.type != XmlEntry::CONTENT &&
273 entry.type != XmlEntry::CDATA))
274 {
275 parser.putBack(entry);
276 return false;
277 }
278
279 return true;
280 }
281
282 //------------------------------------------------------------------------------
283 mike 1.23 //
|
284 kumpf 1.34 // getCimStartTag()
|
285 mike 1.23 //
286 // <!ELEMENT CIM (MESSAGE|DECLARATION)>
287 // <!ATTRLIST CIM
288 // CIMVERSION CDATA #REQUIRED
289 // DTDVERSION CDATA #REQUIRED>
290 //
291 //------------------------------------------------------------------------------
292
|
293 kumpf 1.34 void XmlReader::getCimStartTag(
294 XmlParser& parser,
295 const char*& cimVersion,
296 const char*& dtdVersion)
|
297 mike 1.23 {
298 XmlEntry entry;
299 XmlReader::expectStartTag(parser, entry, "CIM");
300
301 if (!entry.getAttributeValue("CIMVERSION", cimVersion))
302 throw XmlValidationError(
303 parser.getLine(), "missing CIM.CIMVERSION attribute");
304
305 if (!entry.getAttributeValue("DTDVERSION", dtdVersion))
306 throw XmlValidationError(
307 parser.getLine(), "missing CIM.DTDVERSION attribute");
308 }
309
310 //------------------------------------------------------------------------------
311 //
312 // getCimNameAttribute()
313 //
314 // <!ENTITY % CIMName "NAME CDATA #REQUIRED">
315 //
316 //------------------------------------------------------------------------------
317
318 mike 1.23 String XmlReader::getCimNameAttribute(
319 Uint32 lineNumber,
320 const XmlEntry& entry,
321 const char* elementName,
322 Boolean acceptNull)
323 {
324 String name;
325
326 if (!entry.getAttributeValue("NAME", name))
327 {
328 char buffer[MESSAGE_SIZE];
329 sprintf(buffer, "missing %s.NAME attribute", elementName);
330 throw XmlValidationError(lineNumber, buffer);
331 }
332
333 if (acceptNull && name.size() == 0)
334 return name;
335
336 if (!CIMName::legal(name))
337 {
338 char buffer[MESSAGE_SIZE];
339 mike 1.23 sprintf(buffer, "Illegal value for %s.NAME attribute", elementName);
340 throw XmlSemanticError(lineNumber, buffer);
341 }
342
343 return name;
344 }
345
346 //------------------------------------------------------------------------------
347 //
348 // getClassNameAttribute()
349 //
350 // <!ENTITY % CIMName "CLASSNAME CDATA #REQUIRED">
351 //
352 //------------------------------------------------------------------------------
353
354 String XmlReader::getClassNameAttribute(
355 Uint32 lineNumber,
356 const XmlEntry& entry,
357 const char* elementName)
358 {
359 String name;
360 mike 1.23
361 if (!entry.getAttributeValue("CLASSNAME", name))
362 {
363 char buffer[MESSAGE_SIZE];
364 sprintf(buffer, "missing %s.CLASSNAME attribute", elementName);
365 throw XmlValidationError(lineNumber, buffer);
366 }
367
368 if (!CIMName::legal(name))
369 {
370 char buffer[MESSAGE_SIZE];
371 sprintf(buffer,
372 "Illegal value for %s.CLASSNAME attribute", elementName);
373 throw XmlSemanticError(lineNumber, buffer);
374 }
375
376 return name;
377 }
378
379 //------------------------------------------------------------------------------
380 //
381 mike 1.23 // getClassOriginAttribute()
382 //
383 // <!ENTITY % ClassOrigin "CLASSORIGIN CDATA #IMPLIED">
384 //
385 //------------------------------------------------------------------------------
386
387 String XmlReader::getClassOriginAttribute(
388 Uint32 lineNumber,
389 const XmlEntry& entry,
390 const char* tagName)
391 {
392 String name;
393
394 if (!entry.getAttributeValue("CLASSORIGIN", name))
395 return String();
396
397 if (!CIMName::legal(name))
398 {
399 char buffer[MESSAGE_SIZE];
400 sprintf(buffer,
401 "Illegal value for %s.CLASSORIGIN attribute", tagName);
402 mike 1.23 throw XmlSemanticError(lineNumber, buffer);
403 }
404
405 return name;
406 }
407
408 //------------------------------------------------------------------------------
409 //
410 // getReferenceClassAttribute()
411 //
412 // <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">
413 //
414 //------------------------------------------------------------------------------
415
416 String XmlReader::getReferenceClassAttribute(
417 Uint32 lineNumber,
418 const XmlEntry& entry,
419 const char* elementName)
420 {
421 String name;
422
423 mike 1.23 if (!entry.getAttributeValue("REFERENCECLASS", name))
424 return String();
425
426 if (!CIMName::legal(name))
427 {
428 char buffer[MESSAGE_SIZE];
429 sprintf(buffer,
430 "Illegal value for %s.REFERENCECLASS attribute", elementName);
431 throw XmlSemanticError(lineNumber, buffer);
432 }
433
434 return name;
435 }
436
437 //------------------------------------------------------------------------------
438 //
439 // getSuperClassAttribute()
440 //
441 // <!ENTITY % SuperClass "SUPERCLASS CDATA #IMPLIED">
442 //
443 //------------------------------------------------------------------------------
444 mike 1.23
445 String XmlReader::getSuperClassAttribute(
446 Uint32 lineNumber,
447 const XmlEntry& entry,
448 const char* tagName)
449 {
450 String superClass;
451
452 if (!entry.getAttributeValue("SUPERCLASS", superClass))
453 return String();
454
455 if (!CIMName::legal(superClass))
456 {
457 char buffer[MESSAGE_SIZE];
458 sprintf(
459 buffer, "Illegal value for %s.SUPERCLASS attribute", tagName);
460 throw XmlSemanticError(lineNumber, buffer);
461 }
462
463 return superClass;
464 }
465 mike 1.23
466 //------------------------------------------------------------------------------
467 //
468 // getCimTypeAttribute()
469 //
|
470 kumpf 1.26 // This method can be used to get a TYPE attribute or a PARAMTYPE attribute.
471 // The only significant difference is that PARAMTYPE may specify a value of
472 // "reference" type. This method recognizes these attributes by name, and
473 // does not allow a "TYPE" attribute to be of "reference" type.
474 //
|
475 mike 1.23 // <!ENTITY % CIMType "TYPE (boolean|string|char16|uint8|sint8|uint16
476 // |sint16|uint32|sint32|uint64|sint64|datetime|real32|real64)">
477 //
|
478 kumpf 1.26 // <!ENTITY % ParamType "PARAMTYPE (boolean|string|char16|uint8|sint8
479 // |uint16|sint16|uint32|sint32|uint64|sint64|datetime|real32|real64
480 // |reference)">
481 //
|
482 mike 1.23 //------------------------------------------------------------------------------
483
484 CIMType XmlReader::getCimTypeAttribute(
485 Uint32 lineNumber,
486 const XmlEntry& entry,
|
487 kumpf 1.26 const char* tagName,
488 const char* attributeName,
489 Boolean required)
|
490 mike 1.23 {
491 const char* typeName;
492
|
493 kumpf 1.26 if (!entry.getAttributeValue(attributeName, typeName))
|
494 mike 1.23 {
|
495 kumpf 1.26 if (required)
496 {
497 char message[MESSAGE_SIZE];
498 sprintf(message, "missing %s.%s attribute", tagName, attributeName);
499 throw XmlValidationError(lineNumber, message);
500 }
501 else
502 {
503 return CIMType::NONE;
504 }
|
505 mike 1.23 }
506
507 CIMType type = CIMType::NONE;
508
509 if (strcmp(typeName, "boolean") == 0)
510 type = CIMType::BOOLEAN;
511 else if (strcmp(typeName, "string") == 0)
512 type = CIMType::STRING;
513 else if (strcmp(typeName, "char16") == 0)
514 type = CIMType::CHAR16;
515 else if (strcmp(typeName, "uint8") == 0)
516 type = CIMType::UINT8;
517 else if (strcmp(typeName, "sint8") == 0)
518 type = CIMType::SINT8;
519 else if (strcmp(typeName, "uint16") == 0)
520 type = CIMType::UINT16;
521 else if (strcmp(typeName, "sint16") == 0)
522 type = CIMType::SINT16;
523 else if (strcmp(typeName, "uint32") == 0)
524 type = CIMType::UINT32;
525 else if (strcmp(typeName, "sint32") == 0)
526 mike 1.23 type = CIMType::SINT32;
527 else if (strcmp(typeName, "uint64") == 0)
528 type = CIMType::UINT64;
529 else if (strcmp(typeName, "sint64") == 0)
530 type = CIMType::SINT64;
531 else if (strcmp(typeName, "datetime") == 0)
532 type = CIMType::DATETIME;
533 else if (strcmp(typeName, "real32") == 0)
534 type = CIMType::REAL32;
535 else if (strcmp(typeName, "real64") == 0)
536 type = CIMType::REAL64;
|
537 kumpf 1.26 else if (strcmp(typeName, "reference") == 0)
538 type = CIMType::REFERENCE;
|
539 mike 1.23
|
540 kumpf 1.26 if ((type == CIMType::NONE) ||
541 ((type == CIMType::REFERENCE) &&
542 (strcmp(attributeName, "PARAMTYPE") != 0)))
|
543 mike 1.23 {
544 char message[MESSAGE_SIZE];
|
545 kumpf 1.26 sprintf(message, "Illegal value for %s.%s attribute", tagName,
546 attributeName);
|
547 mike 1.23 throw XmlSemanticError(lineNumber, message);
548 }
549
550 return type;
551 }
552
553 //------------------------------------------------------------------------------
554 //
555 // getCimBooleanAttribute()
556 //
557 //------------------------------------------------------------------------------
558
559 Boolean XmlReader::getCimBooleanAttribute(
560 Uint32 lineNumber,
561 const XmlEntry& entry,
562 const char* tagName,
563 const char* attributeName,
564 Boolean defaultValue,
565 Boolean required)
566 {
567 const char* tmp;
568 mike 1.23
569 if (!entry.getAttributeValue(attributeName, tmp))
570 {
571 if (!required)
572 return defaultValue;
573
574 char buffer[62];
575 sprintf(buffer, "missing required %s.%s attribute",
576 attributeName, tagName);
577
578 throw XmlValidationError(lineNumber, buffer);
579 }
580
581 if (strcmp(tmp, "true") == 0)
582 return true;
583 else if (strcmp(tmp, "false") == 0)
584 return false;
585
586 char buffer[62];
587 sprintf(buffer, "Bad %s.%s attribute value", attributeName, tagName);
588 throw XmlSemanticError(lineNumber, buffer);
589 mike 1.23 return false;
590 }
591
592 //------------------------------------------------------------------------------
593 //
594 // SringToReal()
595 //
596 // [ "+" | "-" ] *decimalDigit "." 1*decimalDigit
597 // [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]
598 //
599 //------------------------------------------------------------------------------
600
601 Boolean XmlReader::stringToReal(const char* stringValue, Real64& x)
602 {
|
603 kumpf 1.43 //
604 // Check the string against the DMTF-defined grammar
605 //
|
606 mike 1.23 const char* p = stringValue;
607
608 if (!*p)
609 return false;
610
611 // Skip optional sign:
612
613 if (*p == '+' || *p == '-')
614 p++;
615
616 // Skip optional first set of digits:
617
618 while (isdigit(*p))
619 p++;
620
621 // Test required dot:
622
623 if (*p++ != '.')
624 return false;
625
626 // One or more digits required:
627 mike 1.23
628 if (!isdigit(*p++))
629 return false;
630
631 while (isdigit(*p))
632 p++;
633
634 // If there is an exponent now:
635
636 if (*p)
637 {
638 // Test exponent:
639
640 if (*p != 'e' && *p != 'E')
641 return false;
642
643 p++;
644
645 // Skip optional sign:
646
647 if (*p == '+' || *p == '-')
648 mike 1.23 p++;
649
650 // One or more digits required:
651
652 if (!isdigit(*p++))
653 return false;
654
655 while (isdigit(*p))
656 p++;
657 }
658
659 if (*p)
660 return false;
661
|
662 kumpf 1.43 //
663 // Do the conversion
664 //
|
665 mike 1.23 char* end;
|
666 kumpf 1.43 errno = 0;
|
667 mike 1.23 x = strtod(stringValue, &end);
|
668 kumpf 1.43 if (*end || (errno == ERANGE))
669 {
670 return false;
671 }
672
|
673 mike 1.23 return true;
674 }
675
|
676 kumpf 1.41 inline Uint8 _hexCharToNumeric(const char c)
677 {
678 Uint8 n;
679
680 if (isdigit(c))
681 n = (c - '0');
682 else if (isupper(c))
683 n = (c - 'A' + 10);
684 else // if (islower(c))
685 n = (c - 'a' + 10);
686
687 return n;
688 }
689
|
690 mike 1.23 //------------------------------------------------------------------------------
691 //
692 // stringToSignedInteger
693 //
694 // [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
|
695 kumpf 1.41 // or
696 // [ "+" | "-" ] ( "0x" | "0X" ) 1*hexDigit
|
697 mike 1.23 //
698 //------------------------------------------------------------------------------
699
700 Boolean XmlReader::stringToSignedInteger(
701 const char* stringValue,
702 Sint64& x)
703 {
704 x = 0;
705 const char* p = stringValue;
706
|
707 kumpf 1.41 if (!p || !*p)
|
708 mike 1.23 return false;
709
710 // Skip optional sign:
711
712 Boolean negative = *p == '-';
713
714 if (negative || *p == '+')
715 p++;
716
717 if (*p == '0')
|
718 kumpf 1.41 {
719 if ( (p[1] == 'x') || (p[1] == 'X') )
720 {
721 // Convert a hexadecimal string
|
722 mike 1.23
|
723 kumpf 1.41 // Skip over the "0x"
724 p+=2;
|
725 mike 1.23
|
726 kumpf 1.41 // At least one hexadecimal digit is required
727 if (!isxdigit(*p))
728 return false;
729
730 // Build the Sint64 as a negative number, regardless of the
731 // eventual sign (negative numbers can be bigger than positive ones)
732
733 // Add on each digit, checking for overflow errors
734 while (isxdigit(*p))
735 {
736 // Make sure we won't overflow when we multiply by 16
737 if (x < PEGASUS_LLONG_MIN/16)
738 {
739 return false;
740 }
741 x = x << 4;
742
743 // Make sure we don't overflow when we add the next digit
744 Sint64 newDigit = Sint64(_hexCharToNumeric(*p++));
745 if (PEGASUS_LLONG_MIN - x > -newDigit)
746 {
747 kumpf 1.41 return false;
748 }
749 x = x - newDigit;
750 }
751
752 // If we found a non-hexadecimal digit, report an error
753 if (*p)
754 return false;
755
756 // Return the integer to positive, if necessary, checking for an
757 // overflow error
758 if (!negative)
759 {
760 if (x == PEGASUS_LLONG_MIN)
761 {
762 return false;
763 }
764 x = -x;
765 }
766 return true;
767 }
768 kumpf 1.41 else
769 {
770 // A decimal string that starts with '0' must be exactly "0".
771 return p[1] == '\0';
772 }
773 }
|
774 mike 1.23
|
775 kumpf 1.41 // Expect a positive decimal digit:
|
776 mike 1.23
|
777 kumpf 1.41 // At least one decimal digit is required
778 if (!isdigit(*p))
779 return false;
780
781 // Build the Sint64 as a negative number, regardless of the
782 // eventual sign (negative numbers can be bigger than positive ones)
|
783 mike 1.23
|
784 kumpf 1.41 // Add on each digit, checking for overflow errors
|
785 mike 1.23 while (isdigit(*p))
|
786 kumpf 1.37 {
|
787 kumpf 1.41 // Make sure we won't overflow when we multiply by 10
|
788 kumpf 1.39 if (x < PEGASUS_LLONG_MIN/10)
|
789 kumpf 1.37 {
790 return false;
791 }
792 x = 10 * x;
|
793 kumpf 1.41
794 // Make sure we won't overflow when we add the next digit
795 Sint64 newDigit = (*p++ - '0');
|
796 mday 1.38 if (PEGASUS_LLONG_MIN - x > -newDigit)
|
797 kumpf 1.37 {
798 return false;
799 }
|
800 kumpf 1.41 x = x - newDigit;
|
801 kumpf 1.37 }
|
802 mike 1.23
|
803 kumpf 1.41 // If we found a non-decimal digit, report an error
804 if (*p)
805 return false;
806
807 // Return the integer to positive, if necessary, checking for an
808 // overflow error
|
809 kumpf 1.37 if (!negative)
810 {
|
811 mday 1.38 if (x == PEGASUS_LLONG_MIN)
|
812 kumpf 1.37 {
813 return false;
814 }
|
815 kumpf 1.41 x = -x;
|
816 kumpf 1.37 }
|
817 mike 1.23 return true;
818 }
819
820 //------------------------------------------------------------------------------
821 //
822 // stringToUnsignedInteger
823 //
|
824 kumpf 1.40 // ( positiveDecimalDigit *decimalDigit | "0" )
|
825 kumpf 1.41 // or
826 // ( "0x" | "0X" ) 1*hexDigit
|
827 mike 1.23 //
828 //------------------------------------------------------------------------------
829
830 Boolean XmlReader::stringToUnsignedInteger(
831 const char* stringValue,
832 Uint64& x)
833 {
834 x = 0;
835 const char* p = stringValue;
836
|
837 kumpf 1.41 if (!p || !*p)
|
838 mike 1.23 return false;
839
840 if (*p == '0')
|
841 kumpf 1.41 {
842 if ( (p[1] == 'x') || (p[1] == 'X') )
843 {
844 // Convert a hexadecimal string
|
845 mike 1.23
|
846 kumpf 1.41 // Skip over the "0x"
847 p+=2;
|
848 mike 1.23
|
849 kumpf 1.41 // At least one hexadecimal digit is required
850 if (!*p)
851 return false;
852
853 // Add on each digit, checking for overflow errors
854 while (isxdigit(*p))
855 {
856 // Make sure we won't overflow when we multiply by 16
857 if (x > PEGASUS_ULLONG_MAX/16)
858 {
859 return false;
860 }
861 x = x << 4;
862
863 // We can't overflow when we add the next digit
864 Uint64 newDigit = Uint64(_hexCharToNumeric(*p++));
865 if (PEGASUS_ULLONG_MAX - x < newDigit)
866 {
867 return false;
868 }
869 x = x + newDigit;
870 kumpf 1.41 }
871
872 // If we found a non-hexadecimal digit, report an error
873 if (*p)
874 return false;
|
875 mike 1.23
|
876 kumpf 1.41 return true;
877 }
878 else
879 {
880 // A decimal string that starts with '0' must be exactly "0".
881 return p[1] == '\0';
882 }
883 }
|
884 mike 1.23
|
885 kumpf 1.41 // Expect a positive decimal digit:
|
886 mike 1.23
|
887 kumpf 1.41 // Add on each digit, checking for overflow errors
|
888 mike 1.23 while (isdigit(*p))
|
889 kumpf 1.37 {
|
890 kumpf 1.41 // Make sure we won't overflow when we multiply by 10
|
891 kumpf 1.39 if (x > PEGASUS_ULLONG_MAX/10)
|
892 kumpf 1.37 {
893 return false;
894 }
895 x = 10 * x;
|
896 kumpf 1.41
897 // Make sure we won't overflow when we add the next digit
898 Uint64 newDigit = (*p++ - '0');
|
899 kumpf 1.39 if (PEGASUS_ULLONG_MAX - x < newDigit)
|
900 kumpf 1.37 {
901 return false;
902 }
|
903 kumpf 1.41 x = x + newDigit;
|
904 kumpf 1.37 }
|
905 kumpf 1.41
906 // If we found a non-decimal digit, report an error
907 if (*p)
908 return false;
|
909 mike 1.23
910 return true;
911 }
912
913 //------------------------------------------------------------------------------
914 //
915 // stringToValue()
916 //
|
917 karl 1.35 // Return: CIMValue. If the string input is zero length creates a CIMValue
918 // with value defined by the type. Else the value is inserted.
919 //
920 // Note that this does not set the CIMValue Null if the string is empty.
921 //
|
922 mike 1.23 //------------------------------------------------------------------------------
923
924 CIMValue XmlReader::stringToValue(
925 Uint32 lineNumber,
926 const char* valueString,
927 CIMType type)
928 {
929 // ATTN-B: accepting only UTF-8 for now! (affects string and char16):
930
|
931 karl 1.35 // Create value per type
|
932 mike 1.23 switch (type)
933 {
934 case CIMType::BOOLEAN:
935 {
936 if (CompareNoCase(valueString, "TRUE") == 0)
937 return CIMValue(true);
938 else if (CompareNoCase(valueString, "FALSE") == 0)
939 return CIMValue(false);
940 else
941 throw XmlSemanticError(
942 lineNumber, "Bad boolean value");
943 }
944
945 case CIMType::STRING:
946 {
947 return CIMValue(valueString);
948 }
949
950 case CIMType::CHAR16:
951 {
952 if (strlen(valueString) != 1)
953 mike 1.23 throw XmlSemanticError(lineNumber, "Bad char16 value");
954
955 return CIMValue(Char16(valueString[0]));
956 }
957
958 case CIMType::UINT8:
959 case CIMType::UINT16:
960 case CIMType::UINT32:
961 case CIMType::UINT64:
962 {
963 Uint64 x;
964
965 if (!stringToUnsignedInteger(valueString, x))
966 {
967 throw XmlSemanticError(
968 lineNumber, "Bad unsigned integer value");
969 }
970
971 switch (type)
972 {
|
973 kumpf 1.37 case CIMType::UINT8:
974 {
975 if (x >= (Uint64(1)<<8))
976 {
977 throw XmlSemanticError(
978 lineNumber, "Uint8 value out of range");
979 }
980 return CIMValue(Uint8(x));
981 }
982 case CIMType::UINT16:
983 {
984 if (x >= (Uint64(1)<<16))
985 {
986 throw XmlSemanticError(
987 lineNumber, "Uint16 value out of range");
988 }
989 return CIMValue(Uint16(x));
990 }
991 case CIMType::UINT32:
992 {
993 if (x >= (Uint64(1)<<32))
994 kumpf 1.37 {
995 throw XmlSemanticError(
996 lineNumber, "Uint32 value out of range");
997 }
998 return CIMValue(Uint32(x));
999 }
|
1000 mike 1.23 case CIMType::UINT64: return CIMValue(Uint64(x));
1001 default: break;
1002 }
1003 }
1004
1005 case CIMType::SINT8:
1006 case CIMType::SINT16:
1007 case CIMType::SINT32:
1008 case CIMType::SINT64:
1009 {
1010 Sint64 x;
1011
1012 if (!stringToSignedInteger(valueString, x))
1013 {
1014 throw XmlSemanticError(
1015 lineNumber, "Bad signed integer value");
1016 }
1017
1018 switch (type)
1019 {
|
1020 kumpf 1.37 case CIMType::SINT8:
1021 {
1022 if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )
1023 {
1024 throw XmlSemanticError(
1025 lineNumber, "Sint8 value out of range");
1026 }
1027 return CIMValue(Sint8(x));
1028 }
1029 case CIMType::SINT16:
1030 {
1031 if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )
1032 {
1033 throw XmlSemanticError(
1034 lineNumber, "Sint16 value out of range");
1035 }
1036 return CIMValue(Sint16(x));
1037 }
1038 case CIMType::SINT32:
1039 {
1040 if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )
1041 kumpf 1.37 {
1042 throw XmlSemanticError(
1043 lineNumber, "Sint32 value out of range");
1044 }
1045 return CIMValue(Sint32(x));
1046 }
|
1047 mike 1.23 case CIMType::SINT64: return CIMValue(Sint64(x));
1048 default: break;
1049 }
1050 }
1051
1052 case CIMType::DATETIME:
1053 {
1054 CIMDateTime tmp;
1055
1056 try
1057 {
1058 tmp.set(valueString);
1059 }
1060 catch (BadDateTimeFormat&)
1061 {
1062 throw XmlSemanticError(lineNumber, "Bad datetime value");
1063 }
1064
1065 return CIMValue(tmp);
1066 }
1067
1068 mike 1.23 case CIMType::REAL32:
1069 {
1070 Real64 x;
1071
1072 if (!stringToReal(valueString, x))
|
1073 kumpf 1.43 throw XmlSemanticError(lineNumber, "Bad real number value");
|
1074 mike 1.23
1075 return CIMValue(Real32(x));
1076 }
1077
1078 case CIMType::REAL64:
1079 {
1080 Real64 x;
1081
1082 if (!stringToReal(valueString, x))
|
1083 kumpf 1.43 throw XmlSemanticError(lineNumber, "Bad real number value");
|
1084 mike 1.23
1085 return CIMValue(x);
1086 }
1087
1088 default:
1089 break;
1090 }
1091
1092 throw XmlSemanticError(lineNumber, "malformed XML");
1093 return false;
1094 }
1095
1096 //------------------------------------------------------------------------------
1097 //
1098 // getValueElement()
1099 //
1100 // <!ELEMENT VALUE (#PCDATA)>
1101 //
|
1102 karl 1.35 // Return: false if no value element.
1103 //
|
1104 mike 1.23 //------------------------------------------------------------------------------
1105
1106 Boolean XmlReader::getValueElement(
1107 XmlParser& parser,
1108 CIMType type,
1109 CIMValue& value)
1110 {
|
1111 karl 1.35 // Get VALUE start tag: Return false if no VALUE start Tag
|
1112 mike 1.23
1113 XmlEntry entry;
1114 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
1115 return false;
1116
1117 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1118
1119 const char* valueString = "";
1120
1121 if (!empty)
1122 {
1123 if (testContentOrCData(parser, entry))
1124 valueString = entry.text;
1125
1126 expectEndTag(parser, "VALUE");
1127 }
1128
1129 value = stringToValue(parser.getLine(), valueString,type);
|
1130 karl 1.33
|
1131 mike 1.23 return true;
1132 }
1133
1134 //------------------------------------------------------------------------------
1135 //
1136 // getStringValueElement()
1137 //
1138 // <!ELEMENT VALUE (#PCDATA)>
1139 //
1140 //------------------------------------------------------------------------------
1141
1142 Boolean XmlReader::getStringValueElement(
1143 XmlParser& parser,
1144 String& str,
1145 Boolean required)
1146 {
1147 XmlEntry entry;
1148
1149 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
1150 {
1151 if (required)
1152 mike 1.23 throw XmlValidationError(parser.getLine(),"Expected VALUE element");
1153 return false;
1154 }
1155
1156 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1157
1158 const char* valueString = "";
1159
1160 if (!empty)
1161 {
1162 if (testContentOrCData(parser, entry))
1163 valueString = entry.text;
1164
1165 expectEndTag(parser, "VALUE");
1166 }
1167
1168 str = valueString;
1169 return true;
1170 }
1171
1172 //----------------------------------------------------------------------------
1173 mike 1.23 //
1174 // getPropertyValue
|
1175 kumpf 1.30 // Use: Decode property value from SetProperty request and
1176 // GetProperty response.
|
1177 mike 1.23 //
|
1178 kumpf 1.30 // PropertyValue is one of:
|
1179 mike 1.23 //
1180 //
|
1181 karl 1.33 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1182 //
1183 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
|
1184 kumpf 1.30 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1185 //
1186 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
|
1187 mike 1.23 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
1188 //
|
1189 kumpf 1.30 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
1190 //
|
1191 mike 1.23 //----------------------------------------------------------------------------
1192 Boolean XmlReader::getPropertyValue(
1193 XmlParser& parser,
1194 CIMValue& cimValue)
1195 {
|
1196 kumpf 1.30 // Can not test for value type, so assume String
1197 const CIMType type = CIMType::STRING;
|
1198 mike 1.23
|
1199 kumpf 1.30 // Test for VALUE element
|
1200 mike 1.23 if (XmlReader::getValueElement(parser, type, cimValue))
1201 {
1202 return true;
1203 }
1204
|
1205 kumpf 1.30 // Test for VALUE.ARRAY element
1206 if (XmlReader::getValueArrayElement(parser, type, cimValue))
1207 {
|
1208 mike 1.23 return true;
|
1209 kumpf 1.30 }
|
1210 mike 1.23
|
1211 kumpf 1.30 // Test for VALUE.REFERENCE element
|
1212 kumpf 1.54 CIMObjectPath reference;
|
1213 kumpf 1.30 if (XmlReader::getValueReferenceElement(parser, reference))
|
1214 mike 1.25 {
1215 cimValue.set(reference);
1216 return true;
1217 }
|
1218 mike 1.23
|
1219 kumpf 1.30 // Test for VALUE.REFARRAY element
1220 if (XmlReader::getValueReferenceArrayElement(parser, cimValue))
1221 {
1222 return true;
1223 }
1224
1225 return false;
|
1226 mike 1.23 }
1227
1228 //------------------------------------------------------------------------------
1229 //
1230 // stringArrayToValue()
1231 //
1232 //------------------------------------------------------------------------------
1233
1234 template<class T>
1235 CIMValue StringArrayToValueAux(
1236 Uint32 lineNumber,
1237 const Array<const char*>& stringArray,
1238 CIMType type,
1239 T*)
1240 {
1241 Array<T> array;
1242
1243 for (Uint32 i = 0, n = stringArray.size(); i < n; i++)
1244 {
1245 CIMValue value = XmlReader::stringToValue(
1246 lineNumber, stringArray[i], type);
1247 mike 1.23
1248 T x;
1249 value.get(x);
1250 array.append(x);
1251 }
1252
1253 return CIMValue(array);
1254 }
1255
1256 CIMValue XmlReader::stringArrayToValue(
1257 Uint32 lineNumber,
1258 const Array<const char*>& array,
1259 CIMType type)
1260 {
1261 switch (type)
1262 {
1263 case CIMType::BOOLEAN:
1264 return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);
1265
1266 case CIMType::STRING:
1267 return StringArrayToValueAux(lineNumber, array, type, (String*)0);
1268 mike 1.23
1269 case CIMType::CHAR16:
1270 return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);
1271
1272 case CIMType::UINT8:
1273 return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);
1274
1275 case CIMType::UINT16:
1276 return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);
1277
1278 case CIMType::UINT32:
1279 return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);
1280
1281 case CIMType::UINT64:
1282 return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);
1283
1284 case CIMType::SINT8:
1285 return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);
1286
1287 case CIMType::SINT16:
1288 return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);
1289 mike 1.23
1290 case CIMType::SINT32:
1291 return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);
1292
1293 case CIMType::SINT64:
1294 return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);
1295
1296 case CIMType::DATETIME:
1297 return StringArrayToValueAux(lineNumber, array, type, (CIMDateTime*)0);
1298
1299 case CIMType::REAL32:
1300 return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);
1301
1302 case CIMType::REAL64:
1303 return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);
1304
1305 default:
1306 break;
1307 }
1308
1309 // Unreachable:
1310 mike 1.23 return CIMValue();
1311 }
1312
1313 //------------------------------------------------------------------------------
1314 //
1315 // getValueArrayElement()
1316 //
1317 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1318 //
|
1319 karl 1.35 // Return: Boolean. Returns false if there is no VALUE.ARRAY start element
1320 //
|
1321 mike 1.23 //------------------------------------------------------------------------------
1322
1323 Boolean XmlReader::getValueArrayElement(
1324 XmlParser& parser,
1325 CIMType type,
1326 CIMValue& value)
1327 {
|
1328 karl 1.35 // Clears any values from the Array. Assumes this is array CIMValue
|
1329 mike 1.23 value.clear();
1330
1331 // Get VALUE.ARRAY open tag:
1332
1333 XmlEntry entry;
|
1334 kumpf 1.32 Array<const char*> stringArray;
|
1335 mike 1.23
|
1336 karl 1.35 // If no VALUE.ARRAY start tag, return false
|
1337 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))
1338 return false;
|
1339 karl 1.33
|
1340 kumpf 1.32 if (entry.type != XmlEntry::EMPTY_TAG)
1341 {
1342 // For each VALUE element:
|
1343 mike 1.23
|
1344 kumpf 1.32 while (testStartTagOrEmptyTag(parser, entry, "VALUE"))
1345 {
1346 if (entry.type == XmlEntry::EMPTY_TAG)
1347 {
1348 stringArray.append("");
1349 continue;
1350 }
|
1351 mike 1.23
|
1352 kumpf 1.32 if (testContentOrCData(parser, entry))
1353 stringArray.append(entry.text);
1354 else
1355 stringArray.append("");
|
1356 mike 1.23
|
1357 kumpf 1.32 expectEndTag(parser, "VALUE");
1358 }
|
1359 mike 1.23
|
1360 kumpf 1.32 expectEndTag(parser, "VALUE.ARRAY");
|
1361 mike 1.23 }
1362
1363 value = stringArrayToValue(parser.getLine(), stringArray, type);
1364 return true;
1365 }
1366
1367 //------------------------------------------------------------------------------
1368 //
1369 // getFlavor()
1370 //
1371 // <!ENTITY % QualifierFlavor
1372 // "OVERRIDABLE (true|false) 'true'
1373 // TOSUBCLASS (true|false) 'true'
1374 // TOINSTANCE (true|false) 'false'
1375 // TRANSLATABLE (true|false) 'false'">
1376 //
1377 //------------------------------------------------------------------------------
1378
1379 Uint32 XmlReader::getFlavor(
1380 XmlEntry& entry,
1381 Uint32 lineNumber,
1382 mike 1.23 const char* tagName)
1383 {
1384 // Get QUALIFIER.OVERRIDABLE
1385
1386 Boolean overridable = getCimBooleanAttribute(
1387 lineNumber, entry, tagName, "OVERRIDABLE", true, false);
1388
1389 // Get QUALIFIER.TOSUBCLASS
1390
1391 Boolean toSubClass = getCimBooleanAttribute(
1392 lineNumber, entry, tagName, "TOSUBCLASS", true, false);
1393
1394 // Get QUALIFIER.TOINSTANCE
1395
1396 Boolean toInstance = getCimBooleanAttribute(
1397 lineNumber, entry, tagName, "TOINSTANCE", false, false);
1398
1399 // Get QUALIFIER.TRANSLATABLE
1400
1401 Boolean translatable = getCimBooleanAttribute(
1402 lineNumber, entry, tagName, "TRANSLATABLE", false, false);
1403 mike 1.23
|
1404 kumpf 1.44 // Start with CIMFlavor::NONE. Defaults are specified in the
1405 // getCimBooleanAttribute() calls above.
|
1406 kumpf 1.36 Uint32 flavor = CIMFlavor::NONE;
|
1407 mike 1.23
1408 if (overridable)
1409 flavor |= CIMFlavor::OVERRIDABLE;
|
1410 karl 1.47 else
1411 flavor |= CIMFlavor::DISABLEOVERRIDE;
|
1412 mike 1.23
1413 if (toSubClass)
1414 flavor |= CIMFlavor::TOSUBCLASS;
|
1415 karl 1.47 else
1416 flavor |= CIMFlavor::RESTRICTED;
|
1417 mike 1.23
1418 if (toInstance)
1419 flavor |= CIMFlavor::TOINSTANCE;
1420
1421 if (translatable)
1422 flavor |= CIMFlavor::TRANSLATABLE;
1423
1424 return flavor;
1425 }
1426
1427 //------------------------------------------------------------------------------
1428 //
1429 // getOptionalScope()
1430 //
1431 // DTD:
1432 // <!ELEMENT SCOPE EMPTY>
1433 // <!ATTLIST SCOPE
1434 // CLASS (true|false) 'false'
1435 // ASSOCIATION (true|false) 'false'
1436 // REFERENCE (true|false) 'false'
1437 // PROPERTY (true|false) 'false'
1438 mike 1.23 // METHOD (true|false) 'false'
1439 // PARAMETER (true|false) 'false'
1440 // INDICATION (true|false) 'false'>
1441 //
1442 //------------------------------------------------------------------------------
1443
1444 Uint32 XmlReader::getOptionalScope(XmlParser& parser)
1445 {
1446 XmlEntry entry;
1447
1448 if (!parser.next(entry))
1449 return false;
1450
1451 Boolean isEmptyTag = entry.type == XmlEntry::EMPTY_TAG;
1452
1453 if ((!isEmptyTag &&
1454 entry.type != XmlEntry::START_TAG) ||
1455 strcmp(entry.text, "SCOPE") != 0)
1456 {
1457 parser.putBack(entry);
1458 return 0;
1459 mike 1.23 }
1460
1461 Uint32 line = parser.getLine();
1462 Uint32 scope = 0;
1463
1464 if (getCimBooleanAttribute(line, entry, "SCOPE", "CLASS", false, false))
1465 scope |= CIMScope::CLASS;
1466
1467 if (getCimBooleanAttribute(
1468 line, entry, "SCOPE", "ASSOCIATION", false, false))
1469 scope |= CIMScope::ASSOCIATION;
1470
1471 if (getCimBooleanAttribute(
1472 line, entry, "SCOPE", "REFERENCE", false, false))
1473 scope |= CIMScope::REFERENCE;
1474
1475 if (getCimBooleanAttribute(line, entry, "SCOPE", "PROPERTY", false, false))
1476 scope |= CIMScope::PROPERTY;
1477
1478 if (getCimBooleanAttribute(line, entry, "SCOPE", "METHOD", false, false))
1479 scope |= CIMScope::METHOD;
1480 mike 1.23
1481 if (getCimBooleanAttribute(line, entry, "SCOPE", "PARAMETER", false, false))
1482 scope |= CIMScope::PARAMETER;
1483
1484 if (getCimBooleanAttribute(line, entry, "SCOPE", "INDICATION",false, false))
1485 scope |= CIMScope::INDICATION;
1486
1487 if (!isEmptyTag)
1488 expectEndTag(parser, "SCOPE");
1489
1490 return scope;
1491 }
1492
1493 //------------------------------------------------------------------------------
1494 //
1495 // getQualifierElement()
1496 //
|
1497 kumpf 1.52 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)?>
|
1498 mike 1.23 // <!ATTLIST QUALIFIER
1499 // %CIMName;
1500 // %CIMType; #REQUIRED
1501 // %Propagated;
1502 // %QualifierFlavor;>
1503 //
1504 //------------------------------------------------------------------------------
1505
1506 Boolean XmlReader::getQualifierElement(
1507 XmlParser& parser,
1508 CIMQualifier& qualifier)
1509 {
1510 // Get QUALIFIER element:
1511
1512 XmlEntry entry;
1513 if (!testStartTag(parser, entry, "QUALIFIER"))
1514 return false;
1515
1516 // Get QUALIFIER.NAME attribute:
1517
1518 String name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
1519 mike 1.23
1520 // Get QUALIFIER.TYPE attribute:
1521
1522 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "QUALIFIER");
1523
1524 // Get QUALIFIER.PROPAGATED
1525
1526 Boolean propagated = getCimBooleanAttribute(
1527 parser.getLine(), entry, "QUALIFIER", "PROPAGATED", false, false);
1528
1529 // Get flavor oriented attributes:
1530
1531 Uint32 flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");
1532
1533 // Get VALUE or VALUE.ARRAY element:
1534
1535 CIMValue value;
1536
1537 if (!getValueElement(parser, type, value) &&
1538 !getValueArrayElement(parser, type, value))
1539 {
|
1540 kumpf 1.52 value.setNullValue(type, false);
|
1541 mike 1.23 }
1542
1543 // Expect </QUALIFIER>:
1544
1545 expectEndTag(parser, "QUALIFIER");
1546
1547 // Build qualifier:
1548
1549 qualifier = CIMQualifier(name, value, flavor, propagated);
1550 return true;
1551 }
1552
1553 //------------------------------------------------------------------------------
1554 //
1555 // getQualifierElements()
1556 //
1557 //------------------------------------------------------------------------------
1558
1559 template<class CONTAINER>
1560 void getQualifierElements(XmlParser& parser, CONTAINER& container)
1561 {
1562 mike 1.23 CIMQualifier qualifier;
1563
1564 while (XmlReader::getQualifierElement(parser, qualifier))
1565 {
1566 try
1567 {
1568 container.addQualifier(qualifier);
1569 }
1570 catch (AlreadyExists&)
1571 {
1572 throw XmlSemanticError(parser.getLine(), "duplicate qualifier");
1573 }
1574 }
1575 }
1576
1577 //------------------------------------------------------------------------------
1578 //
1579 // getPropertyElement()
1580 //
1581 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
1582 // <!ATTLIST PROPERTY
1583 mike 1.23 // %CIMName;
1584 // %ClassOrigin;
1585 // %Propagated;
1586 // %CIMType; #REQUIRED>
1587 //
1588 //------------------------------------------------------------------------------
1589
1590 Boolean XmlReader::getPropertyElement(XmlParser& parser, CIMProperty& property)
1591 {
1592 XmlEntry entry;
1593
1594 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY"))
1595 return false;
1596
1597 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1598
1599 // Get PROPERTY.NAME attribute:
1600
1601 String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
1602
1603 // Get PROPERTY.CLASSORIGIN attribute:
1604 mike 1.23
1605 String classOrigin =
1606 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
1607
1608 // Get PROPERTY.PROPAGATED
1609
1610 Boolean propagated = getCimBooleanAttribute(
1611 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
1612
1613 // Get PROPERTY.TYPE attribute:
1614
1615 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");
1616
|
1617 karl 1.35 // Create property: Sets type and !isarray
|
1618 mike 1.23
|
1619 kumpf 1.56 CIMValue value(type, false);
1620 property = CIMProperty(name, value, 0, String(), classOrigin, propagated);
|
1621 mike 1.23
1622 if (!empty)
1623 {
1624 // Get qualifiers:
1625
1626 getQualifierElements(parser, property);
1627
|
1628 karl 1.35 // Get value: Insert value if getValueElement exists (returns True)
|
1629 mike 1.23
1630 if (getValueElement(parser, type, value))
1631 property.setValue(value);
1632
1633 expectEndTag(parser, "PROPERTY");
1634 }
1635
1636 return true;
1637 }
1638
1639 //------------------------------------------------------------------------------
1640 //
1641 // getArraySizeAttribute()
1642 //
1643 // Returns true if able to get array-size. Note that array size will
1644 // always be a positive integer.
1645 //
1646 // <!ENTITY % ArraySize "ARRAYSIZE CDATA #IMPLIED">
1647 //
1648 //------------------------------------------------------------------------------
1649
1650 mike 1.23 Boolean XmlReader::getArraySizeAttribute(
1651 Uint32 lineNumber,
1652 const XmlEntry& entry,
1653 const char* tagName,
1654 Uint32& value)
1655 {
1656 const char* tmp;
1657
1658 if (!entry.getAttributeValue("ARRAYSIZE", tmp))
1659 return false;
1660
1661 Uint64 arraySize;
1662
1663 if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)
1664 {
1665 char message[128];
1666 sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");
1667 throw XmlSemanticError(lineNumber, message);
1668 }
1669
1670 value = Uint32(arraySize);
1671 mike 1.23 return true;
1672 }
1673
1674 //------------------------------------------------------------------------------
1675 //
1676 // getPropertyArrayElement()
1677 //
1678 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
1679 // <!ATTLIST PROPERTY.ARRAY
1680 // %CIMName;
1681 // %CIMType; #REQUIRED
1682 // %ArraySize;
1683 // %ClassOrigin;
1684 // %Propagated;>
1685 //
1686 //------------------------------------------------------------------------------
1687
1688 Boolean XmlReader::getPropertyArrayElement(
1689 XmlParser& parser,
1690 CIMProperty& property)
1691 {
1692 mike 1.23 // Get PROPERTY element:
1693
1694 XmlEntry entry;
1695
1696 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.ARRAY"))
1697 return false;
1698
1699 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1700
1701 // Get PROPERTY.NAME attribute:
1702
1703 String name =
1704 getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
1705
1706 // Get PROPERTY.TYPE attribute:
1707
1708 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
1709
1710 // Get PROPERTY.ARRAYSIZE attribute:
1711
1712 Uint32 arraySize = 0;
1713 mike 1.23 getArraySizeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY", arraySize);
1714
1715 // Get PROPERTY.CLASSORIGIN attribute:
1716
1717 String classOrigin
1718 = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
1719
1720 // Get PROPERTY.ARRAY.PROPAGATED
1721
1722 Boolean propagated = getCimBooleanAttribute(
1723 parser.getLine(), entry, "PROPERTY.ARRAY", "PROPAGATED", false, false);
1724
1725 // Create property:
1726
|
1727 kumpf 1.56 CIMValue value(type, true, arraySize);
|
1728 mike 1.23 property = CIMProperty(
|
1729 kumpf 1.56 name, value, arraySize, String(), classOrigin, propagated);
|
1730 mike 1.23
1731 if (!empty)
1732 {
1733 // Get qualifiers:
1734
1735 getQualifierElements(parser, property);
1736
1737 // Get value:
1738
1739 if (getValueArrayElement(parser, type, value))
1740 {
1741 if (arraySize && arraySize != value.getArraySize())
1742 {
1743 throw XmlSemanticError(parser.getLine(),
1744 "ARRAYSIZE attribute and value-array size are different");
1745 }
1746
1747 property.setValue(value);
1748 }
1749
1750 expectEndTag(parser, "PROPERTY.ARRAY");
1751 mike 1.23 }
1752
1753 return true;
1754 }
1755
1756 //------------------------------------------------------------------------------
1757 //
1758 // getHostElement()
1759 //
1760 // <!ELEMENT HOST (#PCDATA)>
1761 //
1762 //------------------------------------------------------------------------------
1763
1764 Boolean XmlReader::getHostElement(
1765 XmlParser& parser,
1766 String& host)
1767 {
1768 XmlEntry entry;
1769
1770 if (!testStartTag(parser, entry, "HOST"))
1771 return false;
1772 mike 1.23
1773 if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)
1774 {
1775 throw XmlValidationError(parser.getLine(),
1776 "expected content of HOST element");
1777 }
1778
1779 host = entry.text;
1780
1781 expectEndTag(parser, "HOST");
1782 return true;
1783 }
1784
1785 //------------------------------------------------------------------------------
1786 //
1787 // getNameSpaceElement()
1788 //
1789 // <!ELEMENT NAMESPACE EMPTY>
1790 // <!ATTLIST NAMESPACE %CIMName;>
1791 //
1792 //------------------------------------------------------------------------------
1793 mike 1.23
1794 Boolean XmlReader::getNameSpaceElement(
1795 XmlParser& parser,
1796 String& nameSpaceComponent)
1797 {
1798 XmlEntry entry;
1799
1800 if (!testStartTagOrEmptyTag(parser, entry, "NAMESPACE"))
1801 return false;
1802
1803 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1804
1805 nameSpaceComponent = getCimNameAttribute(
1806 parser.getLine(), entry, "NAMESPACE");
1807
1808 if (!empty)
1809 expectEndTag(parser, "NAMESPACE");
1810
1811 return true;
1812 }
1813
1814 mike 1.23 //------------------------------------------------------------------------------
1815 //
1816 // getLocalNameSpacePathElement()
1817 //
1818 // <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
1819 //
1820 //------------------------------------------------------------------------------
1821
1822 Boolean XmlReader::getLocalNameSpacePathElement(
1823 XmlParser& parser,
1824 String& nameSpace)
1825 {
1826 XmlEntry entry;
1827
1828 if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))
1829 return false;
1830
1831 String nameSpaceComponent;
1832
1833 while (getNameSpaceElement(parser, nameSpaceComponent))
1834 {
1835 mike 1.23 if (nameSpace.size())
1836 nameSpace += '/';
1837
1838 nameSpace += nameSpaceComponent;
1839 }
1840
1841 if (!nameSpace.size())
1842 {
1843 throw XmlValidationError(parser.getLine(),
1844 "Expected one or more NAMESPACE elements within "
1845 "LOCALNAMESPACEPATH element");
1846 }
1847
1848 expectEndTag(parser, "LOCALNAMESPACEPATH");
1849 return true;
1850 }
1851
1852 //------------------------------------------------------------------------------
1853 //
1854 // getNameSpacePathElement()
1855 //
1856 mike 1.23 // <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
1857 //
1858 //------------------------------------------------------------------------------
1859
1860 Boolean XmlReader::getNameSpacePathElement(
1861 XmlParser& parser,
1862 String& host,
1863 String& nameSpace)
1864 {
1865 host.clear();
1866 nameSpace.clear();
1867
1868 XmlEntry entry;
1869
1870 if (!testStartTag(parser, entry, "NAMESPACEPATH"))
1871 return false;
1872
1873 if (!getHostElement(parser, host))
1874 throw XmlValidationError(parser.getLine(), "expected HOST element");
1875
1876 if (!getLocalNameSpacePathElement(parser, nameSpace))
1877 mike 1.23 {
1878 throw XmlValidationError(parser.getLine(),
1879 "expected LOCALNAMESPACEPATH element");
1880 }
1881
1882 expectEndTag(parser, "NAMESPACEPATH");
1883
1884 return true;
1885 }
1886
1887 //------------------------------------------------------------------------------
1888 //
1889 // getClassNameElement()
1890 //
1891 // <!ELEMENT CLASSNAME EMPTY>
1892 // <!ATTLIST CLASSNAME %CIMName;>
1893 //
1894 //------------------------------------------------------------------------------
1895
1896 Boolean XmlReader::getClassNameElement(
1897 XmlParser& parser,
1898 mike 1.23 String& className,
1899 Boolean required)
1900 {
1901 XmlEntry entry;
1902
1903 if (!testStartTagOrEmptyTag(parser, entry, "CLASSNAME"))
1904 {
1905 if (required)
1906 {
1907 throw XmlValidationError(parser.getLine(),
1908 "expected CLASSNAME element");
1909 }
1910 else
1911 return false;
1912 }
1913
1914 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1915
1916 className = getCimNameAttribute(
1917 parser.getLine(), entry, "CLASSNAME", true);
1918
1919 mike 1.23 if (!empty)
1920 expectEndTag(parser, "CLASSNAME");
1921
1922 return true;
1923 }
1924
1925 //------------------------------------------------------------------------------
1926 //
1927 // getValueTypeAttribute()
1928 //
1929 // VALUETYPE (string|boolean|numeric) 'string'
1930 //
1931 //------------------------------------------------------------------------------
1932
1933 KeyBinding::Type XmlReader::getValueTypeAttribute(
1934 Uint32 lineNumber,
1935 const XmlEntry& entry,
1936 const char* elementName)
1937 {
1938 String tmp;
1939
1940 mike 1.23 if (!entry.getAttributeValue("VALUETYPE", tmp))
1941 return KeyBinding::STRING;
1942
1943 if (String::equal(tmp, "string"))
1944 return KeyBinding::STRING;
1945 else if (String::equal(tmp, "boolean"))
1946 return KeyBinding::BOOLEAN;
1947 else if (String::equal(tmp, "numeric"))
1948 return KeyBinding::NUMERIC;
1949
1950 char buffer[MESSAGE_SIZE];
1951
1952 sprintf(buffer,
1953 "Illegal value for %s.VALUETYPE attribute; "
1954 "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",
1955 elementName);
1956
1957 throw XmlSemanticError(lineNumber, buffer);
1958 return KeyBinding::BOOLEAN;
1959 }
1960
1961 mike 1.23 //------------------------------------------------------------------------------
1962 //
1963 // getKeyValueElement()
1964 //
1965 // <!ELEMENT KEYVALUE (#PCDATA)>
1966 // <!ATTLIST KEYVALUE
1967 // VALUETYPE (string|boolean|numeric) 'string'>
1968 //
1969 //------------------------------------------------------------------------------
1970
1971 Boolean XmlReader::getKeyValueElement(
1972 XmlParser& parser,
1973 KeyBinding::Type& type,
1974 String& value)
1975 {
1976 XmlEntry entry;
1977
1978 if (!testStartTagOrEmptyTag(parser, entry, "KEYVALUE"))
1979 return false;
1980
1981 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1982 mike 1.23
1983 type = getValueTypeAttribute(parser.getLine(), entry, "KEYVALUE");
1984
1985 value.clear();
1986
1987 if (!empty)
1988 {
1989 if (!parser.next(entry))
1990 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
1991
1992 if (entry.type == XmlEntry::CONTENT)
1993 value = entry.text;
1994 else
1995 parser.putBack(entry);
1996
1997 expectEndTag(parser, "KEYVALUE");
1998 }
1999
2000 return true;
2001 }
2002
2003 mike 1.23 //------------------------------------------------------------------------------
2004 //
2005 // getKeyBindingElement()
2006 //
2007 // <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>
2008 // <!ATTLIST KEYBINDING
2009 // %CIMName;>
2010 //
2011 //------------------------------------------------------------------------------
2012
2013 Boolean XmlReader::getKeyBindingElement(
2014 XmlParser& parser,
2015 String& name,
2016 String& value,
2017 KeyBinding::Type& type)
2018 {
2019 XmlEntry entry;
2020
2021 if (!testStartTag(parser, entry, "KEYBINDING"))
2022 return false;
2023
2024 mike 1.23 name = getCimNameAttribute(parser.getLine(), entry, "KEYBINDING");
2025
2026 if (!getKeyValueElement(parser, type, value))
|
2027 mike 1.25 {
|
2028 kumpf 1.54 CIMObjectPath reference;
|
2029 mike 1.25
2030 if (!getValueReferenceElement(parser, reference))
2031 {
2032 throw XmlValidationError(parser.getLine(),
2033 "Expected KEYVALUE or VALUE.REFERENCE element");
2034 }
2035
2036 type = KeyBinding::REFERENCE;
2037 value = reference.toString();
2038 }
|
2039 mike 1.23
2040 expectEndTag(parser, "KEYBINDING");
2041 return true;
2042 }
2043
2044 //------------------------------------------------------------------------------
2045 //
2046 // getInstanceNameElement()
2047 //
2048 // <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
2049 // <!ATTLIST INSTANCENAME
2050 // %ClassName;>
2051 //
|
2052 mike 1.25 // Note: An empty key name is used in the keyBinding when the INSTANCENAME is
2053 // specified using a KEYVALUE or a VALUE.REFERENCE.
|
2054 mike 1.23 //
2055 //------------------------------------------------------------------------------
2056
2057 Boolean XmlReader::getInstanceNameElement(
2058 XmlParser& parser,
2059 String& className,
2060 Array<KeyBinding>& keyBindings)
2061 {
2062 className.clear();
2063 keyBindings.clear();
2064
2065 XmlEntry entry;
2066
2067 if (!testStartTagOrEmptyTag(parser, entry, "INSTANCENAME"))
2068 return false;
2069
2070 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2071
2072 className = getClassNameAttribute(parser.getLine(), entry, "INSTANCENAME");
2073
|
2074 mike 1.25 if (empty)
|
2075 mike 1.23 {
|
2076 mike 1.25 return true;
2077 }
|
2078 mike 1.23
|
2079 mike 1.25 String name;
2080 KeyBinding::Type type;
2081 String value;
|
2082 kumpf 1.54 CIMObjectPath reference;
|
2083 mike 1.25
2084 if (getKeyValueElement(parser, type, value))
2085 {
2086 // Use empty key name because none was specified
2087 keyBindings.append(KeyBinding(name, value, type));
2088 }
2089 else if (getValueReferenceElement(parser, reference))
2090 {
2091 // Use empty key name because none was specified
2092 type = KeyBinding::REFERENCE;
2093 value = reference.toString();
2094 keyBindings.append(KeyBinding(name, value, type));
2095 }
2096 else
2097 {
|
2098 mike 1.23 while (getKeyBindingElement(parser, name, value, type))
2099 keyBindings.append(KeyBinding(name, value, type));
|
2100 mike 1.25 }
|
2101 mike 1.23
|
2102 mike 1.25 expectEndTag(parser, "INSTANCENAME");
|
2103 mike 1.23
2104 return true;
2105 }
2106
2107 Boolean XmlReader::getInstanceNameElement(
2108 XmlParser& parser,
|
2109 kumpf 1.54 CIMObjectPath& instanceName)
|
2110 mike 1.23 {
2111 String className;
2112 Array<KeyBinding> keyBindings;
2113
2114 if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
2115 return false;
2116
2117 instanceName.set(String(), String(), className, keyBindings);
2118 return true;
2119 }
2120
2121 //------------------------------------------------------------------------------
2122 //
2123 // getInstancePathElement()
2124 //
2125 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2126 //
2127 //------------------------------------------------------------------------------
2128
2129 Boolean XmlReader::getInstancePathElement(
2130 XmlParser& parser,
|
2131 kumpf 1.54 CIMObjectPath& reference)
|
2132 mike 1.23 {
2133 XmlEntry entry;
2134
2135 if (!testStartTag(parser, entry, "INSTANCEPATH"))
2136 return false;
2137
2138 String host;
2139 String nameSpace;
2140
2141 if (!getNameSpacePathElement(parser, host, nameSpace))
2142 {
2143 throw XmlValidationError(parser.getLine(),
2144 "expected NAMESPACEPATH element");
2145 }
2146
2147 String className;
2148 Array<KeyBinding> keyBindings;
2149
2150 if (!getInstanceNameElement(parser, className, keyBindings))
2151 {
2152 throw XmlValidationError(parser.getLine(),
2153 mike 1.23 "expected INSTANCENAME element");
2154 }
2155
2156 reference.set(host, nameSpace, className, keyBindings);
2157
2158 expectEndTag(parser, "INSTANCEPATH");
2159 return true;
2160 }
2161
2162 //------------------------------------------------------------------------------
2163 //
2164 // getLocalInstancePathElement()
2165 //
2166 // <!ELEMENT LOCALINSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2167 //
2168 //------------------------------------------------------------------------------
2169
2170 Boolean XmlReader::getLocalInstancePathElement(
2171 XmlParser& parser,
|
2172 kumpf 1.54 CIMObjectPath& reference)
|
2173 mike 1.23 {
2174 XmlEntry entry;
2175
2176 if (!testStartTag(parser, entry, "LOCALINSTANCEPATH"))
2177 return false;
2178
2179 String nameSpace;
2180
2181 if (!getLocalNameSpacePathElement(parser, nameSpace))
2182 {
2183 throw XmlValidationError(parser.getLine(),
2184 "expected LOCALNAMESPACEPATH element");
2185 }
2186
2187 String className;
2188 Array<KeyBinding> keyBindings;
2189
2190 if (!getInstanceNameElement(parser, className, keyBindings))
2191 {
2192 throw XmlValidationError(parser.getLine(),
2193 "expected INSTANCENAME element");
2194 mike 1.23 }
2195
2196 reference.set(String(), nameSpace, className, keyBindings);
2197
2198 expectEndTag(parser, "LOCALINSTANCEPATH");
2199 return true;
2200 }
2201
2202 //------------------------------------------------------------------------------
2203 //
2204 // getClassPathElement()
2205 //
2206 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
2207 //
2208 //------------------------------------------------------------------------------
2209
2210 Boolean XmlReader::getClassPathElement(
2211 XmlParser& parser,
|
2212 kumpf 1.54 CIMObjectPath& reference)
|
2213 mike 1.23 {
2214 XmlEntry entry;
2215
2216 if (!testStartTag(parser, entry, "CLASSPATH"))
2217 return false;
2218
2219 String host;
2220 String nameSpace;
2221
2222 if (!getNameSpacePathElement(parser, host, nameSpace))
2223 {
2224 throw XmlValidationError(parser.getLine(),
2225 "expected NAMESPACEPATH element");
2226 }
2227
2228 String className;
2229
2230 if (!getClassNameElement(parser, className))
2231 {
2232 throw XmlValidationError(parser.getLine(),
2233 "expected CLASSNAME element");
2234 mike 1.23 }
2235
2236 reference.set(host, nameSpace, className);
2237
2238 expectEndTag(parser, "CLASSPATH");
2239 return true;
2240 }
2241
2242 //------------------------------------------------------------------------------
2243 //
2244 // getLocalClassPathElement()
2245 //
2246 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH,CLASSNAME)>
2247 //
2248 //------------------------------------------------------------------------------
2249
2250 Boolean XmlReader::getLocalClassPathElement(
2251 XmlParser& parser,
|
2252 kumpf 1.54 CIMObjectPath& reference)
|
2253 mike 1.23 {
2254 XmlEntry entry;
2255
2256 if (!testStartTag(parser, entry, "LOCALCLASSPATH"))
2257 return false;
2258
2259 String nameSpace;
2260
2261 if (!getLocalNameSpacePathElement(parser, nameSpace))
2262 {
2263 throw XmlValidationError(parser.getLine(),
2264 "expected LOCALNAMESPACEPATH element");
2265 }
2266
2267 String className;
2268
2269 if (!getClassNameElement(parser, className))
2270 {
2271 throw XmlValidationError(parser.getLine(),
2272 "expected CLASSNAME element");
2273 }
2274 mike 1.23
2275 reference.set(String(), nameSpace, className);
2276
2277 expectEndTag(parser, "LOCALCLASSPATH");
2278
2279 return true;
2280 }
2281
2282 //------------------------------------------------------------------------------
2283 //
2284 // getValueReferenceElement()
2285 //
2286 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
2287 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
2288 //
2289 //
2290 //------------------------------------------------------------------------------
2291
2292 Boolean XmlReader::getValueReferenceElement(
2293 XmlParser& parser,
|
2294 kumpf 1.54 CIMObjectPath& reference)
|
2295 mike 1.23 {
2296 XmlEntry entry;
2297
2298 if (!testStartTag(parser, entry, "VALUE.REFERENCE"))
2299 return false;
2300
2301 if (!parser.next(entry))
2302 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
2303
2304 if (entry.type != XmlEntry::START_TAG &&
2305 entry.type != XmlEntry::EMPTY_TAG)
2306 {
2307 throw XmlValidationError(parser.getLine(),
2308 "Expected one of the following start tags: "
2309 "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "
2310 "LOCALINSTANCEPATH, INSTANCENAME");
2311 }
2312
2313 if (strcmp(entry.text, "CLASSPATH") == 0)
2314 {
2315 parser.putBack(entry);
2316 mike 1.23 getClassPathElement(parser, reference);
2317 }
2318 else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)
2319 {
2320 parser.putBack(entry);
2321 getLocalClassPathElement(parser, reference);
2322 }
2323 else if (strcmp(entry.text, "CLASSNAME") == 0)
2324 {
2325 parser.putBack(entry);
2326 String className;
2327 getClassNameElement(parser, className);
2328 reference.set(String(), String(), className);
2329 }
2330 else if (strcmp(entry.text, "INSTANCEPATH") == 0)
2331 {
2332 parser.putBack(entry);
2333 getInstancePathElement(parser, reference);
2334 }
2335 else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)
2336 {
2337 mike 1.23 parser.putBack(entry);
2338 getLocalInstancePathElement(parser, reference);
2339 }
2340 else if (strcmp(entry.text, "INSTANCENAME") == 0)
2341 {
2342 parser.putBack(entry);
2343 String className;
2344 Array<KeyBinding> keyBindings;
2345 getInstanceNameElement(parser, className, keyBindings);
2346 reference.set(String(), String(), className, keyBindings);
2347 }
2348
2349 expectEndTag(parser, "VALUE.REFERENCE");
2350 return true;
2351 }
2352
2353 //------------------------------------------------------------------------------
2354 //
|
2355 kumpf 1.28 // getValueReferenceArrayElement()
2356 //
2357 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
2358 //
2359 //------------------------------------------------------------------------------
2360
2361 Boolean XmlReader::getValueReferenceArrayElement(
2362 XmlParser& parser,
2363 CIMValue& value)
2364 {
2365 XmlEntry entry;
|
2366 kumpf 1.54 Array<CIMObjectPath> referenceArray;
2367 CIMObjectPath reference;
|
2368 kumpf 1.28
2369 value.clear();
2370
2371 // Get VALUE.REFARRAY open tag:
2372
2373 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.REFARRAY"))
2374 return false;
2375
|
2376 kumpf 1.32 if (entry.type != XmlEntry::EMPTY_TAG)
2377 {
2378 // For each VALUE.REFERENCE element:
|
2379 kumpf 1.28
|
2380 kumpf 1.32 while (getValueReferenceElement(parser, reference))
2381 {
2382 referenceArray.append(reference);
2383 }
|
2384 kumpf 1.28
|
2385 kumpf 1.32 expectEndTag(parser, "VALUE.REFARRAY");
|
2386 kumpf 1.28 }
2387
2388 value.set(referenceArray);
2389 return true;
2390 }
2391
2392 //------------------------------------------------------------------------------
2393 //
|
2394 mike 1.23 // getPropertyReferenceElement()
2395 //
2396 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)>
2397 // <!ATTLIST PROPERTY.REFERENCE
2398 // %CIMName;
2399 // %ReferenceClass;
2400 // %ClassOrigin;
2401 // %Propagated;>
2402 //
2403 //------------------------------------------------------------------------------
2404
2405 Boolean XmlReader::getPropertyReferenceElement(
2406 XmlParser& parser,
2407 CIMProperty& property)
2408 {
2409 XmlEntry entry;
2410
2411 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.REFERENCE"))
2412 return false;
2413
2414 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2415 mike 1.23
2416 // Get PROPERTY.NAME attribute:
2417
2418 String name = getCimNameAttribute(
2419 parser.getLine(), entry, "PROPERTY.REFERENCE");
2420
2421 // Get PROPERTY.REFERENCECLASS attribute:
2422
2423 String referenceClass = getReferenceClassAttribute(
2424 parser.getLine(), entry, "PROPERTY.REFERENCE");
2425
2426 // Get PROPERTY.CLASSORIGIN attribute:
2427
2428 String classOrigin =
2429 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");
2430
2431 // Get PROPERTY.PROPAGATED
2432
2433 Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,
2434 "PROPERTY.REFERENCE", "PROPAGATED", false, false);
2435
2436 mike 1.23 // Create property:
2437
|
2438 kumpf 1.51 CIMValue value = CIMValue(CIMType::REFERENCE, false, 0);
|
2439 kumpf 1.54 // value.set(CIMObjectPath());
|
2440 mike 1.23 property = CIMProperty(
2441 name, value, 0, referenceClass, classOrigin, propagated);
2442
2443 if (!empty)
2444 {
2445 getQualifierElements(parser, property);
2446
|
2447 kumpf 1.54 CIMObjectPath reference;
|
2448 mike 1.23
2449 if (getValueReferenceElement(parser, reference))
2450 property.setValue(reference);
2451
2452 expectEndTag(parser, "PROPERTY.REFERENCE");
2453 }
2454
2455 return true;
2456 }
2457
2458 //------------------------------------------------------------------------------
2459 //
2460 // GetPropertyElements()
2461 //
2462 //------------------------------------------------------------------------------
2463
2464 template<class CONTAINER>
2465 void GetPropertyElements(XmlParser& parser, CONTAINER& container)
2466 {
2467 CIMProperty property;
2468
2469 mike 1.23 while (XmlReader::getPropertyElement(parser, property) ||
2470 XmlReader::getPropertyArrayElement(parser, property) ||
2471 XmlReader::getPropertyReferenceElement(parser, property))
2472 {
2473 try
2474 {
2475 container.addProperty(property);
2476 }
2477 catch (AlreadyExists&)
2478 {
2479 throw XmlSemanticError(parser.getLine(), "duplicate property");
2480 }
2481 }
2482 }
2483
2484 //------------------------------------------------------------------------------
2485 //
2486 // getParameterElement()
2487 //
2488 // <!ELEMENT PARAMETER (QUALIFIER*)>
2489 // <!ATTLIST PARAMETER
2490 mike 1.23 // %CIMName;
2491 // %CIMType; #REQUIRED>
2492 //
2493 //------------------------------------------------------------------------------
2494
2495 Boolean XmlReader::getParameterElement(
2496 XmlParser& parser,
2497 CIMParameter& parameter)
2498 {
2499 XmlEntry entry;
2500
2501 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER"))
2502 return false;
2503
2504 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2505
2506 // Get PARAMETER.NAME attribute:
2507
2508 String name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");
2509
2510 // Get PARAMETER.TYPE attribute:
2511 mike 1.23
2512 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PARAMETER");
2513
2514 // Create parameter:
2515
2516 parameter = CIMParameter(name, type);
2517
2518 if (!empty)
2519 {
2520 getQualifierElements(parser, parameter);
2521
2522 expectEndTag(parser, "PARAMETER");
2523 }
2524
2525 return true;
2526 }
2527
2528 //------------------------------------------------------------------------------
2529 //
2530 // getParameterArrayElement()
2531 //
2532 mike 1.23 // <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
2533 // <!ATTLIST PARAMETER.ARRAY
2534 // %CIMName;
2535 // %CIMType; #REQUIRED
2536 // %ArraySize;>
2537 //
2538 //------------------------------------------------------------------------------
2539
2540 Boolean XmlReader::getParameterArrayElement(
2541 XmlParser& parser,
2542 CIMParameter& parameter)
2543 {
2544 XmlEntry entry;
2545
2546 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.ARRAY"))
2547 return false;
2548
2549 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2550
2551 // Get PARAMETER.ARRAY.NAME attribute:
2552
2553 mike 1.23 String name = getCimNameAttribute(
2554 parser.getLine(), entry, "PARAMETER.ARRAY");
2555
2556 // Get PARAMETER.ARRAY.TYPE attribute:
2557
2558 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY");
2559
2560 // Get PARAMETER.ARRAYSIZE attribute:
2561
2562 Uint32 arraySize = 0;
2563 getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY",arraySize);
2564
2565 // Create parameter:
2566
2567 parameter = CIMParameter(name, type, true, arraySize);
2568
2569 if (!empty)
2570 {
2571 getQualifierElements(parser, parameter);
2572
2573 expectEndTag(parser, "PARAMETER.ARRAY");
2574 mike 1.23 }
2575
2576 return true;
2577 }
2578
2579 //------------------------------------------------------------------------------
2580 //
2581 // getParameterReferenceElement()
2582 //
2583 // <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
2584 // <!ATTLIST PARAMETER.REFERENCE
2585 // %CIMName;
2586 // %ReferenceClass;>
2587 //
2588 //------------------------------------------------------------------------------
2589
2590 Boolean XmlReader::getParameterReferenceElement(
2591 XmlParser& parser,
2592 CIMParameter& parameter)
2593 {
2594 XmlEntry entry;
2595 mike 1.23
2596 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFERENCE"))
2597 return false;
2598
2599 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2600
2601 // Get PARAMETER.NAME attribute:
2602
2603 String name = getCimNameAttribute(
2604 parser.getLine(), entry, "PARAMETER.REFERENCE");
2605
2606 // Get PARAMETER.REFERENCECLASS attribute:
2607
2608 String referenceClass = getReferenceClassAttribute(
2609 parser.getLine(), entry, "PARAMETER.REFERENCE");
2610
2611 // Create parameter:
2612
2613 parameter = CIMParameter(name, CIMType::REFERENCE, false, 0, referenceClass);
2614
2615 if (!empty)
2616 mike 1.23 {
2617 getQualifierElements(parser, parameter);
2618 expectEndTag(parser, "PARAMETER.REFERENCE");
2619 }
2620
2621 return true;
2622 }
2623
2624 //------------------------------------------------------------------------------
2625 //
|
2626 kumpf 1.26 // getParameterReferenceArrayElement()
2627 //
2628 // <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
2629 // <!ATTLIST PARAMETER.REFARRAY
2630 // %CIMName;
2631 // %ReferenceClass;
2632 // %ArraySize;>
2633 //
2634 //------------------------------------------------------------------------------
2635
2636 Boolean XmlReader::getParameterReferenceArrayElement(
2637 XmlParser& parser,
2638 CIMParameter& parameter)
2639 {
2640 XmlEntry entry;
2641
2642 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFARRAY"))
2643 return false;
2644
2645 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2646
2647 kumpf 1.26 // Get PARAMETER.NAME attribute:
2648
2649 String name = getCimNameAttribute(
2650 parser.getLine(), entry, "PARAMETER.REFARRAY");
2651
2652 // Get PARAMETER.REFERENCECLASS attribute:
2653
2654 String referenceClass = getReferenceClassAttribute(
2655 parser.getLine(), entry, "PARAMETER.REFARRAY");
2656
2657 // Get PARAMETER.ARRAYSIZE attribute:
2658
2659 Uint32 arraySize = 0;
2660 getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.REFARRAY",
2661 arraySize);
2662
2663 // Create parameter:
2664
2665 parameter = CIMParameter(name, CIMType::REFERENCE, true, arraySize,
2666 referenceClass);
2667
2668 kumpf 1.26 if (!empty)
2669 {
2670 getQualifierElements(parser, parameter);
2671 expectEndTag(parser, "PARAMETER.REFARRAY");
2672 }
2673
2674 return true;
2675 }
2676
2677 //------------------------------------------------------------------------------
2678 //
|
2679 mike 1.23 // GetParameterElements()
2680 //
2681 //------------------------------------------------------------------------------
2682
2683 template<class CONTAINER>
2684 void GetParameterElements(XmlParser& parser, CONTAINER& container)
2685 {
2686 CIMParameter parameter;
2687
2688 while (XmlReader::getParameterElement(parser, parameter) ||
2689 XmlReader::getParameterArrayElement(parser, parameter) ||
|
2690 kumpf 1.26 XmlReader::getParameterReferenceElement(parser, parameter) ||
2691 XmlReader::getParameterReferenceArrayElement(parser, parameter))
|
2692 mike 1.23 {
2693 try
2694 {
2695 container.addParameter(parameter);
2696 }
2697 catch (AlreadyExists&)
2698 {
2699 throw XmlSemanticError(parser.getLine(), "duplicate parameter");
2700 }
2701 }
2702 }
2703
2704 //------------------------------------------------------------------------------
2705 //
2706 // getQualifierDeclElement()
2707 //
2708 // <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
2709 // <!ATTLIST QUALIFIER.DECLARATION
2710 // %CIMName;
2711 // %CIMType; #REQUIRED
2712 // ISARRAY (true|false) #IMPLIED
2713 mike 1.23 // %ArraySize;
2714 // %QualifierFlavor;>
2715 //
2716 //------------------------------------------------------------------------------
2717
2718 Boolean XmlReader::getQualifierDeclElement(
2719 XmlParser& parser,
2720 CIMQualifierDecl& qualifierDecl)
2721 {
2722 XmlEntry entry;
2723
2724 if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER.DECLARATION"))
2725 return false;
2726
2727 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2728
2729 // Get NAME attribute:
2730
2731 String name = getCimNameAttribute(
2732 parser.getLine(), entry, "QUALIFIER.DECLARATION");
2733
2734 mike 1.23 // Get TYPE attribute:
2735
2736 CIMType type = getCimTypeAttribute(
2737 parser.getLine(), entry, "QUALIFIER.DECLARATION");
2738
2739 // Get ISARRAY attribute:
2740
|
2741 mike 1.25 Boolean isArray = getCimBooleanAttribute(
2742 parser.getLine(), entry, "QUALIFIER.DECLARATION", "ISARRAY",
2743 false, false);
|
2744 mike 1.23
2745 // Get ARRAYSIZE attribute:
2746
2747 Uint32 arraySize = 0;
2748 Boolean gotArraySize = getArraySizeAttribute(parser.getLine(),
2749 entry, "QUALIFIER.DECLARATION", arraySize);
2750
2751 // Get flavor oriented attributes:
2752
2753 Uint32 flavor = getFlavor(entry,parser.getLine(), "QUALIFIER.DECLARATION");
2754
2755 // No need to look for interior elements if empty tag:
2756
2757 Uint32 scope = CIMScope::NONE;
2758 CIMValue value;
2759
2760 if (!empty)
2761 {
2762 // Get the option SCOPE element:
2763
2764 scope = getOptionalScope(parser);
2765 mike 1.23
2766 // Get VALUE or VALUE.ARRAY element:
2767
2768 if (getValueArrayElement(parser, type, value))
2769 {
2770 if (!isArray)
2771 {
2772 throw XmlSemanticError(parser.getLine(),
2773 "VALUE.ARRAY element encountered without "
2774 "ISARRAY attribute");
2775 }
2776
2777 if (arraySize && arraySize != value.getArraySize())
2778 {
2779 throw XmlSemanticError(parser.getLine(),
2780 "VALUE.ARRAY size is not the same as "
2781 "ARRAYSIZE attribute");
2782 }
2783 }
2784 else if (getValueElement(parser, type, value))
2785 {
2786 mike 1.23 if (isArray)
2787 {
2788 throw XmlSemanticError(parser.getLine(),
2789 "ISARRAY attribute used but VALUE element encountered");
2790 }
2791 }
2792
2793 // Now get the closing tag:
2794
2795 expectEndTag(parser, "QUALIFIER.DECLARATION");
2796 }
2797
2798 if (value.getType() == CIMType::NONE)
2799 {
2800 if (isArray)
2801 value.setNullValue(type, true, arraySize);
2802 else
2803 value.setNullValue(type, false);
2804 }
2805
2806 CIMQualifierDecl tmp(name, value, scope, flavor, arraySize);
2807 mike 1.23 qualifierDecl = CIMQualifierDecl(name, value, scope, flavor, arraySize);
2808 return true;
2809 }
2810
2811 //------------------------------------------------------------------------------
2812 // getMethodElement()
2813 //
2814 // <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|
2815 // PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
2816 // <!ATTLIST METHOD
2817 // %CIMName;
2818 // %CIMType; #IMPLIED
2819 // %ClassOrigin;
2820 // %Propagated;>
2821 //
2822 //------------------------------------------------------------------------------
2823
2824 Boolean XmlReader::getMethodElement(XmlParser& parser, CIMMethod& method)
2825 {
2826 XmlEntry entry;
2827
2828 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "METHOD"))
2829 return false;
2830
2831 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2832
2833 String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
2834
2835 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");
2836
2837 String classOrigin =
2838 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
2839
2840 Boolean propagated = getCimBooleanAttribute(
2841 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
2842
2843 method = CIMMethod(name, type, classOrigin, propagated);
2844
2845 if (!empty)
2846 {
|
2847 kumpf 1.26 // ATTN-RK-P2-20020219: Decoding algorithm must not depend on the
2848 // ordering of qualifiers and parameters.
|
2849 mike 1.23 getQualifierElements(parser, method);
2850
2851 GetParameterElements(parser, method);
2852
2853 expectEndTag(parser, "METHOD");
2854 }
2855
2856 return true;
2857 }
2858
2859 //------------------------------------------------------------------------------
2860 // getClassElement()
2861 //
2862 // <!ELEMENT CLASS (QUALIFIER*,
2863 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
2864 // <!ATTLIST CLASS %CIMName; %SuperClass;>
2865 //
2866 //------------------------------------------------------------------------------
2867
2868 Boolean XmlReader::getClassElement(XmlParser& parser, CIMClass& cimClass)
2869 {
2870 mike 1.23 XmlEntry entry;
2871
2872 if (!testStartTag(parser, entry, "CLASS"))
2873 return false;
2874
2875 String name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
2876
2877 String superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");
2878
2879 cimClass = CIMClass(name, superClass);
2880
2881 // Get QUALIFIER elements:
2882
2883 getQualifierElements(parser, cimClass);
2884
2885 // Get PROPERTY elements:
2886
2887 GetPropertyElements(parser, cimClass);
2888
2889 // Get METHOD elements:
2890
2891 mike 1.23 CIMMethod method;
2892
2893 while (getMethodElement(parser, method))
2894 cimClass.addMethod(method);
2895
2896 // Get CLASS end tag:
2897
2898 expectEndTag(parser, "CLASS");
2899
2900 return true;
2901 }
2902
2903 //------------------------------------------------------------------------------
2904 // getInstanceElement()
2905 //
2906 // <!ELEMENT INSTANCE (QUALIFIER*,
2907 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*) >
2908 // <!ATTLIST INSTANCE
2909 // %ClassName;>
2910 //
2911 //------------------------------------------------------------------------------
2912 mike 1.23
2913 Boolean XmlReader::getInstanceElement(
2914 XmlParser& parser,
2915 CIMInstance& cimInstance)
2916 {
2917 XmlEntry entry;
2918
2919 if (!testStartTag(parser, entry, "INSTANCE"))
2920 return false;
2921
2922 String className = getClassNameAttribute(
2923 parser.getLine(), entry, "INSTANCE");
2924
2925 cimInstance = CIMInstance(className);
2926
2927 // Get QUALIFIER elements:
2928
2929 getQualifierElements(parser, cimInstance);
2930
2931 // Get PROPERTY elements:
2932
2933 mike 1.23 GetPropertyElements(parser, cimInstance);
2934
2935 // Get INSTANCE end tag:
2936
2937 expectEndTag(parser, "INSTANCE");
2938
2939 return true;
2940 }
2941
2942 //------------------------------------------------------------------------------
|
2943 mike 1.25 // getNamedInstanceElement()
2944 //
2945 // <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
2946 //
2947 //------------------------------------------------------------------------------
2948
2949 Boolean XmlReader::getNamedInstanceElement(
2950 XmlParser& parser,
|
2951 kumpf 1.55 CIMInstance& namedInstance)
|
2952 mike 1.25 {
2953 XmlEntry entry;
2954
2955 if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))
2956 return false;
2957
|
2958 kumpf 1.54 CIMObjectPath instanceName;
|
2959 mike 1.25
2960 // Get INSTANCENAME elements:
2961
2962 if (!getInstanceNameElement(parser, instanceName))
2963 {
2964 throw XmlValidationError(parser.getLine(),
2965 "expected INSTANCENAME element");
2966 }
2967
2968 // Get INSTANCE elements:
2969
|
2970 kumpf 1.55 if (!getInstanceElement(parser, namedInstance))
|
2971 mike 1.25 {
2972 throw XmlValidationError(parser.getLine(),
2973 "expected INSTANCE element");
2974 }
2975
2976 // Get VALUE.NAMEDINSTANCE end tag:
2977
2978 expectEndTag(parser, "VALUE.NAMEDINSTANCE");
2979
|
2980 kumpf 1.55 namedInstance.setPath (instanceName);
|
2981 mike 1.25
2982 return true;
2983 }
2984
2985 //------------------------------------------------------------------------------
|
2986 mike 1.23 //
2987 // getObject()
2988 //
2989 //------------------------------------------------------------------------------
2990
2991 void XmlReader::getObject(XmlParser& parser, CIMClass& x)
2992 {
2993 if (!getClassElement(parser, x))
2994 {
2995 throw XmlValidationError(parser.getLine(),
2996 "expected CLASS element");
2997 }
2998 }
2999
3000 //------------------------------------------------------------------------------
3001 //
3002 // getObject()
3003 //
3004 //------------------------------------------------------------------------------
3005
3006 void XmlReader::getObject(XmlParser& parser, CIMInstance& x)
3007 mike 1.23 {
3008 if (!getInstanceElement(parser, x))
3009 {
3010 throw XmlValidationError(parser.getLine(),
3011 "expected INSTANCE element");
3012 }
3013 }
3014
3015 //------------------------------------------------------------------------------
3016 //
3017 // getObject()
3018 //
3019 //------------------------------------------------------------------------------
3020
3021 void XmlReader::getObject(XmlParser& parser, CIMQualifierDecl& x)
3022 {
3023 if (!getQualifierDeclElement(parser, x))
3024 {
3025 throw XmlValidationError(parser.getLine(),
3026 "expected QUALIFIER.DECLARATION element");
3027 }
3028 mike 1.23 }
3029
3030 //------------------------------------------------------------------------------
3031 //
3032 // getMessageStartTag()
3033 //
3034 //------------------------------------------------------------------------------
3035
3036 Boolean XmlReader::getMessageStartTag(
3037 XmlParser& parser,
3038 String& id,
|
3039 kumpf 1.34 String& protocolVersion)
|
3040 mike 1.23 {
3041 XmlEntry entry;
3042
3043 if (!testStartTag(parser, entry, "MESSAGE"))
3044 return false;
3045
3046 // Get MESSAGE.ID:
3047
3048 if (!entry.getAttributeValue("ID", id))
3049 throw XmlValidationError(parser.getLine(),
3050 "Bad or missing MESSAGE.ID attribute");
3051
3052 // Get MESSAGE.PROTOCOLVERSION:
3053
3054 if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))
3055 throw XmlValidationError(parser.getLine(),
3056 "Bad or missing MESSAGE.PROTOCOLVERSION attribute");
3057
3058 return true;
3059 }
3060
3061 mike 1.23 //------------------------------------------------------------------------------
3062 //
3063 // getIMethodCallStartTag()
3064 //
3065 //------------------------------------------------------------------------------
3066
3067 Boolean XmlReader::getIMethodCallStartTag(
3068 XmlParser& parser,
3069 const char*& name)
3070 {
3071 XmlEntry entry;
3072
3073 if (!testStartTag(parser, entry, "IMETHODCALL"))
3074 return false;
3075
3076 // Get IMETHODCALL.NAME attribute:
3077
3078 if (!entry.getAttributeValue("NAME", name))
3079 throw XmlValidationError(parser.getLine(),
3080 "Missing IMETHODCALL.NAME attribute");
3081
3082 mike 1.23 return true;
3083 }
3084
3085 //------------------------------------------------------------------------------
3086 //
3087 // getIMethodResponseStartTag()
3088 //
3089 //------------------------------------------------------------------------------
3090
3091 Boolean XmlReader::getIMethodResponseStartTag(
3092 XmlParser& parser,
3093 const char*& name)
3094 {
3095 XmlEntry entry;
3096
3097 if (!testStartTag(parser, entry, "IMETHODRESPONSE"))
3098 return false;
3099
3100 // Get IMETHODRESPONSE.NAME attribute:
3101
3102 if (!entry.getAttributeValue("NAME", name))
3103 mike 1.23 throw XmlValidationError(parser.getLine(),
3104 "Missing IMETHODRESPONSE.NAME attribute");
3105
3106 return true;
3107 }
3108
3109 //------------------------------------------------------------------------------
3110 //
3111 // getIParamValueTag()
3112 //
3113 //------------------------------------------------------------------------------
3114
3115 Boolean XmlReader::getIParamValueTag(
3116 XmlParser& parser,
3117 const char*& name)
3118 {
3119 XmlEntry entry;
3120
3121 if (!testStartTag(parser, entry, "IPARAMVALUE"))
3122 return false;
3123
3124 mike 1.23 // Get IPARAMVALUE.NAME attribute:
3125
3126 if (!entry.getAttributeValue("NAME", name))
3127 throw XmlValidationError(parser.getLine(),
3128 "Missing IPARAMVALUE.NAME attribute");
3129
3130 return true;
3131 }
3132
3133 //------------------------------------------------------------------------------
3134 //
3135 // getBooleanValueElement()
3136 //
3137 // Get an elements like: "<VALUE>FALSE</VALUE>"
3138 //
3139 //------------------------------------------------------------------------------
3140
3141 Boolean XmlReader::getBooleanValueElement(
3142 XmlParser& parser,
3143 Boolean& result,
3144 Boolean required)
3145 mike 1.23 {
3146 XmlEntry entry;
3147
3148 if (!testStartTag(parser, entry, "VALUE"))
3149 {
3150 if (required)
3151 {
3152 throw XmlValidationError(parser.getLine(),
3153 "Expected VALUE element");
3154 }
3155 return false;
3156 }
3157
3158 expectContentOrCData(parser, entry);
3159
|
3160 mike 1.25 if (CompareNoCase(entry.text, "TRUE") == 0)
|
3161 mike 1.23 result = true;
|
3162 mike 1.25 else if (CompareNoCase(entry.text, "FALSE") == 0)
|
3163 mike 1.23 result = false;
3164 else
3165 throw XmlSemanticError(parser.getLine(),
3166 "Bad value for VALUE element: must be \"TRUE\" or \"FALSE\"");
3167
3168 expectEndTag(parser, "VALUE");
3169
3170 return true;
3171 }
3172
3173 //------------------------------------------------------------------------------
3174 //
3175 // getErrorElement()
3176 //
3177 // <!ELEMENT ERROR EMPTY>
3178 // <!ATTLIST ERROR
3179 // CODE CDATA #REQUIRED
3180 // DESCRIPTION CDATA #IMPLIED>
3181 //
3182 //------------------------------------------------------------------------------
3183
3184 mike 1.23 Boolean XmlReader::getErrorElement(
3185 XmlParser& parser,
|
3186 kumpf 1.50 CIMException& cimException,
|
3187 mike 1.23 Boolean required)
3188 {
3189 XmlEntry entry;
3190
3191 if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))
3192 {
3193 if (required)
3194 throw XmlValidationError(parser.getLine(),"Expected ERROR element");
3195 return false;
3196 }
3197
3198 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3199
3200 // Get ERROR.CODE
3201
3202 Uint32 tmpCode;
3203
3204 if (!entry.getAttributeValue("CODE", tmpCode))
3205 throw XmlValidationError(
3206 parser.getLine(), "missing ERROR.CODE attribute");
3207
|
3208 kumpf 1.50 // Get ERROR.DESCRIPTION:
|
3209 mike 1.23
|
3210 kumpf 1.50 String tmpDescription;
|
3211 mike 1.23
|
3212 kumpf 1.50 entry.getAttributeValue("DESCRIPTION", tmpDescription);
|
3213 mike 1.23
3214 if (!empty)
3215 expectEndTag(parser, "ERROR");
3216
|
3217 kumpf 1.50 cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);
|
3218 mike 1.23 return true;
3219 }
3220
3221
3222 //------------------------------------------------------------------------------
|
3223 kumpf 1.48 // getValueObjectElement()
3224 //
3225 // <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>
3226 //
3227 //------------------------------------------------------------------------------
3228
3229 Boolean XmlReader::getValueObjectElement(
3230 XmlParser& parser,
3231 CIMObject& object)
3232 {
3233 XmlEntry entry;
3234
3235 if (!testStartTag(parser, entry, "VALUE.OBJECT"))
3236 return false;
3237
3238 CIMInstance cimInstance;
3239 CIMClass cimClass;
3240
3241 if (XmlReader::getInstanceElement(parser, cimInstance))
3242 {
3243 object = CIMObject(cimInstance);
3244 kumpf 1.48 }
3245 else if (!XmlReader::getClassElement(parser, cimClass))
3246 {
3247 object = CIMObject(cimClass);
3248 }
3249 else
3250 {
3251 throw XmlValidationError(parser.getLine(),
3252 "Expected INSTANCE or CLASS element");
3253 }
3254
3255 expectEndTag(parser, "VALUE.OBJECT");
3256
3257 return true;
3258 }
3259
3260 //------------------------------------------------------------------------------
3261 // getValueObjectWithPathElement()
|
3262 mike 1.23 //
3263 // <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
3264 //
3265 //------------------------------------------------------------------------------
3266
|
3267 kumpf 1.48 Boolean XmlReader::getValueObjectWithPathElement(
|
3268 mike 1.23 XmlParser& parser,
3269 CIMObjectWithPath& objectWithPath)
3270 {
3271 XmlEntry entry;
3272
3273 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))
3274 return false;
3275
|
3276 kumpf 1.54 CIMObjectPath reference;
|
3277 mike 1.23 Boolean isInstance = false;
3278
3279 if (XmlReader::getInstancePathElement(parser, reference))
3280 isInstance = true;
3281 else if (!XmlReader::getClassPathElement(parser, reference))
3282 {
|
3283 kumpf 1.48 throw XmlValidationError(parser.getLine(),
3284 "Expected INSTANCEPATH or CLASSPATH element");
|
3285 mike 1.23 }
3286
3287 if (isInstance)
3288 {
3289 CIMInstance cimInstance;
3290
3291 if (!XmlReader::getInstanceElement(parser, cimInstance))
3292 {
3293 throw XmlValidationError(parser.getLine(),
|
3294 kumpf 1.48 "Expected INSTANCE element");
|
3295 mike 1.23 }
3296 objectWithPath.set(reference, CIMObject(cimInstance));
3297 }
3298 else
3299 {
3300 CIMClass cimClass;
3301
3302 if (!XmlReader::getClassElement(parser, cimClass))
3303 {
3304 throw XmlValidationError(parser.getLine(),
3305 "Expected CLASS element");
3306 }
3307 objectWithPath.set(reference, CIMObject(cimClass));
3308 }
3309
3310 expectEndTag(parser, "VALUE.OBJECTWITHPATH");
3311
3312 return true;
|
3313 kumpf 1.48 }
3314
3315 //------------------------------------------------------------------------------
3316 // getValueObjectWithLocalPathElement()
3317 //
3318 // <!ELEMENT VALUE.OBJECTWITHLOCALPATH
3319 // ((LOCALCLASSPATH,CLASS)|(LOCALINSTANCEPATH,INSTANCE))>
3320 //
3321 //------------------------------------------------------------------------------
3322
3323 Boolean XmlReader::getValueObjectWithLocalPathElement(
3324 XmlParser& parser,
3325 CIMObjectWithPath& objectWithPath)
3326 {
3327 XmlEntry entry;
3328
3329 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))
3330 return false;
3331
|
3332 kumpf 1.54 CIMObjectPath reference;
|
3333 kumpf 1.48 Boolean isInstance = false;
3334
3335 if (XmlReader::getLocalInstancePathElement(parser, reference))
3336 isInstance = true;
3337 else if (!XmlReader::getLocalClassPathElement(parser, reference))
3338 {
3339 throw XmlValidationError(parser.getLine(),
3340 "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");
3341 }
3342
3343 if (isInstance)
3344 {
3345 CIMInstance cimInstance;
3346
3347 if (!XmlReader::getInstanceElement(parser, cimInstance))
3348 {
3349 throw XmlValidationError(parser.getLine(),
3350 "Expected INSTANCE element");
3351 }
3352 objectWithPath.set(reference, CIMObject(cimInstance));
3353 }
3354 kumpf 1.48 else
3355 {
3356 CIMClass cimClass;
3357
3358 if (!XmlReader::getClassElement(parser, cimClass))
3359 {
3360 throw XmlValidationError(parser.getLine(),
3361 "Expected CLASS element");
3362 }
3363 objectWithPath.set(reference, CIMObject(cimClass));
3364 }
3365
3366 expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");
3367
3368 return true;
3369 }
3370
3371 //------------------------------------------------------------------------------
3372 // getObjectArray()
3373 //
3374 // <object>
3375 kumpf 1.48 // (VALUE.OBJECT|VALUE.OBJECTWITHLOCALPATH|VALUE.OBJECTWITHPATH)
3376 //
3377 //------------------------------------------------------------------------------
3378
3379 void XmlReader::getObjectArray(
3380 XmlParser& parser,
3381 Array<CIMObjectWithPath>& objectArray)
3382 {
3383 CIMObject object;
3384 CIMObjectWithPath objectWithPath;
3385
3386 objectArray.clear();
3387
3388 if (getValueObjectElement(parser, object))
3389 {
|
3390 kumpf 1.54 objectArray.append(CIMObjectWithPath(CIMObjectPath(), object));
|
3391 kumpf 1.48 while (getValueObjectElement(parser, object))
|
3392 kumpf 1.54 objectArray.append(CIMObjectWithPath(CIMObjectPath(), object));
|
3393 kumpf 1.48 }
3394 else if (getValueObjectWithPathElement(parser, objectWithPath))
3395 {
3396 objectArray.append(objectWithPath);
3397 while (getValueObjectWithPathElement(parser, objectWithPath))
3398 objectArray.append(objectWithPath);
3399 }
3400 else if (getValueObjectWithLocalPathElement(parser, objectWithPath))
3401 {
3402 objectArray.append(objectWithPath);
3403 while (getValueObjectWithLocalPathElement(parser, objectWithPath))
3404 objectArray.append(objectWithPath);
3405 }
|
3406 mike 1.23 }
3407
3408 //------------------------------------------------------------------------------
3409 //
3410 // <objectName>: (CLASSNAME|INSTANCENAME)
3411 //
3412 //------------------------------------------------------------------------------
3413
3414 Boolean XmlReader::getObjectNameElement(
3415 XmlParser& parser,
|
3416 kumpf 1.54 CIMObjectPath& objectName)
|
3417 mike 1.23 {
3418 String className;
3419
3420 if (getClassNameElement(parser, className, false))
3421 {
3422 objectName.set(String(), String(), className);
3423 return true;
3424 }
3425 else if (getInstanceNameElement(parser, objectName))
3426 return true;
3427 else
3428 {
3429 throw XmlValidationError(parser.getLine(),
3430 "expected CLASSNAME or INSTANCENAME element");
3431 }
3432
3433 return false;
3434 }
3435
3436 //------------------------------------------------------------------------------
3437 //
3438 mike 1.23 // <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>
3439 //
3440 //------------------------------------------------------------------------------
3441
3442 Boolean XmlReader::getObjectPathElement(
3443 XmlParser& parser,
|
3444 kumpf 1.54 CIMObjectPath& objectPath)
|
3445 mike 1.23 {
3446 XmlEntry entry;
3447
3448 if (!testStartTag(parser, entry, "OBJECTPATH"))
3449 return false;
3450
3451 if (getClassPathElement(parser, objectPath))
3452 {
3453 expectEndTag(parser, "OBJECTPATH");
3454 return true;
3455 }
3456 else if (getInstancePathElement(parser, objectPath))
3457 {
3458 expectEndTag(parser, "OBJECTPATH");
3459 return true;
3460 }
3461 else
3462 {
3463 throw XmlValidationError(parser.getLine(),
3464 "expected INSTANCEPATH or CLASSPATH element");
3465 }
3466 mike 1.23
|
3467 mike 1.24 PEGASUS_UNREACHABLE ( return false; )
|
3468 mike 1.25 }
3469
3470 //------------------------------------------------------------------------------
3471 //
3472 // getEMethodCallStartTag()
3473 //
3474 //------------------------------------------------------------------------------
3475
3476 Boolean XmlReader::getEMethodCallStartTag(
3477 XmlParser& parser,
3478 const char*& name)
3479 {
3480 XmlEntry entry;
3481
3482 if (!testStartTag(parser, entry, "EXPMETHODCALL"))
3483 return false;
3484
3485 // Get EXPMETHODCALL.NAME attribute:
3486
3487 if (!entry.getAttributeValue("NAME", name))
3488 throw XmlValidationError(parser.getLine(),
3489 mike 1.25 "Missing EXPMETHODCALL.NAME attribute");
3490
3491 return true;
3492 }
3493
3494 //------------------------------------------------------------------------------
3495 //
3496 // getEMethodResponseStartTag()
3497 //
3498 //------------------------------------------------------------------------------
3499
3500 Boolean XmlReader::getEMethodResponseStartTag(
3501 XmlParser& parser,
3502 const char*& name)
3503 {
3504 XmlEntry entry;
3505
3506 if (!testStartTag(parser, entry, "EXPMETHODRESPONSE"))
3507 return false;
3508
3509 // Get EXPMETHODRESPONSE.NAME attribute:
3510 mike 1.25
3511 if (!entry.getAttributeValue("NAME", name))
3512 throw XmlValidationError(parser.getLine(),
3513 "Missing EXPMETHODRESPONSE.NAME attribute");
3514
3515 return true;
3516 }
3517
3518 //------------------------------------------------------------------------------
3519 //
3520 // getMethodCallStartTag()
3521 //
3522 //------------------------------------------------------------------------------
3523
3524 Boolean XmlReader::getMethodCallStartTag(
3525 XmlParser& parser,
3526 const char*& name)
3527 {
3528 XmlEntry entry;
3529
3530 if (!testStartTag(parser, entry, "METHODCALL"))
3531 mike 1.25 return false;
3532
3533 // Get METHODCALL.NAME attribute:
3534
3535 if (!entry.getAttributeValue("NAME", name))
3536 throw XmlValidationError(parser.getLine(),
3537 "Missing METHODCALL.NAME attribute");
3538
3539 return true;
3540 }
3541
3542 //------------------------------------------------------------------------------
3543 //
3544 // getMethodResponseStartTag()
3545 //
3546 //------------------------------------------------------------------------------
3547
3548 Boolean XmlReader::getMethodResponseStartTag(
3549 XmlParser& parser,
3550 const char*& name)
3551 {
3552 mike 1.25 XmlEntry entry;
3553
3554 if (!testStartTag(parser, entry, "METHODRESPONSE"))
3555 return false;
3556
3557 // Get METHODRESPONSE.NAME attribute:
3558
3559 if (!entry.getAttributeValue("NAME", name))
3560 throw XmlValidationError(parser.getLine(),
3561 "Missing METHODRESPONSE.NAME attribute");
3562
3563 return true;
3564 }
3565
3566 //------------------------------------------------------------------------------
3567 //
|
3568 kumpf 1.26 // getParamValueElement()
3569 //
3570 // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
3571 // <!ATTLIST PARAMVALUE
3572 // %CIMName;
3573 // %ParamType;>
|
3574 mike 1.25 //
3575 //------------------------------------------------------------------------------
3576
|
3577 kumpf 1.26 Boolean XmlReader::getParamValueElement(
|
3578 mike 1.25 XmlParser& parser,
|
3579 kumpf 1.26 CIMParamValue& paramValue)
|
3580 mike 1.25 {
3581 XmlEntry entry;
|
3582 kumpf 1.26 const char* name;
3583 CIMType type;
3584 CIMValue value;
|
3585 mike 1.25
|
3586 kumpf 1.26 if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))
|
3587 mike 1.25 return false;
3588
|
3589 kumpf 1.26 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3590
3591 // Get PARAMVALUE.NAME attribute:
|
3592 mike 1.25
3593 if (!entry.getAttributeValue("NAME", name))
3594 throw XmlValidationError(parser.getLine(),
3595 "Missing PARAMVALUE.NAME attribute");
|
3596 kumpf 1.26
3597 // Get PARAMVALUE.PARAMTYPE attribute:
3598
3599 type = getCimTypeAttribute(parser.getLine(), entry, "PARAMVALUE",
3600 "PARAMTYPE", false);
3601
3602 if (!empty)
3603 {
3604 // Parse VALUE.REFERENCE and VALUE.REFARRAY type
3605 if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )
3606 {
|
3607 kumpf 1.54 CIMObjectPath reference;
|
3608 kumpf 1.26 if (XmlReader::getValueReferenceElement(parser, reference))
3609 {
3610 value.set(reference);
3611 type = CIMType::REFERENCE;
3612 }
|
3613 kumpf 1.28 else if (XmlReader::getValueReferenceArrayElement(parser, value))
3614 {
3615 type = CIMType::REFERENCE;
3616 }
|
3617 kumpf 1.27 // If type==reference but no VALUE.REFERENCE found, use null value
|
3618 kumpf 1.26 }
3619
3620 // Parse non-reference value
3621 if ( type != CIMType::REFERENCE )
3622 {
3623 // If we don't know what type the value is, read it as a String
3624 CIMType effectiveType = type;
3625 if ( effectiveType == CIMType::NONE)
3626 {
3627 effectiveType = CIMType::STRING;
3628 }
3629
3630 if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&
3631 !XmlReader::getValueElement(parser, effectiveType, value) )
3632 {
3633 value.clear(); // Isn't necessary; should already be cleared
3634 }
3635 }
3636
3637 expectEndTag(parser, "PARAMVALUE");
3638 }
3639 kumpf 1.26
|
3640 kumpf 1.31 paramValue = CIMParamValue(name, value, Boolean(type!=CIMType::NONE));
|
3641 kumpf 1.27
3642 return true;
3643 }
3644
3645 //------------------------------------------------------------------------------
3646 //
3647 // getReturnValueElement()
3648 //
3649 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
3650 // <!ATTLIST RETURNVALUE
3651 // %ParamType;>
3652 //
3653 //------------------------------------------------------------------------------
3654
3655 Boolean XmlReader::getReturnValueElement(
3656 XmlParser& parser,
3657 CIMValue& returnValue)
3658 {
3659 XmlEntry entry;
3660 CIMType type;
3661 CIMValue value;
3662 kumpf 1.27
3663 if (!testStartTag(parser, entry, "RETURNVALUE"))
3664 return false;
3665
3666 // Get RETURNVALUE.PARAMTYPE attribute:
3667 // NOTE: Array type return values are not allowed (2/20/02)
3668
3669 type = getCimTypeAttribute(parser.getLine(), entry, "RETURNVALUE",
3670 "PARAMTYPE", false);
3671
3672 // Parse VALUE.REFERENCE type
3673 if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )
3674 {
|
3675 kumpf 1.54 CIMObjectPath reference;
|
3676 kumpf 1.27 if (XmlReader::getValueReferenceElement(parser, reference))
3677 {
3678 returnValue.set(reference);
3679 type = CIMType::REFERENCE;
3680 }
3681 else if (type == CIMType::REFERENCE)
3682 {
3683 throw XmlValidationError(parser.getLine(),
3684 "expected VALUE.REFERENCE element");
3685 }
3686 }
3687
3688 // Parse non-reference return value
3689 if ( type != CIMType::REFERENCE )
3690 {
3691 // If we don't know what type the value is, read it as a String
3692 if ( type == CIMType::NONE)
3693 {
3694 type = CIMType::STRING;
3695 }
3696
3697 kumpf 1.27 if ( !XmlReader::getValueElement(parser, type, returnValue) )
3698 {
3699 throw XmlValidationError(parser.getLine(),
3700 "expected VALUE element");
3701 }
3702 }
3703
3704 expectEndTag(parser, "RETURNVALUE");
|
3705 mike 1.25
3706 return true;
|
3707 mike 1.23 }
3708
3709 PEGASUS_NAMESPACE_END
|
Return to
XmlReader.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common