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