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