90 mike 1.23 }
91
92 //------------------------------------------------------------------------------
93 //
94 // expectStartTag()
95 //
96 //------------------------------------------------------------------------------
97
98 void XmlReader::expectStartTag(
99 XmlParser& parser,
100 XmlEntry& entry,
101 const char* tagName)
102 {
103 if (!parser.next(entry) ||
104 entry.type != XmlEntry::START_TAG ||
105 strcmp(entry.text, tagName) != 0)
106 {
107 char message[MESSAGE_SIZE];
108 sprintf(message, "Expected open of %s element", tagName);
109 throw XmlValidationError(parser.getLine(), message);
110 }
111 mike 1.23 }
112
113 //------------------------------------------------------------------------------
114 //
115 // expectEndTag()
116 //
117 //------------------------------------------------------------------------------
118
119 void XmlReader::expectEndTag(XmlParser& parser, const char* tagName)
120 {
121 XmlEntry entry;
122
123 if (!parser.next(entry) ||
124 entry.type != XmlEntry::END_TAG ||
125 strcmp(entry.text, tagName) != 0)
126 {
127 char message[MESSAGE_SIZE];
128 sprintf(message, "Expected close of %s element, got %s instead",
129 tagName,entry.text);
130 throw XmlValidationError(parser.getLine(), message);
131 }
132 mike 1.23 }
133
134 //------------------------------------------------------------------------------
135 //
136 // expectStartTagOrEmptyTag()
137 //
138 //------------------------------------------------------------------------------
139
140 void XmlReader::expectStartTagOrEmptyTag(
141 XmlParser& parser,
142 XmlEntry& entry,
143 const char* tagName)
144 {
145 if (!parser.next(entry) ||
146 (entry.type != XmlEntry::START_TAG &&
147 entry.type != XmlEntry::EMPTY_TAG) ||
148 strcmp(entry.text, tagName) != 0)
149 {
150 char message[MESSAGE_SIZE];
151 sprintf(message,
152 "Expected either open or open/close %s element", tagName);
153 mike 1.23 throw XmlValidationError(parser.getLine(), message);
154 }
155 }
156
157 //------------------------------------------------------------------------------
158 //
159 // expectContentOrCData()
160 //
161 //------------------------------------------------------------------------------
162
163 Boolean XmlReader::expectContentOrCData(
164 XmlParser& parser,
165 XmlEntry& entry)
166 {
167 if (!parser.next(entry) ||
168 (entry.type != XmlEntry::CONTENT &&
169 entry.type != XmlEntry::CDATA))
170 {
171 throw XmlValidationError(parser.getLine(),
172 "Expected content of CDATA");
173 }
174 mike 1.23
175 return true;
176 }
177
178 //------------------------------------------------------------------------------
179 //
180 // testStartTag()
181 //
182 //------------------------------------------------------------------------------
183
184 Boolean XmlReader::testStartTag(
185 XmlParser& parser,
186 XmlEntry& entry,
187 const char* tagName)
188 {
189 if (!parser.next(entry) ||
190 entry.type != XmlEntry::START_TAG ||
191 strcmp(entry.text, tagName) != 0)
192 {
193 parser.putBack(entry);
194 return false;
195 mike 1.23 }
196
197 return true;
198 }
199
200 //------------------------------------------------------------------------------
201 //
202 // testEndTag>()
203 //
204 //------------------------------------------------------------------------------
205
206 Boolean XmlReader::testEndTag(XmlParser& parser, const char* tagName)
207 {
208 XmlEntry entry;
209
210 if (!parser.next(entry) ||
211 entry.type != XmlEntry::END_TAG ||
212 strcmp(entry.text, tagName) != 0)
213 {
214 parser.putBack(entry);
215 return false;
216 mike 1.23 }
217
218 return true;
219 }
220
221 //------------------------------------------------------------------------------
222 //
223 // testStartTagOrEmptyTag()
224 //
225 //------------------------------------------------------------------------------
226
227 Boolean XmlReader::testStartTagOrEmptyTag(
228 XmlParser& parser,
229 XmlEntry& entry,
230 const char* tagName)
231 {
232 if (!parser.next(entry) ||
233 (entry.type != XmlEntry::START_TAG &&
234 entry.type != XmlEntry::EMPTY_TAG) ||
235 strcmp(entry.text, tagName) != 0)
236 {
237 mike 1.23 parser.putBack(entry);
238 return false;
239 }
240
241 return true;
242 }
243
244 //------------------------------------------------------------------------------
245 //
246 // testContentOrCData()
247 //
248 //------------------------------------------------------------------------------
249
250 Boolean XmlReader::testContentOrCData(
251 XmlParser& parser,
252 XmlEntry& entry)
253 {
254 if (!parser.next(entry) ||
255 (entry.type != XmlEntry::CONTENT &&
256 entry.type != XmlEntry::CDATA))
257 {
258 mike 1.23 parser.putBack(entry);
259 return false;
260 }
261
262 return true;
263 }
264
265 //------------------------------------------------------------------------------
266 //
267 // testCimStartTag()
268 //
269 // <!ELEMENT CIM (MESSAGE|DECLARATION)>
270 // <!ATTRLIST CIM
271 // CIMVERSION CDATA #REQUIRED
272 // DTDVERSION CDATA #REQUIRED>
273 //
274 //------------------------------------------------------------------------------
275
276 void XmlReader::testCimStartTag(XmlParser& parser)
277 {
278 XmlEntry entry;
279 mike 1.23 XmlReader::expectStartTag(parser, entry, "CIM");
280
281 const char* cimVersion;
282
283 if (!entry.getAttributeValue("CIMVERSION", cimVersion))
284 throw XmlValidationError(
285 parser.getLine(), "missing CIM.CIMVERSION attribute");
286
287 if (strcmp(cimVersion, "2.0") != 0)
288 throw XmlValidationError(parser.getLine(),
289 "CIM.CIMVERSION attribute must be \"2.0\"");
290
291 const char* dtdVersion;
292
293 if (!entry.getAttributeValue("DTDVERSION", dtdVersion))
294 throw XmlValidationError(
295 parser.getLine(), "missing CIM.DTDVERSION attribute");
296
297 if (strcmp(dtdVersion, "2.0") != 0)
298 throw XmlValidationError(parser.getLine(),
299 "CIM.DTDVERSION attribute must be \"2.0\"");
300 mike 1.23 }
301
302 //------------------------------------------------------------------------------
303 //
304 // getIsArrayAttribute()
305 //
306 //------------------------------------------------------------------------------
307
308 Boolean XmlReader::getIsArrayAttribute(
309 Uint32 lineNumber,
310 const XmlEntry& entry,
311 const char* tagName,
312 Boolean& value)
313 {
314 const char* tmp;
315
316 if (!entry.getAttributeValue("ISARRAY", tmp))
317 return false;
318
319 if (strcmp(tmp, "true") == 0)
320 {
321 mike 1.23 value = true;
322 return true;
323 }
324 else if (strcmp(tmp, "false") == 0)
325 {
326 value = false;
327 return true;
328 }
329
330 char buffer[62];
331 sprintf(buffer, "Bad %s.%s attribute value", "ISARRAY", tagName);
332 throw XmlSemanticError(lineNumber, buffer);
333 return false;
334 }
335
336 //------------------------------------------------------------------------------
337 //
338 // getCimNameAttribute()
339 //
340 // <!ENTITY % CIMName "NAME CDATA #REQUIRED">
341 //
342 mike 1.23 //------------------------------------------------------------------------------
343
344 String XmlReader::getCimNameAttribute(
345 Uint32 lineNumber,
346 const XmlEntry& entry,
347 const char* elementName,
348 Boolean acceptNull)
349 {
350 String name;
351
352 if (!entry.getAttributeValue("NAME", name))
353 {
354 char buffer[MESSAGE_SIZE];
355 sprintf(buffer, "missing %s.NAME attribute", elementName);
356 throw XmlValidationError(lineNumber, buffer);
357 }
358
359 if (acceptNull && name.size() == 0)
360 return name;
361
362 if (!CIMName::legal(name))
363 mike 1.23 {
364 char buffer[MESSAGE_SIZE];
365 sprintf(buffer, "Illegal value for %s.NAME attribute", elementName);
366 throw XmlSemanticError(lineNumber, buffer);
367 }
368
369 return name;
370 }
371
372 //------------------------------------------------------------------------------
373 //
374 // getClassNameAttribute()
375 //
376 // <!ENTITY % CIMName "CLASSNAME CDATA #REQUIRED">
377 //
378 //------------------------------------------------------------------------------
379
380 String XmlReader::getClassNameAttribute(
381 Uint32 lineNumber,
382 const XmlEntry& entry,
383 const char* elementName)
384 mike 1.23 {
385 String name;
386
387 if (!entry.getAttributeValue("CLASSNAME", name))
388 {
389 char buffer[MESSAGE_SIZE];
390 sprintf(buffer, "missing %s.CLASSNAME attribute", elementName);
391 throw XmlValidationError(lineNumber, buffer);
392 }
393
394 if (!CIMName::legal(name))
395 {
396 char buffer[MESSAGE_SIZE];
397 sprintf(buffer,
398 "Illegal value for %s.CLASSNAME attribute", elementName);
399 throw XmlSemanticError(lineNumber, buffer);
400 }
401
402 return name;
403 }
404
405 mike 1.23 //------------------------------------------------------------------------------
406 //
407 // getClassOriginAttribute()
408 //
409 // <!ENTITY % ClassOrigin "CLASSORIGIN CDATA #IMPLIED">
410 //
411 //------------------------------------------------------------------------------
412
413 String XmlReader::getClassOriginAttribute(
414 Uint32 lineNumber,
415 const XmlEntry& entry,
416 const char* tagName)
417 {
418 String name;
419
420 if (!entry.getAttributeValue("CLASSORIGIN", name))
421 return String();
422
423 if (!CIMName::legal(name))
424 {
425 char buffer[MESSAGE_SIZE];
426 mike 1.23 sprintf(buffer,
427 "Illegal value for %s.CLASSORIGIN attribute", tagName);
428 throw XmlSemanticError(lineNumber, buffer);
429 }
430
431 return name;
432 }
433
434 //------------------------------------------------------------------------------
435 //
436 // getReferenceClassAttribute()
437 //
438 // <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">
439 //
440 //------------------------------------------------------------------------------
441
442 String XmlReader::getReferenceClassAttribute(
443 Uint32 lineNumber,
444 const XmlEntry& entry,
445 const char* elementName)
446 {
447 mike 1.23 String name;
448
449 if (!entry.getAttributeValue("REFERENCECLASS", name))
450 return String();
451
452 if (!CIMName::legal(name))
453 {
454 char buffer[MESSAGE_SIZE];
455 sprintf(buffer,
456 "Illegal value for %s.REFERENCECLASS attribute", elementName);
457 throw XmlSemanticError(lineNumber, buffer);
458 }
459
460 return name;
461 }
462
463 //------------------------------------------------------------------------------
464 //
465 // getSuperClassAttribute()
466 //
467 // <!ENTITY % SuperClass "SUPERCLASS CDATA #IMPLIED">
468 mike 1.23 //
469 //------------------------------------------------------------------------------
470
471 String XmlReader::getSuperClassAttribute(
472 Uint32 lineNumber,
473 const XmlEntry& entry,
474 const char* tagName)
475 {
476 String superClass;
477
478 if (!entry.getAttributeValue("SUPERCLASS", superClass))
479 return String();
480
481 if (!CIMName::legal(superClass))
482 {
483 char buffer[MESSAGE_SIZE];
484 sprintf(
485 buffer, "Illegal value for %s.SUPERCLASS attribute", tagName);
486 throw XmlSemanticError(lineNumber, buffer);
487 }
488
489 mike 1.23 return superClass;
490 }
491
492 //------------------------------------------------------------------------------
493 //
494 // getCimTypeAttribute()
495 //
496 // <!ENTITY % CIMType "TYPE (boolean|string|char16|uint8|sint8|uint16
497 // |sint16|uint32|sint32|uint64|sint64|datetime|real32|real64)">
498 //
499 //------------------------------------------------------------------------------
500
501 CIMType XmlReader::getCimTypeAttribute(
502 Uint32 lineNumber,
503 const XmlEntry& entry,
504 const char* tagName)
505 {
506 const char* typeName;
507
508 if (!entry.getAttributeValue("TYPE", typeName))
509 {
510 mike 1.23 char message[MESSAGE_SIZE];
511 sprintf(message, "missing %s.TYPE attribute", tagName);
512 throw XmlValidationError(lineNumber, message);
513 }
514
515 CIMType type = CIMType::NONE;
516
517 if (strcmp(typeName, "boolean") == 0)
518 type = CIMType::BOOLEAN;
519 else if (strcmp(typeName, "string") == 0)
520 type = CIMType::STRING;
521 else if (strcmp(typeName, "char16") == 0)
522 type = CIMType::CHAR16;
523 else if (strcmp(typeName, "uint8") == 0)
524 type = CIMType::UINT8;
525 else if (strcmp(typeName, "sint8") == 0)
526 type = CIMType::SINT8;
527 else if (strcmp(typeName, "uint16") == 0)
528 type = CIMType::UINT16;
529 else if (strcmp(typeName, "sint16") == 0)
530 type = CIMType::SINT16;
531 mike 1.23 else if (strcmp(typeName, "uint32") == 0)
532 type = CIMType::UINT32;
533 else if (strcmp(typeName, "sint32") == 0)
534 type = CIMType::SINT32;
535 else if (strcmp(typeName, "uint64") == 0)
536 type = CIMType::UINT64;
537 else if (strcmp(typeName, "sint64") == 0)
538 type = CIMType::SINT64;
539 else if (strcmp(typeName, "datetime") == 0)
540 type = CIMType::DATETIME;
541 else if (strcmp(typeName, "real32") == 0)
542 type = CIMType::REAL32;
543 else if (strcmp(typeName, "real64") == 0)
544 type = CIMType::REAL64;
545
546 if (type == CIMType::NONE)
547 {
548 char message[MESSAGE_SIZE];
549 sprintf(message, "Illegal value for %s.TYPE attribute", tagName);
550 throw XmlSemanticError(lineNumber, message);
551 }
552 mike 1.23
553 return type;
554 }
555
556 //------------------------------------------------------------------------------
557 //
558 // getCimBooleanAttribute()
559 //
560 //------------------------------------------------------------------------------
561
562 Boolean XmlReader::getCimBooleanAttribute(
563 Uint32 lineNumber,
564 const XmlEntry& entry,
565 const char* tagName,
566 const char* attributeName,
567 Boolean defaultValue,
568 Boolean required)
569 {
570 const char* tmp;
571
572 if (!entry.getAttributeValue(attributeName, tmp))
573 mike 1.23 {
574 if (!required)
575 return defaultValue;
576
577 char buffer[62];
578 sprintf(buffer, "missing required %s.%s attribute",
579 attributeName, tagName);
580
581 throw XmlValidationError(lineNumber, buffer);
582 }
583
584 if (strcmp(tmp, "true") == 0)
585 return true;
586 else if (strcmp(tmp, "false") == 0)
587 return false;
588
589 char buffer[62];
590 sprintf(buffer, "Bad %s.%s attribute value", attributeName, tagName);
591 throw XmlSemanticError(lineNumber, buffer);
592 return false;
593 }
594 mike 1.23
595 //------------------------------------------------------------------------------
596 //
597 // SringToReal()
598 //
599 // [ "+" | "-" ] *decimalDigit "." 1*decimalDigit
600 // [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]
601 //
602 //------------------------------------------------------------------------------
603
604 Boolean XmlReader::stringToReal(const char* stringValue, Real64& x)
605 {
606 const char* p = stringValue;
607
608 if (!*p)
609 return false;
610
611 // Skip optional sign:
612
613 if (*p == '+' || *p == '-')
614 p++;
615 mike 1.23
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
628 if (!isdigit(*p++))
629 return false;
630
631 while (isdigit(*p))
632 p++;
633
634 // If there is an exponent now:
635
636 mike 1.23 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 p++;
649
650 // One or more digits required:
651
652 if (!isdigit(*p++))
653 return false;
654
655 while (isdigit(*p))
656 p++;
657 mike 1.23 }
658
659 if (*p)
660 return false;
661
662 char* end;
663 x = strtod(stringValue, &end);
664 return true;
665 }
666
667 //------------------------------------------------------------------------------
668 //
669 // stringToSignedInteger
670 //
671 // [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
672 //
673 // ATTN-B: handle conversion from hexadecimal.
674 //------------------------------------------------------------------------------
675
676 Boolean XmlReader::stringToSignedInteger(
677 const char* stringValue,
678 mike 1.23 Sint64& x)
679 {
680 x = 0;
681 const char* p = stringValue;
682
683 if (!*p)
684 return false;
685
686 // Skip optional sign:
687
688 Boolean negative = *p == '-';
689
690 if (negative || *p == '+')
691 p++;
692
693 // If the next thing is a zero, then it must be the last:
694
695 if (*p == '0')
696 return p[1] == '\0';
697
698 // Expect a positive decimal digit:
699 mike 1.23
700 const char* first = p;
701
702 if (!isdigit(*p) || *p == '0')
703 return false;
704
705 p++;
706
707 // Expect zero or more digits:
708
709 while (isdigit(*p))
710 p++;
711
712 if (*p)
713 return false;
714
715 const char* last = p;
716
717 while (first != last)
718 x = 10 * x + (*first++ - '0');
719
720 mike 1.23 if (negative)
721 x = -x;
722
723 return true;
724 }
725
726 //------------------------------------------------------------------------------
727 //
728 // stringToUnsignedInteger
729 //
730 // [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
731 //
732 // ATTN-B: handle conversion from hexadecimal.
733 //------------------------------------------------------------------------------
734
735 Boolean XmlReader::stringToUnsignedInteger(
736 const char* stringValue,
737 Uint64& x)
738 {
739 x = 0;
740 const char* p = stringValue;
741 mike 1.23
742 if (!*p)
743 return false;
744
745 // Skip optional sign:
746
747 if (*p == '-')
748 return false;
749
750 if (*p == '+')
751 p++;
752
753 // If the next thing is a zero, then it must be the last:
754
755 if (*p == '0')
756 return p[1] == '\0';
757
758 // Expect a positive decimal digit:
759
760 const char* first = p;
761
762 mike 1.23 if (!isdigit(*p) || *p == '0')
763 return false;
764
765 p++;
766
767 // Expect zero or more digits:
768
769 while (isdigit(*p))
770 p++;
771
772 if (*p)
773 return false;
774
775 const char* last = p;
776
777 while (first != last)
778 x = 10 * x + (*first++ - '0');
779
780 return true;
781 }
782
783 mike 1.23 //------------------------------------------------------------------------------
784 //
785 // stringToValue()
786 //
787 // ATTN-C: note that integers are truncated without warning. What should be
788 // done in this case? In C they are truncated without warning by design.
789 //
790 //------------------------------------------------------------------------------
791
792 CIMValue XmlReader::stringToValue(
793 Uint32 lineNumber,
794 const char* valueString,
795 CIMType type)
796 {
797 // ATTN-B: accepting only UTF-8 for now! (affects string and char16):
798
799 if (strlen(valueString)==0)
800 {
801 switch (type)
802 {
803 case CIMType::BOOLEAN: return CIMValue(false);
804 mike 1.23 case CIMType::STRING: return CIMValue(valueString);
805 case CIMType::CHAR16: return CIMValue(Char16('\0'));
806 case CIMType::UINT8: return CIMValue(Uint8(0));
807 case CIMType::UINT16: return CIMValue(Uint16(0));
808 case CIMType::UINT32: return CIMValue(Uint32(0));
809 case CIMType::UINT64: return CIMValue(Uint64(0));
810 case CIMType::SINT8: return CIMValue(Sint8(0));
811 case CIMType::SINT16: return CIMValue(Sint16(0));
812 case CIMType::SINT32: return CIMValue(Sint32(0));
813 case CIMType::SINT64: return CIMValue(Sint64(0));
814 case CIMType::REAL32: return CIMValue(Real32(0));
815 case CIMType::REAL64: return CIMValue(Real64(0));
816 }
817 }
818
819 switch (type)
820 {
821 case CIMType::BOOLEAN:
822 {
823 if (CompareNoCase(valueString, "TRUE") == 0)
824 return CIMValue(true);
825 mike 1.23 else if (CompareNoCase(valueString, "FALSE") == 0)
826 return CIMValue(false);
827 else
828 throw XmlSemanticError(
829 lineNumber, "Bad boolean value");
830 }
831
832 case CIMType::STRING:
833 {
834 return CIMValue(valueString);
835 }
836
837 case CIMType::CHAR16:
838 {
839 if (strlen(valueString) != 1)
840 throw XmlSemanticError(lineNumber, "Bad char16 value");
841
842 return CIMValue(Char16(valueString[0]));
843 }
844
845 case CIMType::UINT8:
846 mike 1.23 case CIMType::UINT16:
847 case CIMType::UINT32:
848 case CIMType::UINT64:
849 {
850 Uint64 x;
851
852 if (!stringToUnsignedInteger(valueString, x))
853 {
854 throw XmlSemanticError(
855 lineNumber, "Bad unsigned integer value");
856 }
857
858 switch (type)
859 {
860 case CIMType::UINT8: return CIMValue(Uint8(x));
861 case CIMType::UINT16: return CIMValue(Uint16(x));
862 case CIMType::UINT32: return CIMValue(Uint32(x));
863 case CIMType::UINT64: return CIMValue(Uint64(x));
864 default: break;
865 }
866 }
867 mike 1.23
868 case CIMType::SINT8:
869 case CIMType::SINT16:
870 case CIMType::SINT32:
871 case CIMType::SINT64:
872 {
873 Sint64 x;
874
875 if (!stringToSignedInteger(valueString, x))
876 {
877 throw XmlSemanticError(
878 lineNumber, "Bad signed integer value");
879 }
880
881 switch (type)
882 {
883 case CIMType::SINT8: return CIMValue(Sint8(x));
884 case CIMType::SINT16: return CIMValue(Sint16(x));
885 case CIMType::SINT32: return CIMValue(Sint32(x));
886 case CIMType::SINT64: return CIMValue(Sint64(x));
887 default: break;
888 mike 1.23 }
889 }
890
891 case CIMType::DATETIME:
892 {
893 CIMDateTime tmp;
894
895 try
896 {
897 tmp.set(valueString);
898 }
899 catch (BadDateTimeFormat&)
900 {
901 throw XmlSemanticError(lineNumber, "Bad datetime value");
902 }
903
904 return CIMValue(tmp);
905 }
906
907 case CIMType::REAL32:
908 {
909 mike 1.23 Real64 x;
910
911 if (!stringToReal(valueString, x))
912 throw XmlSemanticError(lineNumber, "Bad real value");
913
914 return CIMValue(Real32(x));
915 }
916
917 case CIMType::REAL64:
918 {
919 Real64 x;
920
921 if (!stringToReal(valueString, x))
922 throw XmlSemanticError(lineNumber, "Bad real value");
923
924 return CIMValue(x);
925 }
926
927 default:
928 break;
929 }
930 mike 1.23
931 throw XmlSemanticError(lineNumber, "malformed XML");
932 return false;
933 }
934
935 //------------------------------------------------------------------------------
936 //
937 // getValueElement()
938 //
939 // <!ELEMENT VALUE (#PCDATA)>
940 //
941 //------------------------------------------------------------------------------
942
943 Boolean XmlReader::getValueElement(
944 XmlParser& parser,
945 CIMType type,
946 CIMValue& value)
947 {
948 // Get VALUE start tag:
949
950 XmlEntry entry;
951 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
952 return false;
953
954 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
955
956 const char* valueString = "";
957
958 if (!empty)
959 {
960 if (testContentOrCData(parser, entry))
961 valueString = entry.text;
962
963 expectEndTag(parser, "VALUE");
964 }
965
966 value = stringToValue(parser.getLine(), valueString,type);
967
968 return true;
969 }
970
971 //------------------------------------------------------------------------------
972 mike 1.23 //
973 // getStringValueElement()
974 //
975 // <!ELEMENT VALUE (#PCDATA)>
976 //
977 //------------------------------------------------------------------------------
978
979 Boolean XmlReader::getStringValueElement(
980 XmlParser& parser,
981 String& str,
982 Boolean required)
983 {
984 XmlEntry entry;
985
986 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
987 {
988 if (required)
989 throw XmlValidationError(parser.getLine(),"Expected VALUE element");
990 return false;
991 }
992
993 mike 1.23 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
994
995 const char* valueString = "";
996
997 if (!empty)
998 {
999 if (testContentOrCData(parser, entry))
1000 valueString = entry.text;
1001
1002 expectEndTag(parser, "VALUE");
1003 }
1004
1005 str = valueString;
1006 return true;
1007 }
1008
1009 //----------------------------------------------------------------------------
1010 //
1011 // getPropertyValue
1012 // Use: Decode property value from getPropertyResponse
1013 // Expect (ERROR|IRETURNVALUE).!ELEMENT VALUE (#PCDATA)>
1014 mike 1.23 //
1015 // PropertyValue:
1016 // <!ELEMENT VALUE>
1017 //
1018 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1019 //
1020 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
1021 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
1022 //
1023 //----------------------------------------------------------------------------
1024 Boolean XmlReader::getPropertyValue(
1025 XmlParser& parser,
1026 CIMValue& cimValue)
1027 {
|
1049 mike 1.23
1050 return false;
1051 }
1052
1053 //------------------------------------------------------------------------------
1054 //
1055 // stringArrayToValue()
1056 //
1057 //------------------------------------------------------------------------------
1058
1059 template<class T>
1060 CIMValue StringArrayToValueAux(
1061 Uint32 lineNumber,
1062 const Array<const char*>& stringArray,
1063 CIMType type,
1064 T*)
1065 {
1066 Array<T> array;
1067
1068 for (Uint32 i = 0, n = stringArray.size(); i < n; i++)
1069 {
1070 mike 1.23 CIMValue value = XmlReader::stringToValue(
1071 lineNumber, stringArray[i], type);
1072
1073 T x;
1074 value.get(x);
1075 array.append(x);
1076 }
1077
1078 return CIMValue(array);
1079 }
1080
1081 CIMValue XmlReader::stringArrayToValue(
1082 Uint32 lineNumber,
1083 const Array<const char*>& array,
1084 CIMType type)
1085 {
1086 switch (type)
1087 {
1088 case CIMType::BOOLEAN:
1089 return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);
1090
1091 mike 1.23 case CIMType::STRING:
1092 return StringArrayToValueAux(lineNumber, array, type, (String*)0);
1093
1094 case CIMType::CHAR16:
1095 return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);
1096
1097 case CIMType::UINT8:
1098 return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);
1099
1100 case CIMType::UINT16:
1101 return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);
1102
1103 case CIMType::UINT32:
1104 return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);
1105
1106 case CIMType::UINT64:
1107 return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);
1108
1109 case CIMType::SINT8:
1110 return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);
1111
1112 mike 1.23 case CIMType::SINT16:
1113 return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);
1114
1115 case CIMType::SINT32:
1116 return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);
1117
1118 case CIMType::SINT64:
1119 return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);
1120
1121 case CIMType::DATETIME:
1122 return StringArrayToValueAux(lineNumber, array, type, (CIMDateTime*)0);
1123
1124 case CIMType::REAL32:
1125 return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);
1126
1127 case CIMType::REAL64:
1128 return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);
1129
1130 default:
1131 break;
1132 }
1133 mike 1.23
1134 // Unreachable:
1135 return CIMValue();
1136 }
1137
1138 //------------------------------------------------------------------------------
1139 //
1140 // getValueArrayElement()
1141 //
1142 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1143 //
1144 //------------------------------------------------------------------------------
1145
1146 Boolean XmlReader::getValueArrayElement(
1147 XmlParser& parser,
1148 CIMType type,
1149 CIMValue& value)
1150 {
1151 value.clear();
1152
1153 // Get VALUE.ARRAY open tag:
1154 mike 1.23
1155 XmlEntry entry;
1156
1157 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))
1158 return false;
1159
1160 if (entry.type == XmlEntry::EMPTY_TAG)
1161 return true;
1162
1163 // For each VALUE element:
1164
1165 Array<const char*> stringArray;
1166
1167 while (testStartTagOrEmptyTag(parser, entry, "VALUE"))
1168 {
1169 if (entry.type == XmlEntry::EMPTY_TAG)
1170 {
1171 stringArray.append("");
1172 continue;
1173 }
1174
1175 mike 1.23 if (testContentOrCData(parser, entry))
1176 stringArray.append(entry.text);
1177 else
1178 stringArray.append("");
1179
1180 expectEndTag(parser, "VALUE");
1181 }
1182
1183 expectEndTag(parser, "VALUE.ARRAY");
1184
1185 value = stringArrayToValue(parser.getLine(), stringArray, type);
1186 return true;
1187 }
1188
1189 //------------------------------------------------------------------------------
1190 //
1191 // getFlavor()
1192 //
1193 // <!ENTITY % QualifierFlavor
1194 // "OVERRIDABLE (true|false) 'true'
1195 // TOSUBCLASS (true|false) 'true'
1196 mike 1.23 // TOINSTANCE (true|false) 'false'
1197 // TRANSLATABLE (true|false) 'false'">
1198 //
1199 //------------------------------------------------------------------------------
1200
1201 Uint32 XmlReader::getFlavor(
1202 XmlEntry& entry,
1203 Uint32 lineNumber,
1204 const char* tagName)
1205 {
1206 // Get QUALIFIER.OVERRIDABLE
1207
1208 Boolean overridable = getCimBooleanAttribute(
1209 lineNumber, entry, tagName, "OVERRIDABLE", true, false);
1210
1211 // Get QUALIFIER.TOSUBCLASS
1212
1213 Boolean toSubClass = getCimBooleanAttribute(
1214 lineNumber, entry, tagName, "TOSUBCLASS", true, false);
1215
1216 // Get QUALIFIER.TOINSTANCE
1217 mike 1.23
1218 Boolean toInstance = getCimBooleanAttribute(
1219 lineNumber, entry, tagName, "TOINSTANCE", false, false);
1220
1221 // Get QUALIFIER.TRANSLATABLE
1222
1223 Boolean translatable = getCimBooleanAttribute(
1224 lineNumber, entry, tagName, "TRANSLATABLE", false, false);
1225
1226 Uint32 flavor = 0;
1227
1228 if (overridable)
1229 flavor |= CIMFlavor::OVERRIDABLE;
1230
1231 if (toSubClass)
1232 flavor |= CIMFlavor::TOSUBCLASS;
1233
1234 if (toInstance)
1235 flavor |= CIMFlavor::TOINSTANCE;
1236
1237 if (translatable)
1238 mike 1.23 flavor |= CIMFlavor::TRANSLATABLE;
1239
1240 return flavor;
1241 }
1242
1243 //------------------------------------------------------------------------------
1244 //
1245 // getOptionalScope()
1246 //
1247 // DTD:
1248 // <!ELEMENT SCOPE EMPTY>
1249 // <!ATTLIST SCOPE
1250 // CLASS (true|false) 'false'
1251 // ASSOCIATION (true|false) 'false'
1252 // REFERENCE (true|false) 'false'
1253 // PROPERTY (true|false) 'false'
1254 // METHOD (true|false) 'false'
1255 // PARAMETER (true|false) 'false'
1256 // INDICATION (true|false) 'false'>
1257 //
1258 //------------------------------------------------------------------------------
1259 mike 1.23
1260 Uint32 XmlReader::getOptionalScope(XmlParser& parser)
1261 {
1262 XmlEntry entry;
1263
1264 if (!parser.next(entry))
1265 return false;
1266
1267 Boolean isEmptyTag = entry.type == XmlEntry::EMPTY_TAG;
1268
1269 if ((!isEmptyTag &&
1270 entry.type != XmlEntry::START_TAG) ||
1271 strcmp(entry.text, "SCOPE") != 0)
1272 {
1273 parser.putBack(entry);
1274 return 0;
1275 }
1276
1277 Uint32 line = parser.getLine();
1278 Uint32 scope = 0;
1279
1280 mike 1.23 if (getCimBooleanAttribute(line, entry, "SCOPE", "CLASS", false, false))
1281 scope |= CIMScope::CLASS;
1282
1283 if (getCimBooleanAttribute(
1284 line, entry, "SCOPE", "ASSOCIATION", false, false))
1285 scope |= CIMScope::ASSOCIATION;
1286
1287 if (getCimBooleanAttribute(
1288 line, entry, "SCOPE", "REFERENCE", false, false))
1289 scope |= CIMScope::REFERENCE;
1290
1291 if (getCimBooleanAttribute(line, entry, "SCOPE", "PROPERTY", false, false))
1292 scope |= CIMScope::PROPERTY;
1293
1294 if (getCimBooleanAttribute(line, entry, "SCOPE", "METHOD", false, false))
1295 scope |= CIMScope::METHOD;
1296
1297 if (getCimBooleanAttribute(line, entry, "SCOPE", "PARAMETER", false, false))
1298 scope |= CIMScope::PARAMETER;
1299
1300 if (getCimBooleanAttribute(line, entry, "SCOPE", "INDICATION",false, false))
1301 mike 1.23 scope |= CIMScope::INDICATION;
1302
1303 if (!isEmptyTag)
1304 expectEndTag(parser, "SCOPE");
1305
1306 return scope;
1307 }
1308
1309 //------------------------------------------------------------------------------
1310 //
1311 // getQualifierElement()
1312 //
1313 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>
1314 // <!ATTLIST QUALIFIER
1315 // %CIMName;
1316 // %CIMType; #REQUIRED
1317 // %Propagated;
1318 // %QualifierFlavor;>
1319 //
1320 //------------------------------------------------------------------------------
1321
1322 mike 1.23 Boolean XmlReader::getQualifierElement(
1323 XmlParser& parser,
1324 CIMQualifier& qualifier)
1325 {
1326 // Get QUALIFIER element:
1327
1328 XmlEntry entry;
1329 if (!testStartTag(parser, entry, "QUALIFIER"))
1330 return false;
1331
1332 // Get QUALIFIER.NAME attribute:
1333
1334 String name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
1335
1336 // Get QUALIFIER.TYPE attribute:
1337
1338 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "QUALIFIER");
1339
1340 // Get QUALIFIER.PROPAGATED
1341
1342 Boolean propagated = getCimBooleanAttribute(
1343 mike 1.23 parser.getLine(), entry, "QUALIFIER", "PROPAGATED", false, false);
1344
1345 // Get flavor oriented attributes:
1346
1347 Uint32 flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");
1348
1349 // Get VALUE or VALUE.ARRAY element:
1350
1351 CIMValue value;
1352
1353 if (!getValueElement(parser, type, value) &&
1354 !getValueArrayElement(parser, type, value))
1355 {
1356 throw XmlSemanticError(parser.getLine(),
1357 "Expected VALUE or VALUE.ARRAY element");
1358 }
1359
1360 // Expect </QUALIFIER>:
1361
1362 expectEndTag(parser, "QUALIFIER");
1363
1364 mike 1.23 // Build qualifier:
1365
1366 qualifier = CIMQualifier(name, value, flavor, propagated);
1367 return true;
1368 }
1369
1370 //------------------------------------------------------------------------------
1371 //
1372 // getQualifierElements()
1373 //
1374 //------------------------------------------------------------------------------
1375
1376 template<class CONTAINER>
1377 void getQualifierElements(XmlParser& parser, CONTAINER& container)
1378 {
1379 CIMQualifier qualifier;
1380
1381 while (XmlReader::getQualifierElement(parser, qualifier))
1382 {
1383 try
1384 {
1385 mike 1.23 container.addQualifier(qualifier);
1386 }
1387 catch (AlreadyExists&)
1388 {
1389 throw XmlSemanticError(parser.getLine(), "duplicate qualifier");
1390 }
1391 }
1392 }
1393
1394 //------------------------------------------------------------------------------
1395 //
1396 // getPropertyElement()
1397 //
1398 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
1399 // <!ATTLIST PROPERTY
1400 // %CIMName;
1401 // %ClassOrigin;
1402 // %Propagated;
1403 // %CIMType; #REQUIRED>
1404 //
1405 //------------------------------------------------------------------------------
1406 mike 1.23
1407 Boolean XmlReader::getPropertyElement(XmlParser& parser, CIMProperty& property)
1408 {
1409 XmlEntry entry;
1410
1411 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY"))
1412 return false;
1413
1414 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1415
1416 // Get PROPERTY.NAME attribute:
1417
1418 String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
1419
1420 // Get PROPERTY.CLASSORIGIN attribute:
1421
1422 String classOrigin =
1423 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
1424
1425 // Get PROPERTY.PROPAGATED
1426
1427 mike 1.23 Boolean propagated = getCimBooleanAttribute(
1428 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
1429
1430 // Get PROPERTY.TYPE attribute:
1431
1432 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");
1433
1434 // Create property:
1435
1436 CIMValue value;
1437 value.setNullValue(type, false);
1438 property = CIMProperty(
1439 name, value, 0, String(), classOrigin, propagated);
1440
1441 if (!empty)
1442 {
1443 // Get qualifiers:
1444
1445 getQualifierElements(parser, property);
1446
1447 // Get value:
1448 mike 1.23
1449 if (getValueElement(parser, type, value))
1450 property.setValue(value);
1451
1452 expectEndTag(parser, "PROPERTY");
1453 }
1454
1455 return true;
1456 }
1457
1458 //------------------------------------------------------------------------------
1459 //
1460 // getArraySizeAttribute()
1461 //
1462 // Returns true if able to get array-size. Note that array size will
1463 // always be a positive integer.
1464 //
1465 // <!ENTITY % ArraySize "ARRAYSIZE CDATA #IMPLIED">
1466 //
1467 //------------------------------------------------------------------------------
1468
1469 mike 1.23 Boolean XmlReader::getArraySizeAttribute(
1470 Uint32 lineNumber,
1471 const XmlEntry& entry,
1472 const char* tagName,
1473 Uint32& value)
1474 {
1475 const char* tmp;
1476
1477 if (!entry.getAttributeValue("ARRAYSIZE", tmp))
1478 return false;
1479
1480 Uint64 arraySize;
1481
1482 if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)
1483 {
1484 char message[128];
1485 sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");
1486 throw XmlSemanticError(lineNumber, message);
1487 }
1488
1489 value = Uint32(arraySize);
1490 mike 1.23 return true;
1491 }
1492
1493 //------------------------------------------------------------------------------
1494 //
1495 // getPropertyArrayElement()
1496 //
1497 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
1498 // <!ATTLIST PROPERTY.ARRAY
1499 // %CIMName;
1500 // %CIMType; #REQUIRED
1501 // %ArraySize;
1502 // %ClassOrigin;
1503 // %Propagated;>
1504 //
1505 //------------------------------------------------------------------------------
1506
1507 Boolean XmlReader::getPropertyArrayElement(
1508 XmlParser& parser,
1509 CIMProperty& property)
1510 {
1511 mike 1.23 // Get PROPERTY element:
1512
1513 XmlEntry entry;
1514
1515 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.ARRAY"))
1516 return false;
1517
1518 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1519
1520 // Get PROPERTY.NAME attribute:
1521
1522 String name =
1523 getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
1524
1525 // Get PROPERTY.TYPE attribute:
1526
1527 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
1528
1529 // Get PROPERTY.ARRAYSIZE attribute:
1530
1531 Uint32 arraySize = 0;
1532 mike 1.23 getArraySizeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY", arraySize);
1533
1534 // Get PROPERTY.CLASSORIGIN attribute:
1535
1536 String classOrigin
1537 = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
1538
1539 // Get PROPERTY.ARRAY.PROPAGATED
1540
1541 Boolean propagated = getCimBooleanAttribute(
1542 parser.getLine(), entry, "PROPERTY.ARRAY", "PROPAGATED", false, false);
1543
1544 // Create property:
1545
1546 CIMValue nullValue;
1547 nullValue.setNullValue(type, true, arraySize);
1548 property = CIMProperty(
1549 name, nullValue, arraySize, String(), classOrigin, propagated);
1550
1551 if (!empty)
1552 {
1553 mike 1.23 // Get qualifiers:
1554
1555 getQualifierElements(parser, property);
1556
1557 // Get value:
1558
1559 CIMValue value;
1560
1561 if (getValueArrayElement(parser, type, value))
1562 {
1563 if (arraySize && arraySize != value.getArraySize())
1564 {
1565 throw XmlSemanticError(parser.getLine(),
1566 "ARRAYSIZE attribute and value-array size are different");
1567 }
1568
1569 property.setValue(value);
1570 }
1571
1572 expectEndTag(parser, "PROPERTY.ARRAY");
1573 }
1574 mike 1.23
1575 return true;
1576 }
1577
1578 //------------------------------------------------------------------------------
1579 //
1580 // getHostElement()
1581 //
1582 // <!ELEMENT HOST (#PCDATA)>
1583 //
1584 //------------------------------------------------------------------------------
1585
1586 Boolean XmlReader::getHostElement(
1587 XmlParser& parser,
1588 String& host)
1589 {
1590 XmlEntry entry;
1591
1592 if (!testStartTag(parser, entry, "HOST"))
1593 return false;
1594
1595 mike 1.23 if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)
1596 {
1597 throw XmlValidationError(parser.getLine(),
1598 "expected content of HOST element");
1599 }
1600
1601 host = entry.text;
1602
1603 expectEndTag(parser, "HOST");
1604 return true;
1605 }
1606
1607 //------------------------------------------------------------------------------
1608 //
1609 // getNameSpaceElement()
1610 //
1611 // <!ELEMENT NAMESPACE EMPTY>
1612 // <!ATTLIST NAMESPACE %CIMName;>
1613 //
1614 //------------------------------------------------------------------------------
1615
1616 mike 1.23 Boolean XmlReader::getNameSpaceElement(
1617 XmlParser& parser,
1618 String& nameSpaceComponent)
1619 {
1620 XmlEntry entry;
1621
1622 if (!testStartTagOrEmptyTag(parser, entry, "NAMESPACE"))
1623 return false;
1624
1625 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1626
1627 nameSpaceComponent = getCimNameAttribute(
1628 parser.getLine(), entry, "NAMESPACE");
1629
1630 if (!empty)
1631 expectEndTag(parser, "NAMESPACE");
1632
1633 return true;
1634 }
1635
1636 //------------------------------------------------------------------------------
1637 mike 1.23 //
1638 // getLocalNameSpacePathElement()
1639 //
1640 // <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
1641 //
1642 //------------------------------------------------------------------------------
1643
1644 Boolean XmlReader::getLocalNameSpacePathElement(
1645 XmlParser& parser,
1646 String& nameSpace)
1647 {
1648 XmlEntry entry;
1649
1650 if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))
1651 return false;
1652
1653 String nameSpaceComponent;
1654
1655 while (getNameSpaceElement(parser, nameSpaceComponent))
1656 {
1657 if (nameSpace.size())
1658 mike 1.23 nameSpace += '/';
1659
1660 nameSpace += nameSpaceComponent;
1661 }
1662
1663 if (!nameSpace.size())
1664 {
1665 throw XmlValidationError(parser.getLine(),
1666 "Expected one or more NAMESPACE elements within "
1667 "LOCALNAMESPACEPATH element");
1668 }
1669
1670 expectEndTag(parser, "LOCALNAMESPACEPATH");
1671 return true;
1672 }
1673
1674 //------------------------------------------------------------------------------
1675 //
1676 // getNameSpacePathElement()
1677 //
1678 // <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
1679 mike 1.23 //
1680 //------------------------------------------------------------------------------
1681
1682 Boolean XmlReader::getNameSpacePathElement(
1683 XmlParser& parser,
1684 String& host,
1685 String& nameSpace)
1686 {
1687 host.clear();
1688 nameSpace.clear();
1689
1690 XmlEntry entry;
1691
1692 if (!testStartTag(parser, entry, "NAMESPACEPATH"))
1693 return false;
1694
1695 if (!getHostElement(parser, host))
1696 throw XmlValidationError(parser.getLine(), "expected HOST element");
1697
1698 if (!getLocalNameSpacePathElement(parser, nameSpace))
1699 {
1700 mike 1.23 throw XmlValidationError(parser.getLine(),
1701 "expected LOCALNAMESPACEPATH element");
1702 }
1703
1704 expectEndTag(parser, "NAMESPACEPATH");
1705
1706 return true;
1707 }
1708
1709 //------------------------------------------------------------------------------
1710 //
1711 // getClassNameElement()
1712 //
1713 // <!ELEMENT CLASSNAME EMPTY>
1714 // <!ATTLIST CLASSNAME %CIMName;>
1715 //
1716 //------------------------------------------------------------------------------
1717
1718 Boolean XmlReader::getClassNameElement(
1719 XmlParser& parser,
1720 String& className,
1721 mike 1.23 Boolean required)
1722 {
1723 XmlEntry entry;
1724
1725 if (!testStartTagOrEmptyTag(parser, entry, "CLASSNAME"))
1726 {
1727 if (required)
1728 {
1729 throw XmlValidationError(parser.getLine(),
1730 "expected CLASSNAME element");
1731 }
1732 else
1733 return false;
1734 }
1735
1736 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1737
1738 className = getCimNameAttribute(
1739 parser.getLine(), entry, "CLASSNAME", true);
1740
1741 if (!empty)
1742 mike 1.23 expectEndTag(parser, "CLASSNAME");
1743
1744 return true;
1745 }
1746
1747 //------------------------------------------------------------------------------
1748 //
1749 // getValueTypeAttribute()
1750 //
1751 // VALUETYPE (string|boolean|numeric) 'string'
1752 //
1753 //------------------------------------------------------------------------------
1754
1755 KeyBinding::Type XmlReader::getValueTypeAttribute(
1756 Uint32 lineNumber,
1757 const XmlEntry& entry,
1758 const char* elementName)
1759 {
1760 String tmp;
1761
1762 if (!entry.getAttributeValue("VALUETYPE", tmp))
1763 mike 1.23 return KeyBinding::STRING;
1764
1765 if (String::equal(tmp, "string"))
1766 return KeyBinding::STRING;
1767 else if (String::equal(tmp, "boolean"))
1768 return KeyBinding::BOOLEAN;
1769 else if (String::equal(tmp, "numeric"))
1770 return KeyBinding::NUMERIC;
1771
1772 char buffer[MESSAGE_SIZE];
1773
1774 sprintf(buffer,
1775 "Illegal value for %s.VALUETYPE attribute; "
1776 "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",
1777 elementName);
1778
1779 throw XmlSemanticError(lineNumber, buffer);
1780 return KeyBinding::BOOLEAN;
1781 }
1782
1783 //------------------------------------------------------------------------------
1784 mike 1.23 //
1785 // getKeyValueElement()
1786 //
1787 // <!ELEMENT KEYVALUE (#PCDATA)>
1788 // <!ATTLIST KEYVALUE
1789 // VALUETYPE (string|boolean|numeric) 'string'>
1790 //
1791 //------------------------------------------------------------------------------
1792
1793 Boolean XmlReader::getKeyValueElement(
1794 XmlParser& parser,
1795 KeyBinding::Type& type,
1796 String& value)
1797 {
1798 XmlEntry entry;
1799
1800 if (!testStartTagOrEmptyTag(parser, entry, "KEYVALUE"))
1801 return false;
1802
1803 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1804
1805 mike 1.23 type = getValueTypeAttribute(parser.getLine(), entry, "KEYVALUE");
1806
1807 value.clear();
1808
1809 if (!empty)
1810 {
1811 if (!parser.next(entry))
1812 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
1813
1814 if (entry.type == XmlEntry::CONTENT)
1815 value = entry.text;
1816 else
1817 parser.putBack(entry);
1818
1819 expectEndTag(parser, "KEYVALUE");
1820 }
1821
1822 return true;
1823 }
1824
1825 //------------------------------------------------------------------------------
1826 mike 1.23 //
1827 // getKeyBindingElement()
1828 //
1829 // <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>
1830 // <!ATTLIST KEYBINDING
1831 // %CIMName;>
1832 //
1833 //------------------------------------------------------------------------------
1834
1835 Boolean XmlReader::getKeyBindingElement(
1836 XmlParser& parser,
1837 String& name,
1838 String& value,
1839 KeyBinding::Type& type)
1840 {
1841 XmlEntry entry;
1842
1843 if (!testStartTag(parser, entry, "KEYBINDING"))
1844 return false;
1845
1846 name = getCimNameAttribute(parser.getLine(), entry, "KEYBINDING");
1847 mike 1.23
1848 if (!getKeyValueElement(parser, type, value))
|
1925 mike 1.23
1926 return true;
1927 }
1928
1929 Boolean XmlReader::getInstanceNameElement(
1930 XmlParser& parser,
1931 CIMReference& instanceName)
1932 {
1933 String className;
1934 Array<KeyBinding> keyBindings;
1935
1936 if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
1937 return false;
1938
1939 instanceName.set(String(), String(), className, keyBindings);
1940 return true;
1941 }
1942
1943 //------------------------------------------------------------------------------
1944 //
1945 // getInstancePathElement()
1946 mike 1.23 //
1947 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
1948 //
1949 //------------------------------------------------------------------------------
1950
1951 Boolean XmlReader::getInstancePathElement(
1952 XmlParser& parser,
1953 CIMReference& reference)
1954 {
1955 XmlEntry entry;
1956
1957 if (!testStartTag(parser, entry, "INSTANCEPATH"))
1958 return false;
1959
1960 String host;
1961 String nameSpace;
1962
1963 if (!getNameSpacePathElement(parser, host, nameSpace))
1964 {
1965 throw XmlValidationError(parser.getLine(),
1966 "expected NAMESPACEPATH element");
1967 mike 1.23 }
1968
1969 String className;
1970 Array<KeyBinding> keyBindings;
1971
1972 if (!getInstanceNameElement(parser, className, keyBindings))
1973 {
1974 throw XmlValidationError(parser.getLine(),
1975 "expected INSTANCENAME element");
1976 }
1977
1978 reference.set(host, nameSpace, className, keyBindings);
1979
1980 expectEndTag(parser, "INSTANCEPATH");
1981 return true;
1982 }
1983
1984 //------------------------------------------------------------------------------
1985 //
1986 // getLocalInstancePathElement()
1987 //
1988 mike 1.23 // <!ELEMENT LOCALINSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
1989 //
1990 //------------------------------------------------------------------------------
1991
1992 Boolean XmlReader::getLocalInstancePathElement(
1993 XmlParser& parser,
1994 CIMReference& reference)
1995 {
1996 XmlEntry entry;
1997
1998 if (!testStartTag(parser, entry, "LOCALINSTANCEPATH"))
1999 return false;
2000
2001 String nameSpace;
2002
2003 if (!getLocalNameSpacePathElement(parser, nameSpace))
2004 {
2005 throw XmlValidationError(parser.getLine(),
2006 "expected LOCALNAMESPACEPATH element");
2007 }
2008
2009 mike 1.23 String className;
2010 Array<KeyBinding> keyBindings;
2011
2012 if (!getInstanceNameElement(parser, className, keyBindings))
2013 {
2014 throw XmlValidationError(parser.getLine(),
2015 "expected INSTANCENAME element");
2016 }
2017
2018 reference.set(String(), nameSpace, className, keyBindings);
2019
2020 expectEndTag(parser, "LOCALINSTANCEPATH");
2021 return true;
2022 }
2023
2024 //------------------------------------------------------------------------------
2025 //
2026 // getClassPathElement()
2027 //
2028 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
2029 //
2030 mike 1.23 //------------------------------------------------------------------------------
2031
2032 Boolean XmlReader::getClassPathElement(
2033 XmlParser& parser,
2034 CIMReference& reference)
2035 {
2036 XmlEntry entry;
2037
2038 if (!testStartTag(parser, entry, "CLASSPATH"))
2039 return false;
2040
2041 String host;
2042 String nameSpace;
2043
2044 if (!getNameSpacePathElement(parser, host, nameSpace))
2045 {
2046 throw XmlValidationError(parser.getLine(),
2047 "expected NAMESPACEPATH element");
2048 }
2049
2050 String className;
2051 mike 1.23
2052 if (!getClassNameElement(parser, className))
2053 {
2054 throw XmlValidationError(parser.getLine(),
2055 "expected CLASSNAME element");
2056 }
2057
2058 reference.set(host, nameSpace, className);
2059
2060 expectEndTag(parser, "CLASSPATH");
2061 return true;
2062 }
2063
2064 //------------------------------------------------------------------------------
2065 //
2066 // getLocalClassPathElement()
2067 //
2068 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH,CLASSNAME)>
2069 //
2070 //------------------------------------------------------------------------------
2071
2072 mike 1.23 Boolean XmlReader::getLocalClassPathElement(
2073 XmlParser& parser,
2074 CIMReference& reference)
2075 {
2076 XmlEntry entry;
2077
2078 if (!testStartTag(parser, entry, "LOCALCLASSPATH"))
2079 return false;
2080
2081 String nameSpace;
2082
2083 if (!getLocalNameSpacePathElement(parser, nameSpace))
2084 {
2085 throw XmlValidationError(parser.getLine(),
2086 "expected LOCALNAMESPACEPATH element");
2087 }
2088
2089 String className;
2090
2091 if (!getClassNameElement(parser, className))
2092 {
2093 mike 1.23 throw XmlValidationError(parser.getLine(),
2094 "expected CLASSNAME element");
2095 }
2096
2097 reference.set(String(), nameSpace, className);
2098
2099 expectEndTag(parser, "LOCALCLASSPATH");
2100
2101 return true;
2102 }
2103
2104 //------------------------------------------------------------------------------
2105 //
2106 // getValueReferenceElement()
2107 //
2108 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
2109 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
2110 //
2111 //
2112 //------------------------------------------------------------------------------
2113
2114 mike 1.23 Boolean XmlReader::getValueReferenceElement(
2115 XmlParser& parser,
2116 CIMReference& reference)
2117 {
2118 XmlEntry entry;
2119
2120 if (!testStartTag(parser, entry, "VALUE.REFERENCE"))
2121 return false;
2122
2123 if (!parser.next(entry))
2124 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
2125
2126 if (entry.type != XmlEntry::START_TAG &&
2127 entry.type != XmlEntry::EMPTY_TAG)
2128 {
2129 throw XmlValidationError(parser.getLine(),
2130 "Expected one of the following start tags: "
2131 "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "
2132 "LOCALINSTANCEPATH, INSTANCENAME");
2133 }
2134
2135 mike 1.23 if (strcmp(entry.text, "CLASSPATH") == 0)
2136 {
2137 parser.putBack(entry);
2138 getClassPathElement(parser, reference);
2139 }
2140 else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)
2141 {
2142 parser.putBack(entry);
2143 getLocalClassPathElement(parser, reference);
2144 }
2145 else if (strcmp(entry.text, "CLASSNAME") == 0)
2146 {
2147 parser.putBack(entry);
2148 String className;
2149 getClassNameElement(parser, className);
2150 reference.set(String(), String(), className);
2151 }
2152 else if (strcmp(entry.text, "INSTANCEPATH") == 0)
2153 {
2154 parser.putBack(entry);
2155 getInstancePathElement(parser, reference);
2156 mike 1.23 }
2157 else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)
2158 {
2159 parser.putBack(entry);
2160 getLocalInstancePathElement(parser, reference);
2161 }
2162 else if (strcmp(entry.text, "INSTANCENAME") == 0)
2163 {
2164 parser.putBack(entry);
2165 String className;
2166 Array<KeyBinding> keyBindings;
2167 getInstanceNameElement(parser, className, keyBindings);
2168 reference.set(String(), String(), className, keyBindings);
2169 }
2170
2171 expectEndTag(parser, "VALUE.REFERENCE");
2172 return true;
2173 }
2174
2175 //------------------------------------------------------------------------------
2176 //
2177 mike 1.23 // getPropertyReferenceElement()
2178 //
2179 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)>
2180 // <!ATTLIST PROPERTY.REFERENCE
2181 // %CIMName;
2182 // %ReferenceClass;
2183 // %ClassOrigin;
2184 // %Propagated;>
2185 //
2186 //------------------------------------------------------------------------------
2187
2188 Boolean XmlReader::getPropertyReferenceElement(
2189 XmlParser& parser,
2190 CIMProperty& property)
2191 {
2192 XmlEntry entry;
2193
2194 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.REFERENCE"))
2195 return false;
2196
2197 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2198 mike 1.23
2199 // Get PROPERTY.NAME attribute:
2200
2201 String name = getCimNameAttribute(
2202 parser.getLine(), entry, "PROPERTY.REFERENCE");
2203
2204 // Get PROPERTY.REFERENCECLASS attribute:
2205
2206 String referenceClass = getReferenceClassAttribute(
2207 parser.getLine(), entry, "PROPERTY.REFERENCE");
2208
2209 // Get PROPERTY.CLASSORIGIN attribute:
2210
2211 String classOrigin =
2212 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");
2213
2214 // Get PROPERTY.PROPAGATED
2215
2216 Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,
2217 "PROPERTY.REFERENCE", "PROPAGATED", false, false);
2218
2219 mike 1.23 // Create property:
2220
2221 CIMValue value;
2222 value.set(CIMReference());
2223 property = CIMProperty(
2224 name, value, 0, referenceClass, classOrigin, propagated);
2225
2226 if (!empty)
2227 {
2228 getQualifierElements(parser, property);
2229
2230 CIMReference reference;
2231
2232 if (getValueReferenceElement(parser, reference))
2233 property.setValue(reference);
2234
2235 expectEndTag(parser, "PROPERTY.REFERENCE");
2236 }
2237
2238 return true;
2239 }
2240 mike 1.23
2241 //------------------------------------------------------------------------------
2242 //
2243 // GetPropertyElements()
2244 //
2245 //------------------------------------------------------------------------------
2246
2247 template<class CONTAINER>
2248 void GetPropertyElements(XmlParser& parser, CONTAINER& container)
2249 {
2250 CIMProperty property;
2251
2252 while (XmlReader::getPropertyElement(parser, property) ||
2253 XmlReader::getPropertyArrayElement(parser, property) ||
2254 XmlReader::getPropertyReferenceElement(parser, property))
2255 {
2256 try
2257 {
2258 container.addProperty(property);
2259 }
2260 catch (AlreadyExists&)
2261 mike 1.23 {
2262 throw XmlSemanticError(parser.getLine(), "duplicate property");
2263 }
2264 }
2265 }
2266
2267 //------------------------------------------------------------------------------
2268 //
2269 // getParameterElement()
2270 //
2271 // <!ELEMENT PARAMETER (QUALIFIER*)>
2272 // <!ATTLIST PARAMETER
2273 // %CIMName;
2274 // %CIMType; #REQUIRED>
2275 //
2276 //------------------------------------------------------------------------------
2277
2278 Boolean XmlReader::getParameterElement(
2279 XmlParser& parser,
2280 CIMParameter& parameter)
2281 {
2282 mike 1.23 XmlEntry entry;
2283
2284 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER"))
2285 return false;
2286
2287 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2288
2289 // Get PARAMETER.NAME attribute:
2290
2291 String name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");
2292
2293 // Get PARAMETER.TYPE attribute:
2294
2295 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PARAMETER");
2296
2297 // Create parameter:
2298
2299 parameter = CIMParameter(name, type);
2300
2301 if (!empty)
2302 {
2303 mike 1.23 getQualifierElements(parser, parameter);
2304
2305 expectEndTag(parser, "PARAMETER");
2306 }
2307
2308 return true;
2309 }
2310
2311 //------------------------------------------------------------------------------
2312 //
2313 // getParameterArrayElement()
2314 //
2315 // <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
2316 // <!ATTLIST PARAMETER.ARRAY
2317 // %CIMName;
2318 // %CIMType; #REQUIRED
2319 // %ArraySize;>
2320 //
2321 //------------------------------------------------------------------------------
2322
2323 Boolean XmlReader::getParameterArrayElement(
2324 mike 1.23 XmlParser& parser,
2325 CIMParameter& parameter)
2326 {
2327 XmlEntry entry;
2328
2329 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.ARRAY"))
2330 return false;
2331
2332 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2333
2334 // Get PARAMETER.ARRAY.NAME attribute:
2335
2336 String name = getCimNameAttribute(
2337 parser.getLine(), entry, "PARAMETER.ARRAY");
2338
2339 // Get PARAMETER.ARRAY.TYPE attribute:
2340
2341 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY");
2342
2343 // Get PARAMETER.ARRAYSIZE attribute:
2344
2345 mike 1.23 Uint32 arraySize = 0;
2346 getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY",arraySize);
2347
2348 // Create parameter:
2349
2350 parameter = CIMParameter(name, type, true, arraySize);
2351
2352 if (!empty)
2353 {
2354 getQualifierElements(parser, parameter);
2355
2356 expectEndTag(parser, "PARAMETER.ARRAY");
2357 }
2358
2359 return true;
2360 }
2361
2362 //------------------------------------------------------------------------------
2363 //
2364 // getParameterReferenceElement()
2365 //
2366 mike 1.23 // <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
2367 // <!ATTLIST PARAMETER.REFERENCE
2368 // %CIMName;
2369 // %ReferenceClass;>
2370 //
2371 //------------------------------------------------------------------------------
2372
2373 Boolean XmlReader::getParameterReferenceElement(
2374 XmlParser& parser,
2375 CIMParameter& parameter)
2376 {
2377 XmlEntry entry;
2378
2379 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFERENCE"))
2380 return false;
2381
2382 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2383
2384 // Get PARAMETER.NAME attribute:
2385
2386 String name = getCimNameAttribute(
2387 mike 1.23 parser.getLine(), entry, "PARAMETER.REFERENCE");
2388
2389 // Get PARAMETER.REFERENCECLASS attribute:
2390
2391 String referenceClass = getReferenceClassAttribute(
2392 parser.getLine(), entry, "PARAMETER.REFERENCE");
2393
2394 // Create parameter:
2395
2396 parameter = CIMParameter(name, CIMType::REFERENCE, false, 0, referenceClass);
2397
2398 if (!empty)
2399 {
2400 getQualifierElements(parser, parameter);
2401 expectEndTag(parser, "PARAMETER.REFERENCE");
2402 }
2403
2404 return true;
2405 }
2406
2407 //------------------------------------------------------------------------------
2408 mike 1.23 //
2409 // GetParameterElements()
2410 //
2411 //------------------------------------------------------------------------------
2412
2413 template<class CONTAINER>
2414 void GetParameterElements(XmlParser& parser, CONTAINER& container)
2415 {
2416 CIMParameter parameter;
2417
2418 while (XmlReader::getParameterElement(parser, parameter) ||
2419 XmlReader::getParameterArrayElement(parser, parameter) ||
2420 XmlReader::getParameterReferenceElement(parser, parameter))
2421 {
2422 try
2423 {
2424 container.addParameter(parameter);
2425 }
2426 catch (AlreadyExists&)
2427 {
2428 throw XmlSemanticError(parser.getLine(), "duplicate parameter");
2429 mike 1.23 }
2430 }
2431 }
2432
2433 //------------------------------------------------------------------------------
2434 //
2435 // getQualifierDeclElement()
2436 //
2437 // <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
2438 // <!ATTLIST QUALIFIER.DECLARATION
2439 // %CIMName;
2440 // %CIMType; #REQUIRED
2441 // ISARRAY (true|false) #IMPLIED
2442 // %ArraySize;
2443 // %QualifierFlavor;>
2444 //
2445 //------------------------------------------------------------------------------
2446
2447 Boolean XmlReader::getQualifierDeclElement(
2448 XmlParser& parser,
2449 CIMQualifierDecl& qualifierDecl)
2450 mike 1.23 {
2451 XmlEntry entry;
2452
2453 if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER.DECLARATION"))
2454 return false;
2455
2456 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2457
2458 // Get NAME attribute:
2459
2460 String name = getCimNameAttribute(
2461 parser.getLine(), entry, "QUALIFIER.DECLARATION");
2462
2463 // Get TYPE attribute:
2464
2465 CIMType type = getCimTypeAttribute(
2466 parser.getLine(), entry, "QUALIFIER.DECLARATION");
2467
2468 // Get ISARRAY attribute:
2469
2470 Boolean isArray = false;
2471 mike 1.23 getIsArrayAttribute(
2472 parser.getLine(), entry, "QUALIFIER.DECLARATION", isArray);
2473
2474 // Get ARRAYSIZE attribute:
2475
2476 Uint32 arraySize = 0;
2477 Boolean gotArraySize = getArraySizeAttribute(parser.getLine(),
2478 entry, "QUALIFIER.DECLARATION", arraySize);
2479
2480 // Get flavor oriented attributes:
2481
2482 Uint32 flavor = getFlavor(entry,parser.getLine(), "QUALIFIER.DECLARATION");
2483
2484 // No need to look for interior elements if empty tag:
2485
2486 Uint32 scope = CIMScope::NONE;
2487 CIMValue value;
2488
2489 if (!empty)
2490 {
2491 // Get the option SCOPE element:
2492 mike 1.23
2493 scope = getOptionalScope(parser);
2494
2495 // Get VALUE or VALUE.ARRAY element:
2496
2497 if (getValueArrayElement(parser, type, value))
2498 {
2499 if (!isArray)
2500 {
2501 throw XmlSemanticError(parser.getLine(),
2502 "VALUE.ARRAY element encountered without "
2503 "ISARRAY attribute");
2504 }
2505
2506 if (arraySize && arraySize != value.getArraySize())
2507 {
2508 throw XmlSemanticError(parser.getLine(),
2509 "VALUE.ARRAY size is not the same as "
2510 "ARRAYSIZE attribute");
2511 }
2512 }
2513 mike 1.23 else if (getValueElement(parser, type, value))
2514 {
2515 if (isArray)
2516 {
2517 throw XmlSemanticError(parser.getLine(),
2518 "ISARRAY attribute used but VALUE element encountered");
2519 }
2520 }
2521
2522 // Now get the closing tag:
2523
2524 expectEndTag(parser, "QUALIFIER.DECLARATION");
2525 }
2526
2527 if (value.getType() == CIMType::NONE)
2528 {
2529 if (isArray)
2530 value.setNullValue(type, true, arraySize);
2531 else
2532 value.setNullValue(type, false);
2533 }
2534 mike 1.23
2535 CIMQualifierDecl tmp(name, value, scope, flavor, arraySize);
2536 qualifierDecl = CIMQualifierDecl(name, value, scope, flavor, arraySize);
2537 return true;
2538 }
2539
2540 //------------------------------------------------------------------------------
2541 // getMethodElement()
2542 //
2543 // <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|
2544 // PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
2545 // <!ATTLIST METHOD
2546 // %CIMName;
2547 // %CIMType; #IMPLIED
2548 // %ClassOrigin;
2549 // %Propagated;>
2550 //
2551 //------------------------------------------------------------------------------
2552
2553 Boolean XmlReader::getMethodElement(XmlParser& parser, CIMMethod& method)
2554 {
2555 mike 1.23 XmlEntry entry;
2556
2557 if (!testStartTagOrEmptyTag(parser, entry, "METHOD"))
2558 return false;
2559
2560 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2561
2562 String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
2563
2564 CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");
2565
2566 String classOrigin =
2567 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
2568
2569 Boolean propagated = getCimBooleanAttribute(
2570 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
2571
2572 method = CIMMethod(name, type, classOrigin, propagated);
2573
2574 if (!empty)
2575 {
2576 mike 1.23 getQualifierElements(parser, method);
2577
2578 GetParameterElements(parser, method);
2579
2580 expectEndTag(parser, "METHOD");
2581 }
2582
2583 return true;
2584 }
2585
2586 //------------------------------------------------------------------------------
2587 // getClassElement()
2588 //
2589 // <!ELEMENT CLASS (QUALIFIER*,
2590 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
2591 // <!ATTLIST CLASS %CIMName; %SuperClass;>
2592 //
2593 //------------------------------------------------------------------------------
2594
2595 Boolean XmlReader::getClassElement(XmlParser& parser, CIMClass& cimClass)
2596 {
2597 mike 1.23 XmlEntry entry;
2598
2599 if (!testStartTag(parser, entry, "CLASS"))
2600 return false;
2601
2602 String name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
2603
2604 String superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");
2605
2606 cimClass = CIMClass(name, superClass);
2607
2608 // Get QUALIFIER elements:
2609
2610 getQualifierElements(parser, cimClass);
2611
2612 // Get PROPERTY elements:
2613
2614 GetPropertyElements(parser, cimClass);
2615
2616 // Get METHOD elements:
2617
2618 mike 1.23 CIMMethod method;
2619
2620 while (getMethodElement(parser, method))
2621 cimClass.addMethod(method);
2622
2623 // Get CLASS end tag:
2624
2625 expectEndTag(parser, "CLASS");
2626
2627 return true;
2628 }
2629
2630 //------------------------------------------------------------------------------
2631 // getInstanceElement()
2632 //
2633 // <!ELEMENT INSTANCE (QUALIFIER*,
2634 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*) >
2635 // <!ATTLIST INSTANCE
2636 // %ClassName;>
2637 //
2638 //------------------------------------------------------------------------------
2639 mike 1.23
2640 Boolean XmlReader::getInstanceElement(
2641 XmlParser& parser,
2642 CIMInstance& cimInstance)
2643 {
2644 XmlEntry entry;
2645
2646 if (!testStartTag(parser, entry, "INSTANCE"))
2647 return false;
2648
2649 String className = getClassNameAttribute(
2650 parser.getLine(), entry, "INSTANCE");
2651
2652 cimInstance = CIMInstance(className);
2653
2654 // Get QUALIFIER elements:
2655
2656 getQualifierElements(parser, cimInstance);
2657
2658 // Get PROPERTY elements:
2659
2660 mike 1.23 GetPropertyElements(parser, cimInstance);
2661
2662 // Get INSTANCE end tag:
2663
2664 expectEndTag(parser, "INSTANCE");
2665
2666 return true;
2667 }
2668
2669 //------------------------------------------------------------------------------
2670 //
2671 // getObject()
2672 //
2673 //------------------------------------------------------------------------------
2674
2675 void XmlReader::getObject(XmlParser& parser, CIMClass& x)
2676 {
2677 if (!getClassElement(parser, x))
2678 {
2679 throw XmlValidationError(parser.getLine(),
2680 "expected CLASS element");
2681 mike 1.23 }
2682 }
2683
2684 //------------------------------------------------------------------------------
2685 //
2686 // getObject()
2687 //
2688 //------------------------------------------------------------------------------
2689
2690 void XmlReader::getObject(XmlParser& parser, CIMInstance& x)
2691 {
2692 if (!getInstanceElement(parser, x))
2693 {
2694 throw XmlValidationError(parser.getLine(),
2695 "expected INSTANCE element");
2696 }
2697 }
2698
2699 //------------------------------------------------------------------------------
2700 //
2701 // getObject()
2702 mike 1.23 //
2703 //------------------------------------------------------------------------------
2704
2705 void XmlReader::getObject(XmlParser& parser, CIMQualifierDecl& x)
2706 {
2707 if (!getQualifierDeclElement(parser, x))
2708 {
2709 throw XmlValidationError(parser.getLine(),
2710 "expected QUALIFIER.DECLARATION element");
2711 }
2712 }
2713
2714 //------------------------------------------------------------------------------
2715 //
2716 // getMessageStartTag()
2717 //
2718 //------------------------------------------------------------------------------
2719
2720 Boolean XmlReader::getMessageStartTag(
2721 XmlParser& parser,
2722 String& id,
2723 mike 1.23 const char*& protocolVersion)
2724 {
2725 XmlEntry entry;
2726
2727 if (!testStartTag(parser, entry, "MESSAGE"))
2728 return false;
2729
2730 // Get MESSAGE.ID:
2731
2732 if (!entry.getAttributeValue("ID", id))
2733 throw XmlValidationError(parser.getLine(),
2734 "Bad or missing MESSAGE.ID attribute");
2735
2736 // Get MESSAGE.PROTOCOLVERSION:
2737
2738 if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))
2739 throw XmlValidationError(parser.getLine(),
2740 "Bad or missing MESSAGE.PROTOCOLVERSION attribute");
2741
2742 return true;
2743 }
2744 mike 1.23
2745 //------------------------------------------------------------------------------
2746 //
2747 // getIMethodCallStartTag()
2748 //
2749 //------------------------------------------------------------------------------
2750
2751 Boolean XmlReader::getIMethodCallStartTag(
2752 XmlParser& parser,
2753 const char*& name)
2754 {
2755 XmlEntry entry;
2756
2757 if (!testStartTag(parser, entry, "IMETHODCALL"))
2758 return false;
2759
2760 // Get IMETHODCALL.NAME attribute:
2761
2762 if (!entry.getAttributeValue("NAME", name))
2763 throw XmlValidationError(parser.getLine(),
2764 "Missing IMETHODCALL.NAME attribute");
2765 mike 1.23
2766 return true;
2767 }
2768
2769 //------------------------------------------------------------------------------
2770 //
2771 // getIMethodResponseStartTag()
2772 //
2773 //------------------------------------------------------------------------------
2774
2775 Boolean XmlReader::getIMethodResponseStartTag(
2776 XmlParser& parser,
2777 const char*& name)
2778 {
2779 XmlEntry entry;
2780
2781 if (!testStartTag(parser, entry, "IMETHODRESPONSE"))
2782 return false;
2783
2784 // Get IMETHODRESPONSE.NAME attribute:
2785
2786 mike 1.23 if (!entry.getAttributeValue("NAME", name))
2787 throw XmlValidationError(parser.getLine(),
2788 "Missing IMETHODRESPONSE.NAME attribute");
2789
2790 return true;
2791 }
2792
2793 //------------------------------------------------------------------------------
2794 //
2795 // getIParamValueTag()
2796 //
2797 //------------------------------------------------------------------------------
2798
2799 Boolean XmlReader::getIParamValueTag(
2800 XmlParser& parser,
2801 const char*& name)
2802 {
2803 XmlEntry entry;
2804
2805 if (!testStartTag(parser, entry, "IPARAMVALUE"))
2806 return false;
2807 mike 1.23
2808 // Get IPARAMVALUE.NAME attribute:
2809
2810 if (!entry.getAttributeValue("NAME", name))
2811 throw XmlValidationError(parser.getLine(),
2812 "Missing IPARAMVALUE.NAME attribute");
2813
2814 return true;
2815 }
2816
2817 //------------------------------------------------------------------------------
2818 //
2819 // getBooleanValueElement()
2820 //
2821 // Get an elements like: "<VALUE>FALSE</VALUE>"
2822 //
2823 //------------------------------------------------------------------------------
2824
2825 Boolean XmlReader::getBooleanValueElement(
2826 XmlParser& parser,
2827 Boolean& result,
2828 mike 1.23 Boolean required)
2829 {
2830 XmlEntry entry;
2831
2832 if (!testStartTag(parser, entry, "VALUE"))
2833 {
2834 if (required)
2835 {
2836 throw XmlValidationError(parser.getLine(),
2837 "Expected VALUE element");
2838 }
2839 return false;
2840 }
2841
2842 expectContentOrCData(parser, entry);
2843
2844 if (strcmp(entry.text, "TRUE") == 0)
2845 result = true;
2846 else if (strcmp(entry.text, "FALSE") == 0)
2847 result = false;
2848 else
2849 mike 1.23 throw XmlSemanticError(parser.getLine(),
2850 "Bad value for VALUE element: must be \"TRUE\" or \"FALSE\"");
2851
2852 expectEndTag(parser, "VALUE");
2853
2854 return true;
2855 }
2856
2857 //------------------------------------------------------------------------------
2858 //
2859 // getErrorElement()
2860 //
2861 // <!ELEMENT ERROR EMPTY>
2862 // <!ATTLIST ERROR
2863 // CODE CDATA #REQUIRED
2864 // DESCRIPTION CDATA #IMPLIED>
2865 //
2866 //------------------------------------------------------------------------------
2867
2868 Boolean XmlReader::getErrorElement(
2869 XmlParser& parser,
2870 mike 1.23 CIMStatusCode& code,
2871 const char*& description,
2872 Boolean required)
2873 {
2874 XmlEntry entry;
2875
2876 if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))
2877 {
2878 if (required)
2879 throw XmlValidationError(parser.getLine(),"Expected ERROR element");
2880 return false;
2881 }
2882
2883 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2884
2885 // Get ERROR.CODE
2886
2887 Uint32 tmpCode;
2888
2889 if (!entry.getAttributeValue("CODE", tmpCode))
2890 throw XmlValidationError(
2891 mike 1.23 parser.getLine(), "missing ERROR.CODE attribute");
2892
2893 code = CIMStatusCode(tmpCode);
2894
2895 // Get ERROR.DESCRIPTION:
2896
2897 description = "";
2898 entry.getAttributeValue("DESCRIPTION", description);
2899
2900 if (!empty)
2901 expectEndTag(parser, "ERROR");
2902
2903 return true;
2904 }
2905
2906
2907 //------------------------------------------------------------------------------
2908 // getObjectWithPath()
2909 //
2910 // <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
2911 //
2912 mike 1.23 //------------------------------------------------------------------------------
2913
2914 Boolean XmlReader::getObjectWithPath(
2915 XmlParser& parser,
2916 CIMObjectWithPath& objectWithPath)
2917 {
2918 XmlEntry entry;
2919
2920 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))
2921 return false;
2922
2923 CIMReference reference;
2924 Boolean isInstance = false;
2925
2926 if (XmlReader::getInstancePathElement(parser, reference))
2927 isInstance = true;
2928 else if (!XmlReader::getClassPathElement(parser, reference))
2929 {
2930 throw XmlValidationError(parser.getLine(),
2931 "Expected INSTANCE element");
2932 }
2933 mike 1.23
2934 if (isInstance)
2935 {
2936 CIMInstance cimInstance;
2937
2938 if (!XmlReader::getInstanceElement(parser, cimInstance))
2939 {
2940 throw XmlValidationError(parser.getLine(),
2941 "Expected INSTANCEPATH or CLASSPATH element");
2942 }
2943 objectWithPath.set(reference, CIMObject(cimInstance));
2944 }
2945 else
2946 {
2947 CIMClass cimClass;
2948
2949 if (!XmlReader::getClassElement(parser, cimClass))
2950 {
2951 throw XmlValidationError(parser.getLine(),
2952 "Expected CLASS element");
2953 }
2954 mike 1.23 objectWithPath.set(reference, CIMObject(cimClass));
2955 }
2956
2957 expectEndTag(parser, "VALUE.OBJECTWITHPATH");
2958
2959 return true;
2960 }
2961
2962 //------------------------------------------------------------------------------
2963 //
2964 // <objectName>: (CLASSNAME|INSTANCENAME)
2965 //
2966 //------------------------------------------------------------------------------
2967
2968 Boolean XmlReader::getObjectNameElement(
2969 XmlParser& parser,
2970 CIMReference& objectName)
2971 {
2972 String className;
2973 CIMReference instanceName;
2974
2975 mike 1.23 if (getClassNameElement(parser, className, false))
2976 {
2977 objectName.set(String(), String(), className);
2978 return true;
2979 }
2980 else if (getInstanceNameElement(parser, objectName))
2981 return true;
2982 else
2983 {
2984 throw XmlValidationError(parser.getLine(),
2985 "expected CLASSNAME or INSTANCENAME element");
2986 }
2987
2988 return false;
2989 }
2990
2991 //------------------------------------------------------------------------------
2992 //
2993 // <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>
2994 //
2995 //------------------------------------------------------------------------------
2996 mike 1.23
2997 Boolean XmlReader::getObjectPathElement(
2998 XmlParser& parser,
2999 CIMReference& objectPath)
3000 {
3001 XmlEntry entry;
3002
3003 if (!testStartTag(parser, entry, "OBJECTPATH"))
3004 return false;
3005
3006 if (getClassPathElement(parser, objectPath))
3007 {
3008 expectEndTag(parser, "OBJECTPATH");
3009 return true;
3010 }
3011 else if (getInstancePathElement(parser, objectPath))
3012 {
3013 expectEndTag(parser, "OBJECTPATH");
3014 return true;
3015 }
3016 else
3017 mike 1.23 {
3018 throw XmlValidationError(parser.getLine(),
3019 "expected INSTANCEPATH or CLASSPATH element");
3020 }
3021
|
Return to
XmlReader.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common