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