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