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