1 karl 1.94 //%2003////////////////////////////////////////////////////////////////////////
|
2 mike 1.23 //
|
3 karl 1.94 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development
4 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
6 // IBM Corp.; EMC Corporation, The Open Group.
|
7 mike 1.23 //
8 // Permission is hereby granted, free of charge, to any person obtaining a copy
|
9 kumpf 1.58 // of this software and associated documentation files (the "Software"), to
10 // deal in the Software without restriction, including without limitation the
11 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
12 mike 1.23 // sell copies of the Software, and to permit persons to whom the Software is
13 // furnished to do so, subject to the following conditions:
14 //
|
15 kumpf 1.58 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
|
16 mike 1.23 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
17 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
|
18 kumpf 1.58 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
19 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
21 mike 1.23 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 //
24 //==============================================================================
25 //
26 // Author: Mike Brasher (mbrasher@bmc.com)
27 //
|
28 mike 1.25 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
29 // (carolann_graves@hp.com)
30 // Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
31 // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
|
32 mike 1.23 //
33 //%/////////////////////////////////////////////////////////////////////////////
|
34 mday 1.45 #include <Pegasus/Common/Config.h>
|
35 mike 1.23 #include <cctype>
36 #include <cstdio>
37 #include <cstdlib>
|
38 ramnath 1.46 #if defined(PEGASUS_OS_TYPE_UNIX)
|
39 mday 1.45 #include <errno.h>
40 #endif
|
41 mike 1.23 #include "CIMName.h"
42 #include "XmlReader.h"
43 #include "XmlWriter.h"
44 #include "CIMQualifier.h"
45 #include "CIMQualifierDecl.h"
46 #include "CIMClass.h"
47 #include "CIMInstance.h"
48 #include "CIMObject.h"
|
49 mike 1.25 #include "CIMParamValue.h"
|
50 kumpf 1.72 #include "System.h"
|
51 humberto 1.91 #include "XmlConstants.h"
|
52 david 1.86 #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
53 #include "OS400ConvertChar.h"
54 #endif
|
55 humberto 1.85 // l10n
56 #include <Pegasus/Common/MessageLoader.h>
57
|
58 kumpf 1.82 #define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000))
|
59 kumpf 1.74 #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)
|
60 kumpf 1.68
|
61 mike 1.25 PEGASUS_USING_STD;
|
62 mike 1.23 PEGASUS_NAMESPACE_BEGIN
63
64 static const Uint32 MESSAGE_SIZE = 128;
65
66 //------------------------------------------------------------------------------
67 //
|
68 kumpf 1.49 // getXmlDeclaration()
69 //
70 // <?xml version="1.0" encoding="utf-8"?>
|
71 mike 1.23 //
72 //------------------------------------------------------------------------------
73
|
74 kumpf 1.49 void XmlReader::getXmlDeclaration(
|
75 mike 1.23 XmlParser& parser,
|
76 kumpf 1.49 const char*& xmlVersion,
77 const char*& xmlEncoding)
|
78 mike 1.23 {
|
79 kumpf 1.49 XmlEntry entry;
80
|
81 mike 1.23 if (!parser.next(entry) ||
82 entry.type != XmlEntry::XML_DECLARATION ||
83 strcmp(entry.text, "xml") != 0)
84 {
|
85 humberto 1.85
86 // l10n
87
88 // throw XmlValidationError(parser.getLine(),
89 // "Expected <?xml ... ?> style declaration");
90
91 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE",
|
92 humberto 1.87 "Expected <?xml ... ?> style declaration");
|
93 humberto 1.85
94 throw XmlValidationError(parser.getLine(), mlParms);
95
|
96 kumpf 1.49 }
97
|
98 humberto 1.85 if (!entry.getAttributeValue("version", xmlVersion)) {
99
100 // l10n
101
102 // throw XmlValidationError(
103 // parser.getLine(), "missing xml.version attribute");
104
|
105 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_XML_ATTRIBUTE",
106 "missing xml.version attribute");
|
107 humberto 1.85
108 throw XmlValidationError(parser.getLine(), mlParms);
109 }
|
110 kumpf 1.49
111 if (!entry.getAttributeValue("encoding", xmlEncoding))
112 {
113 // ATTN-RK-P3-20020403: Is there a default encoding?
|
114 mike 1.23 }
115 }
116
117 //------------------------------------------------------------------------------
118 //
|
119 mike 1.25 // testXmlDeclaration ()
120 //
121 //------------------------------------------------------------------------------
122
123 Boolean XmlReader::testXmlDeclaration (
124 XmlParser& parser,
125 XmlEntry& entry)
126 {
127 if (!parser.next (entry) ||
128 entry.type != XmlEntry::XML_DECLARATION ||
129 strcmp (entry.text, "xml") != 0)
130 {
131 parser.putBack (entry);
132 return false;
133 }
134
135 return true;
136 }
137
138 //------------------------------------------------------------------------------
139 //
|
140 mike 1.23 // expectStartTag()
141 //
142 //------------------------------------------------------------------------------
143
144 void XmlReader::expectStartTag(
145 XmlParser& parser,
146 XmlEntry& entry,
147 const char* tagName)
148 {
149 if (!parser.next(entry) ||
150 entry.type != XmlEntry::START_TAG ||
151 strcmp(entry.text, tagName) != 0)
152 {
|
153 humberto 1.85 // l10n
154
155 // char message[MESSAGE_SIZE];
156 // sprintf(message, "Expected open of %s element", tagName);
157 // throw XmlValidationError(parser.getLine(), message);
158
159 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
160 "Expected open of $0 element",
161 tagName);
162
163 throw XmlValidationError(parser.getLine(), mlParms);
|
164 mike 1.23 }
165 }
166
167 //------------------------------------------------------------------------------
168 //
169 // expectEndTag()
170 //
171 //------------------------------------------------------------------------------
172
173 void XmlReader::expectEndTag(XmlParser& parser, const char* tagName)
174 {
175 XmlEntry entry;
176
177 if (!parser.next(entry) ||
178 entry.type != XmlEntry::END_TAG ||
179 strcmp(entry.text, tagName) != 0)
180 {
|
181 humberto 1.85
182 // l10n
183
184 // char message[MESSAGE_SIZE];
185 // sprintf(message, "Expected close of %s element, got %s instead",
186 // tagName,entry.text);
187 // throw XmlValidationError(parser.getLine(), message);
188
189 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLOSE",
190 "Expected close of $0 element, got $1 instead",
191 tagName,entry.text);
192
193 throw XmlValidationError(parser.getLine(), mlParms);
|
194 mike 1.23 }
195 }
196
197 //------------------------------------------------------------------------------
198 //
199 // expectStartTagOrEmptyTag()
200 //
201 //------------------------------------------------------------------------------
202
203 void XmlReader::expectStartTagOrEmptyTag(
204 XmlParser& parser,
205 XmlEntry& entry,
206 const char* tagName)
207 {
208 if (!parser.next(entry) ||
209 (entry.type != XmlEntry::START_TAG &&
210 entry.type != XmlEntry::EMPTY_TAG) ||
211 strcmp(entry.text, tagName) != 0)
212 {
|
213 humberto 1.85 // l10n
214
215 // char message[MESSAGE_SIZE];
216 // sprintf(message,
217 // "Expected either open or open/close %s element", tagName);
218 // throw XmlValidationError(parser.getLine(), message);
219
220 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPENCLOSE",
221 "Expected either open or open/close $0 element",
222 tagName);
223
224 throw XmlValidationError(parser.getLine(), mlParms);
|
225 mike 1.23 }
226 }
227
228 //------------------------------------------------------------------------------
229 //
230 // expectContentOrCData()
231 //
232 //------------------------------------------------------------------------------
233
234 Boolean XmlReader::expectContentOrCData(
235 XmlParser& parser,
236 XmlEntry& entry)
237 {
238 if (!parser.next(entry) ||
239 (entry.type != XmlEntry::CONTENT &&
240 entry.type != XmlEntry::CDATA))
241 {
|
242 humberto 1.85 // l10n
243
244 // throw XmlValidationError(parser.getLine(),
245 // "Expected content of CDATA");
246
247 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA",
|
248 humberto 1.87 "Expected content of CDATA");
|
249 humberto 1.85
250 throw XmlValidationError(parser.getLine(), mlParms);
251
|
252 mike 1.23 }
253
254 return true;
255 }
256
257 //------------------------------------------------------------------------------
258 //
259 // testStartTag()
260 //
261 //------------------------------------------------------------------------------
262
263 Boolean XmlReader::testStartTag(
264 XmlParser& parser,
265 XmlEntry& entry,
266 const char* tagName)
267 {
268 if (!parser.next(entry) ||
269 entry.type != XmlEntry::START_TAG ||
270 strcmp(entry.text, tagName) != 0)
271 {
272 parser.putBack(entry);
273 mike 1.23 return false;
274 }
275
276 return true;
277 }
278
279 //------------------------------------------------------------------------------
280 //
|
281 kumpf 1.48 // testEndTag()
|
282 mike 1.23 //
283 //------------------------------------------------------------------------------
284
285 Boolean XmlReader::testEndTag(XmlParser& parser, const char* tagName)
286 {
287 XmlEntry entry;
288
289 if (!parser.next(entry) ||
290 entry.type != XmlEntry::END_TAG ||
291 strcmp(entry.text, tagName) != 0)
292 {
293 parser.putBack(entry);
294 return false;
295 }
296
297 return true;
298 }
299
300 //------------------------------------------------------------------------------
301 //
302 // testStartTagOrEmptyTag()
303 mike 1.23 //
304 //------------------------------------------------------------------------------
305
306 Boolean XmlReader::testStartTagOrEmptyTag(
307 XmlParser& parser,
308 XmlEntry& entry,
309 const char* tagName)
310 {
311 if (!parser.next(entry) ||
312 (entry.type != XmlEntry::START_TAG &&
313 entry.type != XmlEntry::EMPTY_TAG) ||
314 strcmp(entry.text, tagName) != 0)
315 {
316 parser.putBack(entry);
317 return false;
318 }
319
320 return true;
321 }
322
323 //------------------------------------------------------------------------------
324 mike 1.23 //
|
325 kumpf 1.95 // testStartTagOrEmptyTag()
326 //
327 //------------------------------------------------------------------------------
328
329 Boolean XmlReader::testStartTagOrEmptyTag(
330 XmlParser& parser,
331 XmlEntry& entry)
332 {
333 if (!parser.next(entry) ||
334 (entry.type != XmlEntry::START_TAG &&
335 entry.type != XmlEntry::EMPTY_TAG))
336 {
337 parser.putBack(entry);
338 return false;
339 }
340
341 return true;
342 }
343
344 //------------------------------------------------------------------------------
345 //
|
346 mike 1.23 // testContentOrCData()
347 //
348 //------------------------------------------------------------------------------
349
350 Boolean XmlReader::testContentOrCData(
351 XmlParser& parser,
352 XmlEntry& entry)
353 {
354 if (!parser.next(entry) ||
355 (entry.type != XmlEntry::CONTENT &&
356 entry.type != XmlEntry::CDATA))
357 {
358 parser.putBack(entry);
359 return false;
360 }
361
362 return true;
363 }
364
365 //------------------------------------------------------------------------------
366 //
|
367 kumpf 1.34 // getCimStartTag()
|
368 mike 1.23 //
369 // <!ELEMENT CIM (MESSAGE|DECLARATION)>
370 // <!ATTRLIST CIM
371 // CIMVERSION CDATA #REQUIRED
372 // DTDVERSION CDATA #REQUIRED>
373 //
374 //------------------------------------------------------------------------------
375
|
376 kumpf 1.34 void XmlReader::getCimStartTag(
377 XmlParser& parser,
378 const char*& cimVersion,
379 const char*& dtdVersion)
|
380 mike 1.23 {
381 XmlEntry entry;
382 XmlReader::expectStartTag(parser, entry, "CIM");
383
|
384 humberto 1.85 if (!entry.getAttributeValue("CIMVERSION", cimVersion)) {
385
386 // l10n
387
388 // throw XmlValidationError(
389 // parser.getLine(), "missing CIM.CIMVERSION attribute");
390
|
391 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",
392 "missing CIM.CIMVERSION attribute");
|
393 humberto 1.85
394 throw XmlValidationError(parser.getLine(), mlParms);
395 }
396
397 if (!entry.getAttributeValue("DTDVERSION", dtdVersion)){
398
399 // l10n
400
401 // throw XmlValidationError(
402 // parser.getLine(), "missing CIM.DTDVERSION attribute");
403
|
404 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",
405 "missing CIM.DTDVERSION attribute");
|
406 humberto 1.85
407 throw XmlValidationError(parser.getLine(), mlParms);
408 }
|
409 mike 1.23 }
410
411 //------------------------------------------------------------------------------
412 //
413 // getCimNameAttribute()
414 //
415 // <!ENTITY % CIMName "NAME CDATA #REQUIRED">
416 //
417 //------------------------------------------------------------------------------
418
|
419 kumpf 1.74 CIMName XmlReader::getCimNameAttribute(
|
420 mike 1.23 Uint32 lineNumber,
421 const XmlEntry& entry,
422 const char* elementName,
423 Boolean acceptNull)
424 {
425 String name;
426
427 if (!entry.getAttributeValue("NAME", name))
|
428 humberto 1.85 {
429
430 // l10n
431
432 // char buffer[MESSAGE_SIZE];
433 // sprintf(buffer, "missing %s.NAME attribute", elementName);
434 // throw XmlValidationError(lineNumber, buffer);
435
|
436 mike 1.23 char buffer[MESSAGE_SIZE];
|
437 humberto 1.85 sprintf(buffer, "%s.NAME", elementName);
438 MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
439 "missing $0 attribute",
440 buffer);
441
442 throw XmlValidationError(lineNumber, mlParms);
|
443 mike 1.23 }
444
445 if (acceptNull && name.size() == 0)
|
446 kumpf 1.74 return CIMName ();
|
447 karl 1.78
|
448 mike 1.23 if (!CIMName::legal(name))
449 {
|
450 karl 1.78 #ifdef PEGASUS_SNIA_INTEROP_TEST
451 // In testing, replace illegal CIMName with this value to avoid the
452 // exception and let xml parsing continue. THIS IS TEMP.
453 name = "BADNAMESUBSTITUTEDBYPEGASUSCLIENT";
454 #else
|
455 humberto 1.85
456 // l10n
457
458 // char buffer[MESSAGE_SIZE];
459 // sprintf(buffer, "Illegal value for %s.NAME attribute", elementName);
460 // throw XmlSemanticError(lineNumber, buffer);
461
462 char buffer[MESSAGE_SIZE];
463 sprintf(buffer, "%s.NAME", elementName);
464
465 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
466 "Illegal value for $0 attribute",
467 buffer);
468
469 throw XmlSemanticError(lineNumber, mlParms);
470
|
471 karl 1.78 #endif
|
472 mike 1.23 }
|
473 kumpf 1.74 return CIMName (name);
|
474 mike 1.23 }
475
476 //------------------------------------------------------------------------------
477 //
478 // getClassNameAttribute()
479 //
480 // <!ENTITY % CIMName "CLASSNAME CDATA #REQUIRED">
481 //
482 //------------------------------------------------------------------------------
483
484 String XmlReader::getClassNameAttribute(
485 Uint32 lineNumber,
486 const XmlEntry& entry,
487 const char* elementName)
488 {
489 String name;
490
491 if (!entry.getAttributeValue("CLASSNAME", name))
492 {
|
493 humberto 1.85
494
495 // l10n
496
497 // char buffer[MESSAGE_SIZE];
498 // sprintf(buffer, "missing %s.CLASSNAME attribute", elementName);
499 // throw XmlValidationError(lineNumber, buffer);
500
501 char buffer[MESSAGE_SIZE];
502 sprintf(buffer, "%s.CLASSNAME", elementName);
503
504 MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
505 "missing $0 attribute",
506 buffer);
507
508 throw XmlValidationError(lineNumber, mlParms);
509
|
510 mike 1.23 }
511
512 if (!CIMName::legal(name))
513 {
|
514 humberto 1.85 // l10n
515
516 // char buffer[MESSAGE_SIZE];
517 // sprintf(buffer,
518 // "Illegal value for %s.CLASSNAME attribute", elementName);
519 // throw XmlSemanticError(lineNumber, buffer);
520
521 char buffer[MESSAGE_SIZE];
522 sprintf(buffer, "%s.CLASSNAME", elementName);
523
524 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
525 "Illegal value for $0 attribute",
526 buffer);
527
528 throw XmlSemanticError(lineNumber, mlParms);
529
|
530 mike 1.23 }
531
532 return name;
533 }
534
535 //------------------------------------------------------------------------------
536 //
537 // getClassOriginAttribute()
538 //
539 // <!ENTITY % ClassOrigin "CLASSORIGIN CDATA #IMPLIED">
540 //
541 //------------------------------------------------------------------------------
542
|
543 kumpf 1.62 CIMName XmlReader::getClassOriginAttribute(
|
544 mike 1.23 Uint32 lineNumber,
545 const XmlEntry& entry,
546 const char* tagName)
547 {
548 String name;
549
550 if (!entry.getAttributeValue("CLASSORIGIN", name))
|
551 kumpf 1.62 return CIMName();
|
552 mike 1.23
553 if (!CIMName::legal(name))
554 {
|
555 humberto 1.85 // l10n
556
557 // char buffer[MESSAGE_SIZE];
558 // sprintf(buffer,
559 // "Illegal value for %s.CLASSORIGIN attribute", tagName);
560 // throw XmlSemanticError(lineNumber, buffer);
561
562 char buffer[MESSAGE_SIZE];
563 sprintf(buffer, "%s.CLASSORIGIN", tagName);
564
565 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
566 "Illegal value for $0 attribute",
567 buffer);
568
569 throw XmlSemanticError(lineNumber, mlParms);
|
570 mike 1.23 }
571
572 return name;
573 }
574
575 //------------------------------------------------------------------------------
576 //
577 // getReferenceClassAttribute()
578 //
579 // <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">
580 //
581 //------------------------------------------------------------------------------
582
|
583 kumpf 1.62 CIMName XmlReader::getReferenceClassAttribute(
|
584 mike 1.23 Uint32 lineNumber,
585 const XmlEntry& entry,
586 const char* elementName)
587 {
588 String name;
589
590 if (!entry.getAttributeValue("REFERENCECLASS", name))
|
591 kumpf 1.62 return CIMName();
|
592 mike 1.23
593 if (!CIMName::legal(name))
594 {
|
595 karl 1.79 #ifdef PEGASUS_SNIA_INTEROP_TEST
596 name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME";
597 return name;
598 #endif
|
599 humberto 1.85
600 // l10n
601
602 // char buffer[MESSAGE_SIZE];
603 // sprintf(buffer,
604 // "Illegal value for %s.REFERENCECLASS attribute", elementName);
605 // throw XmlSemanticError(lineNumber, buffer);
606
607 char buffer[MESSAGE_SIZE];
608 sprintf(buffer, "%s.REFERENCECLASS", elementName);
609
610 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
611 "Illegal value for $0 attribute",
612 buffer);
613
614 throw XmlSemanticError(lineNumber, mlParms);
|
615 mike 1.23 }
616
617 return name;
618 }
619
620 //------------------------------------------------------------------------------
621 //
622 // getSuperClassAttribute()
623 //
624 // <!ENTITY % SuperClass "SUPERCLASS CDATA #IMPLIED">
625 //
626 //------------------------------------------------------------------------------
627
|
628 kumpf 1.62 CIMName XmlReader::getSuperClassAttribute(
|
629 mike 1.23 Uint32 lineNumber,
630 const XmlEntry& entry,
631 const char* tagName)
632 {
633 String superClass;
634
635 if (!entry.getAttributeValue("SUPERCLASS", superClass))
|
636 kumpf 1.62 return CIMName();
|
637 mike 1.23
638 if (!CIMName::legal(superClass))
639 {
|
640 humberto 1.85
641 // l10n
642
643 // char buffer[MESSAGE_SIZE];
644 // sprintf(
645 // buffer, "Illegal value for %s.SUPERCLASS attribute", tagName);
646 // throw XmlSemanticError(lineNumber, buffer);
647
648 char buffer[MESSAGE_SIZE];
649 sprintf(buffer, "%s.SUPERCLASS", tagName);
650
651 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
652 "Illegal value for $0 attribute",
653 buffer);
654
655 throw XmlSemanticError(lineNumber, mlParms);
|
656 mike 1.23 }
657
658 return superClass;
659 }
660
661 //------------------------------------------------------------------------------
662 //
663 // getCimTypeAttribute()
664 //
|
665 kumpf 1.26 // This method can be used to get a TYPE attribute or a PARAMTYPE attribute.
666 // The only significant difference is that PARAMTYPE may specify a value of
667 // "reference" type. This method recognizes these attributes by name, and
668 // does not allow a "TYPE" attribute to be of "reference" type.
669 //
|
670 mike 1.23 // <!ENTITY % CIMType "TYPE (boolean|string|char16|uint8|sint8|uint16
671 // |sint16|uint32|sint32|uint64|sint64|datetime|real32|real64)">
672 //
|
673 kumpf 1.26 // <!ENTITY % ParamType "PARAMTYPE (boolean|string|char16|uint8|sint8
674 // |uint16|sint16|uint32|sint32|uint64|sint64|datetime|real32|real64
675 // |reference)">
676 //
|
677 mike 1.23 //------------------------------------------------------------------------------
678
|
679 kumpf 1.67 Boolean XmlReader::getCimTypeAttribute(
|
680 mike 1.23 Uint32 lineNumber,
681 const XmlEntry& entry,
|
682 kumpf 1.67 CIMType& cimType, // Output parameter
|
683 kumpf 1.26 const char* tagName,
684 const char* attributeName,
685 Boolean required)
|
686 mike 1.23 {
687 const char* typeName;
688
|
689 kumpf 1.26 if (!entry.getAttributeValue(attributeName, typeName))
|
690 mike 1.23 {
|
691 kumpf 1.26 if (required)
692 {
|
693 humberto 1.85
694 // l10n
695
696 // char message[MESSAGE_SIZE];
697 // sprintf(message, "missing %s.%s attribute", tagName, attributeName);
698 // throw XmlValidationError(lineNumber, message);
699
700 char message[MESSAGE_SIZE];
701 sprintf(message, "%s.%s", tagName, attributeName);
702
703 MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
704 "missing $0 attribute",
705 message);
706
707 throw XmlValidationError(lineNumber, mlParms);
708
|
709 kumpf 1.26 }
710 else
|
711 humberto 1.85 {
|
712 kumpf 1.67 return false;
|
713 humberto 1.85 }
|
714 mike 1.23 }
715
|
716 kumpf 1.67 CIMType type = CIMTYPE_BOOLEAN;
717 Boolean unrecognizedType = false;
|
718 mike 1.23
719 if (strcmp(typeName, "boolean") == 0)
|
720 kumpf 1.61 type = CIMTYPE_BOOLEAN;
|
721 mike 1.23 else if (strcmp(typeName, "string") == 0)
|
722 kumpf 1.61 type = CIMTYPE_STRING;
|
723 mike 1.23 else if (strcmp(typeName, "char16") == 0)
|
724 kumpf 1.61 type = CIMTYPE_CHAR16;
|
725 mike 1.23 else if (strcmp(typeName, "uint8") == 0)
|
726 kumpf 1.61 type = CIMTYPE_UINT8;
|
727 mike 1.23 else if (strcmp(typeName, "sint8") == 0)
|
728 kumpf 1.61 type = CIMTYPE_SINT8;
|
729 mike 1.23 else if (strcmp(typeName, "uint16") == 0)
|
730 kumpf 1.61 type = CIMTYPE_UINT16;
|
731 mike 1.23 else if (strcmp(typeName, "sint16") == 0)
|
732 kumpf 1.61 type = CIMTYPE_SINT16;
|
733 mike 1.23 else if (strcmp(typeName, "uint32") == 0)
|
734 kumpf 1.61 type = CIMTYPE_UINT32;
|
735 mike 1.23 else if (strcmp(typeName, "sint32") == 0)
|
736 kumpf 1.61 type = CIMTYPE_SINT32;
|
737 mike 1.23 else if (strcmp(typeName, "uint64") == 0)
|
738 kumpf 1.61 type = CIMTYPE_UINT64;
|
739 mike 1.23 else if (strcmp(typeName, "sint64") == 0)
|
740 kumpf 1.61 type = CIMTYPE_SINT64;
|
741 mike 1.23 else if (strcmp(typeName, "datetime") == 0)
|
742 kumpf 1.61 type = CIMTYPE_DATETIME;
|
743 mike 1.23 else if (strcmp(typeName, "real32") == 0)
|
744 kumpf 1.61 type = CIMTYPE_REAL32;
|
745 mike 1.23 else if (strcmp(typeName, "real64") == 0)
|
746 kumpf 1.61 type = CIMTYPE_REAL64;
|
747 kumpf 1.26 else if (strcmp(typeName, "reference") == 0)
|
748 kumpf 1.61 type = CIMTYPE_REFERENCE;
|
749 kumpf 1.67 else unrecognizedType = true;
|
750 mike 1.23
|
751 kumpf 1.67 if (unrecognizedType ||
|
752 kumpf 1.61 ((type == CIMTYPE_REFERENCE) &&
|
753 kumpf 1.26 (strcmp(attributeName, "PARAMTYPE") != 0)))
|
754 mike 1.23 {
|
755 humberto 1.85 // l10n
756
757 // char message[MESSAGE_SIZE];
758 // sprintf(message, "Illegal value for %s.%s attribute", tagName,
759 // attributeName);
760 // throw XmlSemanticError(lineNumber, message);
761
762 char buffer[MESSAGE_SIZE];
763 sprintf(buffer, "%s.%s", tagName, attributeName);
764
765 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
766 "Illegal value for $0 attribute",
767 buffer);
768
769 throw XmlSemanticError(lineNumber, mlParms);
|
770 mike 1.23 }
771
|
772 kumpf 1.67 cimType = type;
773 return true;
|
774 mike 1.23 }
775
776 //------------------------------------------------------------------------------
777 //
778 // getCimBooleanAttribute()
779 //
780 //------------------------------------------------------------------------------
781
782 Boolean XmlReader::getCimBooleanAttribute(
783 Uint32 lineNumber,
784 const XmlEntry& entry,
785 const char* tagName,
786 const char* attributeName,
787 Boolean defaultValue,
788 Boolean required)
789 {
790 const char* tmp;
791
792 if (!entry.getAttributeValue(attributeName, tmp))
793 {
794 if (!required)
795 mike 1.23 return defaultValue;
796
|
797 humberto 1.85 // l10n
798
799 // char buffer[62];
800 // sprintf(buffer, "missing required %s.%s attribute",
801 // attributeName, tagName);
802
803 // throw XmlValidationError(lineNumber, buffer);
804
|
805 mike 1.23 char buffer[62];
|
806 humberto 1.85 sprintf(buffer, "%s.%s", attributeName, tagName);
|
807 mike 1.23
|
808 humberto 1.85 MessageLoaderParms mlParms("Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",
809 "missing required $0 attribute",
810 buffer);
811
812 throw XmlValidationError(lineNumber, mlParms);
|
813 mike 1.23 }
814
815 if (strcmp(tmp, "true") == 0)
816 return true;
817 else if (strcmp(tmp, "false") == 0)
818 return false;
819
|
820 humberto 1.85 // l10n
821
822 // char buffer[62];
823 // sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName);
824 // throw XmlSemanticError(lineNumber, buffer);
825
|
826 mike 1.23 char buffer[62];
|
827 humberto 1.85 sprintf(buffer, "%s.%s", attributeName, tagName);
828
829 MessageLoaderParms mlParms("Common.XmlReader.INVALID_ATTRIBUTE",
830 "Invalid $0 attribute value",
831 buffer);
832
833 throw XmlSemanticError(lineNumber, mlParms);
834
|
835 mike 1.23 return false;
836 }
837
838 //------------------------------------------------------------------------------
839 //
840 // SringToReal()
841 //
842 // [ "+" | "-" ] *decimalDigit "." 1*decimalDigit
843 // [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]
844 //
845 //------------------------------------------------------------------------------
846
847 Boolean XmlReader::stringToReal(const char* stringValue, Real64& x)
848 {
|
849 kumpf 1.43 //
850 // Check the string against the DMTF-defined grammar
851 //
|
852 mike 1.23 const char* p = stringValue;
853
854 if (!*p)
855 return false;
856
857 // Skip optional sign:
858
859 if (*p == '+' || *p == '-')
860 p++;
861
862 // Skip optional first set of digits:
863
864 while (isdigit(*p))
865 p++;
866
867 // Test required dot:
868
869 if (*p++ != '.')
870 return false;
871
872 // One or more digits required:
873 mike 1.23
874 if (!isdigit(*p++))
875 return false;
876
877 while (isdigit(*p))
878 p++;
879
880 // If there is an exponent now:
881
882 if (*p)
883 {
884 // Test exponent:
885
886 if (*p != 'e' && *p != 'E')
887 return false;
888
889 p++;
890
891 // Skip optional sign:
892
893 if (*p == '+' || *p == '-')
894 mike 1.23 p++;
895
896 // One or more digits required:
897
898 if (!isdigit(*p++))
899 return false;
900
901 while (isdigit(*p))
902 p++;
903 }
904
905 if (*p)
906 return false;
907
|
908 kumpf 1.43 //
909 // Do the conversion
910 //
|
911 mike 1.23 char* end;
|
912 kumpf 1.43 errno = 0;
|
913 mike 1.23 x = strtod(stringValue, &end);
|
914 kumpf 1.43 if (*end || (errno == ERANGE))
915 {
916 return false;
917 }
918
|
919 mike 1.23 return true;
920 }
921
|
922 s.hills 1.93 inline Uint8 _xmlReader_hexCharToNumeric(const char c)
|
923 kumpf 1.41 {
924 Uint8 n;
925
926 if (isdigit(c))
927 n = (c - '0');
928 else if (isupper(c))
929 n = (c - 'A' + 10);
930 else // if (islower(c))
931 n = (c - 'a' + 10);
932
933 return n;
|
934 kumpf 1.82 }
935
936 // See http://www.ietf.org/rfc/rfc2396.txt section 2
|
937 chuck 1.88 //
938 // Also see the "CIM Operations over HTTP" spec, section 3.3.2 and
939 // 3.3.3, for the treatment of non US-ASCII chars (UTF-8)
|
940 kumpf 1.82 String XmlReader::decodeURICharacters(String uriString)
941 {
942 Uint32 i;
943
|
944 chuck 1.88 Array<Uint8> utf8Chars;
945
|
946 kumpf 1.82 for (i=0; i<uriString.size(); i++)
947 {
948 if (uriString[i] == '%')
949 {
950 if (i+2 >= uriString.size())
951 {
|
952 humberto 1.85 // l10n
953
954 // throw ParseError("Invalid URI encoding");
955
|
956 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING",
957 "Invalid URI encoding");
|
958 humberto 1.85
959 throw ParseError(MessageLoader::getMessage(mlParms));
960
|
961 kumpf 1.82 }
962
|
963 s.hills 1.93 Uint8 digit1 = _xmlReader_hexCharToNumeric(char(uriString[++i]));
964 Uint8 digit2 = _xmlReader_hexCharToNumeric(char(uriString[++i]));
|
965 kumpf 1.82 if ( (digit1 > 15) || (digit2 > 15) )
966 {
|
967 humberto 1.85 // l10n
968
969 // throw ParseError("Invalid URI encoding");
970
|
971 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING",
972 "Invalid URI encoding");
|
973 humberto 1.85
974 throw ParseError(MessageLoader::getMessage(mlParms));
|
975 kumpf 1.82 }
976
977 Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);
|
978 chuck 1.88 utf8Chars.append((Uint8)decodedChar);
|
979 kumpf 1.82 }
980 else
981 {
|
982 chuck 1.88 utf8Chars.append((Uint8)uriString[i]);
|
983 kumpf 1.82 }
984 }
985
|
986 chuck 1.88 // If there was a string to decode...
987 if (uriString.size() > 0)
988 {
989 // Convert UTF-8 to UTF-16 and return the String
990 utf8Chars.append('\0');
|
991 chuck 1.98 return String((char *)utf8Chars.getData());
|
992 chuck 1.88 }
993 else
994 {
995 return String();
996 }
|
997 kumpf 1.41 }
998
|
999 mike 1.23 //------------------------------------------------------------------------------
1000 //
1001 // stringToSignedInteger
1002 //
1003 // [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
|
1004 kumpf 1.41 // or
1005 // [ "+" | "-" ] ( "0x" | "0X" ) 1*hexDigit
|
1006 mike 1.23 //
1007 //------------------------------------------------------------------------------
1008
1009 Boolean XmlReader::stringToSignedInteger(
1010 const char* stringValue,
1011 Sint64& x)
1012 {
1013 x = 0;
1014 const char* p = stringValue;
1015
|
1016 kumpf 1.41 if (!p || !*p)
|
1017 mike 1.23 return false;
1018
1019 // Skip optional sign:
1020
1021 Boolean negative = *p == '-';
1022
1023 if (negative || *p == '+')
1024 p++;
1025
1026 if (*p == '0')
|
1027 kumpf 1.41 {
1028 if ( (p[1] == 'x') || (p[1] == 'X') )
1029 {
1030 // Convert a hexadecimal string
|
1031 mike 1.23
|
1032 kumpf 1.41 // Skip over the "0x"
1033 p+=2;
|
1034 mike 1.23
|
1035 kumpf 1.41 // At least one hexadecimal digit is required
1036 if (!isxdigit(*p))
1037 return false;
1038
1039 // Build the Sint64 as a negative number, regardless of the
1040 // eventual sign (negative numbers can be bigger than positive ones)
1041
1042 // Add on each digit, checking for overflow errors
1043 while (isxdigit(*p))
1044 {
1045 // Make sure we won't overflow when we multiply by 16
|
1046 kumpf 1.68 if (x < PEGASUS_SINT64_MIN/16)
|
1047 kumpf 1.41 {
1048 return false;
1049 }
1050 x = x << 4;
1051
1052 // Make sure we don't overflow when we add the next digit
|
1053 s.hills 1.93 Sint64 newDigit = Sint64(_xmlReader_hexCharToNumeric(*p++));
|
1054 kumpf 1.68 if (PEGASUS_SINT64_MIN - x > -newDigit)
|
1055 kumpf 1.41 {
1056 return false;
1057 }
1058 x = x - newDigit;
1059 }
1060
1061 // If we found a non-hexadecimal digit, report an error
1062 if (*p)
1063 return false;
1064
1065 // Return the integer to positive, if necessary, checking for an
1066 // overflow error
1067 if (!negative)
1068 {
|
1069 kumpf 1.68 if (x == PEGASUS_SINT64_MIN)
|
1070 kumpf 1.41 {
1071 return false;
1072 }
1073 x = -x;
1074 }
1075 return true;
1076 }
1077 else
1078 {
1079 // A decimal string that starts with '0' must be exactly "0".
1080 return p[1] == '\0';
1081 }
1082 }
|
1083 mike 1.23
|
1084 kumpf 1.41 // Expect a positive decimal digit:
|
1085 mike 1.23
|
1086 kumpf 1.41 // At least one decimal digit is required
1087 if (!isdigit(*p))
1088 return false;
1089
1090 // Build the Sint64 as a negative number, regardless of the
1091 // eventual sign (negative numbers can be bigger than positive ones)
|
1092 mike 1.23
|
1093 kumpf 1.41 // Add on each digit, checking for overflow errors
|
1094 mike 1.23 while (isdigit(*p))
|
1095 kumpf 1.37 {
|
1096 kumpf 1.41 // Make sure we won't overflow when we multiply by 10
|
1097 kumpf 1.68 if (x < PEGASUS_SINT64_MIN/10)
|
1098 kumpf 1.37 {
1099 return false;
1100 }
1101 x = 10 * x;
|
1102 kumpf 1.41
1103 // Make sure we won't overflow when we add the next digit
1104 Sint64 newDigit = (*p++ - '0');
|
1105 kumpf 1.68 if (PEGASUS_SINT64_MIN - x > -newDigit)
|
1106 kumpf 1.37 {
1107 return false;
1108 }
|
1109 kumpf 1.41 x = x - newDigit;
|
1110 kumpf 1.37 }
|
1111 mike 1.23
|
1112 kumpf 1.41 // If we found a non-decimal digit, report an error
1113 if (*p)
1114 return false;
1115
1116 // Return the integer to positive, if necessary, checking for an
1117 // overflow error
|
1118 kumpf 1.37 if (!negative)
1119 {
|
1120 kumpf 1.68 if (x == PEGASUS_SINT64_MIN)
|
1121 kumpf 1.37 {
1122 return false;
1123 }
|
1124 kumpf 1.41 x = -x;
|
1125 kumpf 1.37 }
|
1126 mike 1.23 return true;
1127 }
1128
1129 //------------------------------------------------------------------------------
1130 //
1131 // stringToUnsignedInteger
1132 //
|
1133 kumpf 1.40 // ( positiveDecimalDigit *decimalDigit | "0" )
|
1134 kumpf 1.41 // or
1135 // ( "0x" | "0X" ) 1*hexDigit
|
1136 mike 1.23 //
1137 //------------------------------------------------------------------------------
1138
1139 Boolean XmlReader::stringToUnsignedInteger(
1140 const char* stringValue,
1141 Uint64& x)
1142 {
1143 x = 0;
1144 const char* p = stringValue;
1145
|
1146 kumpf 1.41 if (!p || !*p)
|
1147 mike 1.23 return false;
1148
1149 if (*p == '0')
|
1150 kumpf 1.41 {
1151 if ( (p[1] == 'x') || (p[1] == 'X') )
1152 {
1153 // Convert a hexadecimal string
|
1154 mike 1.23
|
1155 kumpf 1.41 // Skip over the "0x"
1156 p+=2;
|
1157 mike 1.23
|
1158 kumpf 1.41 // At least one hexadecimal digit is required
1159 if (!*p)
1160 return false;
1161
1162 // Add on each digit, checking for overflow errors
1163 while (isxdigit(*p))
1164 {
1165 // Make sure we won't overflow when we multiply by 16
|
1166 kumpf 1.68 if (x > PEGASUS_UINT64_MAX/16)
|
1167 kumpf 1.41 {
1168 return false;
1169 }
1170 x = x << 4;
1171
1172 // We can't overflow when we add the next digit
|
1173 s.hills 1.93 Uint64 newDigit = Uint64(_xmlReader_hexCharToNumeric(*p++));
|
1174 kumpf 1.68 if (PEGASUS_UINT64_MAX - x < newDigit)
|
1175 kumpf 1.41 {
1176 return false;
1177 }
1178 x = x + newDigit;
1179 }
1180
1181 // If we found a non-hexadecimal digit, report an error
1182 if (*p)
1183 return false;
|
1184 mike 1.23
|
1185 kumpf 1.41 return true;
1186 }
1187 else
1188 {
1189 // A decimal string that starts with '0' must be exactly "0".
1190 return p[1] == '\0';
1191 }
1192 }
|
1193 mike 1.23
|
1194 kumpf 1.41 // Expect a positive decimal digit:
|
1195 mike 1.23
|
1196 kumpf 1.41 // Add on each digit, checking for overflow errors
|
1197 mike 1.23 while (isdigit(*p))
|
1198 kumpf 1.37 {
|
1199 kumpf 1.41 // Make sure we won't overflow when we multiply by 10
|
1200 kumpf 1.68 if (x > PEGASUS_UINT64_MAX/10)
|
1201 kumpf 1.37 {
1202 return false;
1203 }
1204 x = 10 * x;
|
1205 kumpf 1.41
1206 // Make sure we won't overflow when we add the next digit
1207 Uint64 newDigit = (*p++ - '0');
|
1208 kumpf 1.68 if (PEGASUS_UINT64_MAX - x < newDigit)
|
1209 kumpf 1.37 {
1210 return false;
1211 }
|
1212 kumpf 1.41 x = x + newDigit;
|
1213 kumpf 1.37 }
|
1214 kumpf 1.41
1215 // If we found a non-decimal digit, report an error
1216 if (*p)
1217 return false;
|
1218 mike 1.23
1219 return true;
1220 }
1221
1222 //------------------------------------------------------------------------------
1223 //
1224 // stringToValue()
1225 //
|
1226 karl 1.35 // Return: CIMValue. If the string input is zero length creates a CIMValue
1227 // with value defined by the type. Else the value is inserted.
1228 //
1229 // Note that this does not set the CIMValue Null if the string is empty.
1230 //
|
1231 mike 1.23 //------------------------------------------------------------------------------
1232
1233 CIMValue XmlReader::stringToValue(
1234 Uint32 lineNumber,
1235 const char* valueString,
1236 CIMType type)
1237 {
1238 // ATTN-B: accepting only UTF-8 for now! (affects string and char16):
1239
|
1240 karl 1.35 // Create value per type
|
1241 mike 1.23 switch (type)
1242 {
|
1243 kumpf 1.61 case CIMTYPE_BOOLEAN:
|
1244 mike 1.23 {
|
1245 kumpf 1.72 if (System::strcasecmp(valueString, "TRUE") == 0)
|
1246 mike 1.23 return CIMValue(true);
|
1247 kumpf 1.72 else if (System::strcasecmp(valueString, "FALSE") == 0)
|
1248 mike 1.23 return CIMValue(false);
|
1249 humberto 1.85 else {
1250
1251 // l10n
1252
1253 // throw XmlSemanticError(
1254 // lineNumber, "Invalid boolean value");
1255
|
1256 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_BOOLEAN_VALUE",
1257 "Invalid boolean value");
|
1258 humberto 1.85
1259 throw XmlSemanticError(lineNumber, mlParms);
1260
1261 }
|
1262 mike 1.23 }
1263
|
1264 kumpf 1.61 case CIMTYPE_STRING:
|
1265 mike 1.23 {
|
1266 chuck 1.98 return CIMValue(String(valueString));
|
1267 mike 1.23 }
1268
|
1269 kumpf 1.61 case CIMTYPE_CHAR16:
|
1270 mike 1.23 {
|
1271 chuck 1.88
1272 // remove this test, utf-8 can be up to 6 bytes per char
1273 /*
|
1274 humberto 1.85 if (strlen(valueString) != 1) {
|
1275 chuck 1.88 // l10n
|
1276 humberto 1.85
|
1277 chuck 1.88 // throw XmlSemanticError(lineNumber, "Invalid char16 value");
1278
1279 MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE",
1280 "Invalid char16 value");
1281
1282 throw XmlSemanticError(lineNumber, mlParms);
1283 }
1284 */
1285 // Converts UTF-8 to UTF-16
|
1286 chuck 1.98 String tmp(valueString);
|
1287 chuck 1.88 if (tmp.size() != 1)
1288 {
|
1289 humberto 1.85 // l10n
1290
1291 // throw XmlSemanticError(lineNumber, "Invalid char16 value");
1292
|
1293 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE",
1294 "Invalid char16 value");
|
1295 humberto 1.85
1296 throw XmlSemanticError(lineNumber, mlParms);
|
1297 chuck 1.88 }
|
1298 mike 1.23
|
1299 chuck 1.88 return CIMValue(tmp[0]);
|
1300 mike 1.23 }
1301
|
1302 kumpf 1.61 case CIMTYPE_UINT8:
1303 case CIMTYPE_UINT16:
1304 case CIMTYPE_UINT32:
1305 case CIMTYPE_UINT64:
|
1306 mike 1.23 {
1307 Uint64 x;
1308
1309 if (!stringToUnsignedInteger(valueString, x))
1310 {
|
1311 humberto 1.85
1312 // l10n
1313
1314 // throw XmlSemanticError(
1315 // lineNumber, "Invalid unsigned integer value");
1316
|
1317 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_UI_VALUE",
1318 "Invalid unsigned integer value");
|
1319 humberto 1.85
1320 throw XmlSemanticError(lineNumber, mlParms);
1321
|
1322 mike 1.23 }
1323
1324 switch (type)
1325 {
|
1326 kumpf 1.61 case CIMTYPE_UINT8:
|
1327 kumpf 1.37 {
1328 if (x >= (Uint64(1)<<8))
1329 {
|
1330 humberto 1.85
1331 // l10n
1332
1333 // throw XmlSemanticError(
1334 // lineNumber, "Uint8 value out of range");
1335
|
1336 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.U8_VALUE_OUT_OF_RANGE",
1337 "Uint8 value out of range");
|
1338 humberto 1.85
1339 throw XmlSemanticError(lineNumber, mlParms);
|
1340 kumpf 1.37 }
1341 return CIMValue(Uint8(x));
1342 }
|
1343 kumpf 1.61 case CIMTYPE_UINT16:
|
1344 kumpf 1.37 {
1345 if (x >= (Uint64(1)<<16))
1346 {
|
1347 humberto 1.85
1348 // l10n
1349
1350 // throw XmlSemanticError(
1351 // lineNumber, "Uint16 value out of range");
1352
|
1353 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.U16_VALUE_OUT_OF_RANGE",
1354 "Uint16 value out of range");
|
1355 humberto 1.85
1356 throw XmlSemanticError(lineNumber, mlParms);
1357
|
1358 kumpf 1.37 }
1359 return CIMValue(Uint16(x));
1360 }
|
1361 kumpf 1.61 case CIMTYPE_UINT32:
|
1362 kumpf 1.37 {
1363 if (x >= (Uint64(1)<<32))
1364 {
|
1365 humberto 1.85
1366 // l10n
1367
1368 // throw XmlSemanticError(
1369 // lineNumber, "Uint32 value out of range");
1370
|
1371 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.U32_VALUE_OUT_OF_RANGE",
1372 "Uint32 value out of range");
|
1373 humberto 1.85
1374 throw XmlSemanticError(lineNumber, mlParms);
|
1375 kumpf 1.37 }
1376 return CIMValue(Uint32(x));
1377 }
|
1378 kumpf 1.61 case CIMTYPE_UINT64: return CIMValue(Uint64(x));
|
1379 mike 1.23 default: break;
1380 }
1381 }
1382
|
1383 kumpf 1.61 case CIMTYPE_SINT8:
1384 case CIMTYPE_SINT16:
1385 case CIMTYPE_SINT32:
1386 case CIMTYPE_SINT64:
|
1387 mike 1.23 {
1388 Sint64 x;
1389
1390 if (!stringToSignedInteger(valueString, x))
1391 {
|
1392 humberto 1.85
1393 // l10n
1394
1395 // throw XmlSemanticError(
1396 // lineNumber, "Invalid signed integer value");
1397
|
1398 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_SI_VALUE",
1399 "Invalid signed integer value");
|
1400 humberto 1.85
1401 throw XmlSemanticError(lineNumber, mlParms);
1402
|
1403 mike 1.23 }
1404
1405 switch (type)
1406 {
|
1407 kumpf 1.61 case CIMTYPE_SINT8:
|
1408 kumpf 1.37 {
1409 if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )
1410 {
|
1411 humberto 1.85
1412 // l10n
1413
1414 // throw XmlSemanticError(
1415 // lineNumber, "Sint8 value out of range");
1416
|
1417 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.S8_VALUE_OUT_OF_RANGE",
1418 "Sint8 value out of range");
|
1419 humberto 1.85
1420 throw XmlSemanticError(lineNumber, mlParms);
|
1421 kumpf 1.37 }
1422 return CIMValue(Sint8(x));
1423 }
|
1424 kumpf 1.61 case CIMTYPE_SINT16:
|
1425 kumpf 1.37 {
1426 if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )
1427 {
|
1428 humberto 1.85
1429 // l10n
1430
1431 // throw XmlSemanticError(
1432 // lineNumber, "Sint16 value out of range");
1433
|
1434 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.S16_VALUE_OUT_OF_RANGE",
1435 "Sint16 value out of range");
|
1436 humberto 1.85
1437 throw XmlSemanticError(lineNumber, mlParms);
|
1438 kumpf 1.37 }
1439 return CIMValue(Sint16(x));
1440 }
|
1441 kumpf 1.61 case CIMTYPE_SINT32:
|
1442 kumpf 1.37 {
1443 if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )
1444 {
|
1445 humberto 1.85
1446 // l10n
1447
1448 // throw XmlSemanticError(
1449 // lineNumber, "Sint32 value out of range");
1450
|
1451 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.S32_VALUE_OUT_OF_RANGE",
1452 "Sint32 value out of range");
|
1453 humberto 1.85
1454 throw XmlSemanticError(lineNumber, mlParms);
|
1455 kumpf 1.37 }
1456 return CIMValue(Sint32(x));
1457 }
|
1458 kumpf 1.61 case CIMTYPE_SINT64: return CIMValue(Sint64(x));
|
1459 mike 1.23 default: break;
1460 }
1461 }
1462
|
1463 kumpf 1.61 case CIMTYPE_DATETIME:
|
1464 mike 1.23 {
1465 CIMDateTime tmp;
1466
1467 try
1468 {
|
1469 karl 1.76 // KS 20021002 - Exception if no datatime value. Test for
1470 // zero length and leave the NULL value in the variable
1471 // Bugzilla 137 Adds the following if line.
|
1472 karl 1.78 // Expect this to become permanent but test only for now
|
1473 karl 1.76 #ifdef PEGASUS_SNIA_INTEROP_TEST
1474 if (strlen(valueString) != 0)
1475 #endif
|
1476 karl 1.77 tmp.set(valueString);
|
1477 mike 1.23 }
|
1478 kumpf 1.66 catch (InvalidDateTimeFormatException&)
|
1479 mike 1.23 {
|
1480 humberto 1.85
1481 // l10n
1482
1483 // throw XmlSemanticError(lineNumber, "Invalid datetime value");
1484
|
1485 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_DATETIME_VALUE",
1486 "Invalid datetime value");
|
1487 humberto 1.85
1488 throw XmlSemanticError(lineNumber, mlParms);
|
1489 mike 1.23 }
1490
1491 return CIMValue(tmp);
1492 }
1493
|
1494 kumpf 1.61 case CIMTYPE_REAL32:
|
1495 mike 1.23 {
1496 Real64 x;
1497
|
1498 humberto 1.85 if (!stringToReal(valueString, x)) {
1499
1500 // l10n
1501
1502 // throw XmlSemanticError(lineNumber, "Invalid real number value");
|
1503 mike 1.23
|
1504 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE",
1505 "Invalid real number value");
|
1506 humberto 1.85
1507 throw XmlSemanticError(lineNumber, mlParms);
1508 }
|
1509 mike 1.23 return CIMValue(Real32(x));
1510 }
1511
|
1512 kumpf 1.61 case CIMTYPE_REAL64:
|
1513 mike 1.23 {
1514 Real64 x;
1515
|
1516 humberto 1.85 if (!stringToReal(valueString, x)) {
1517
1518 // l10n
1519
1520 // throw XmlSemanticError(lineNumber, "Invalid real number value");
|
1521 mike 1.23
|
1522 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE",
1523 "Invalid real number value");
|
1524 humberto 1.85
1525 throw XmlSemanticError(lineNumber, mlParms);
1526 }
|
1527 mike 1.23 return CIMValue(x);
1528 }
1529
1530 default:
1531 break;
1532 }
1533
|
1534 humberto 1.85 // l10n
1535
1536 // throw XmlSemanticError(lineNumber, "malformed XML");
1537
1538 MessageLoaderParms mlParms("Common.XmlReader.MALFORMED_XML",
1539 "malformed XML");
1540
1541 throw XmlSemanticError(lineNumber, mlParms);
1542
|
1543 mike 1.23 return false;
1544 }
1545
1546 //------------------------------------------------------------------------------
1547 //
|
1548 kumpf 1.95 // skipElement()
1549 //
1550 //------------------------------------------------------------------------------
1551 void XmlReader::skipElement(
1552 XmlParser& parser,
1553 XmlEntry& entry)
1554 {
1555 const char * tag_name = entry.text;
1556
1557 if (entry.type == XmlEntry::EMPTY_TAG)
1558 {
1559 return;
1560 }
1561
1562 while (testStartTagOrEmptyTag(parser, entry))
1563 {
1564 skipElement(parser, entry);
1565 }
1566
1567 if (testContentOrCData(parser, entry))
1568 {
1569 kumpf 1.95 ; // skip
1570 }
1571
1572 expectEndTag(parser, tag_name);
1573 return;
1574 }
1575
1576 //------------------------------------------------------------------------------
1577 //
|
1578 mike 1.23 // getValueElement()
1579 //
1580 // <!ELEMENT VALUE (#PCDATA)>
1581 //
|
1582 karl 1.35 // Return: false if no value element.
1583 //
|
1584 mike 1.23 //------------------------------------------------------------------------------
1585
1586 Boolean XmlReader::getValueElement(
1587 XmlParser& parser,
1588 CIMType type,
1589 CIMValue& value)
1590 {
|
1591 karl 1.35 // Get VALUE start tag: Return false if no VALUE start Tag
|
1592 mike 1.23
1593 XmlEntry entry;
1594 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
1595 return false;
1596
1597 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1598
1599 const char* valueString = "";
1600
1601 if (!empty)
1602 {
1603 if (testContentOrCData(parser, entry))
1604 valueString = entry.text;
1605
1606 expectEndTag(parser, "VALUE");
1607 }
|
1608 karl 1.80 #ifdef PEGASUS_SNIA_INTEROP_TEST
1609 // KS 20021004 - tries to put value in even if empty.
1610 // Think this is general problem with empty value
1611 // Need to check meaning of (#PCDATA) - Does it allow empty.
1612 // Bugzilla tbd
1613 if (!empty)
1614 #endif
1615 value = stringToValue(parser.getLine(), valueString,type);
|
1616 karl 1.33
|
1617 mike 1.23 return true;
1618 }
1619
1620 //------------------------------------------------------------------------------
1621 //
1622 // getStringValueElement()
1623 //
1624 // <!ELEMENT VALUE (#PCDATA)>
1625 //
1626 //------------------------------------------------------------------------------
1627
1628 Boolean XmlReader::getStringValueElement(
1629 XmlParser& parser,
1630 String& str,
1631 Boolean required)
1632 {
1633 XmlEntry entry;
1634
1635 if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
1636 {
|
1637 humberto 1.85 if (required) {
1638
1639 // l10n
1640
1641 // throw XmlValidationError(parser.getLine(),"Expected VALUE element");
1642
|
1643 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
1644 "Expected VALUE element");
|
1645 humberto 1.85
1646 throw XmlValidationError(parser.getLine(), mlParms);
1647
1648
1649 }
1650 return false;
|
1651 mike 1.23 }
1652
1653 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
1654
1655 const char* valueString = "";
1656
1657 if (!empty)
1658 {
1659 if (testContentOrCData(parser, entry))
1660 valueString = entry.text;
1661
1662 expectEndTag(parser, "VALUE");
1663 }
1664
|
1665 chuck 1.98 str = String(valueString);
|
1666 mike 1.23 return true;
1667 }
1668
1669 //----------------------------------------------------------------------------
1670 //
1671 // getPropertyValue
|
1672 kumpf 1.30 // Use: Decode property value from SetProperty request and
1673 // GetProperty response.
|
1674 mike 1.23 //
|
1675 kumpf 1.30 // PropertyValue is one of:
|
1676 mike 1.23 //
1677 //
|
1678 karl 1.33 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1679 //
1680 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
|
1681 kumpf 1.30 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1682 //
1683 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
|
1684 mike 1.23 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
1685 //
|
1686 kumpf 1.30 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
1687 //
|
1688 mike 1.23 //----------------------------------------------------------------------------
1689 Boolean XmlReader::getPropertyValue(
1690 XmlParser& parser,
1691 CIMValue& cimValue)
1692 {
|
1693 kumpf 1.30 // Can not test for value type, so assume String
|
1694 kumpf 1.61 const CIMType type = CIMTYPE_STRING;
|
1695 mike 1.23
|
1696 kumpf 1.30 // Test for VALUE element
|
1697 mike 1.23 if (XmlReader::getValueElement(parser, type, cimValue))
1698 {
1699 return true;
1700 }
1701
|
1702 kumpf 1.30 // Test for VALUE.ARRAY element
1703 if (XmlReader::getValueArrayElement(parser, type, cimValue))
1704 {
|
1705 mike 1.23 return true;
|
1706 kumpf 1.30 }
|
1707 mike 1.23
|
1708 kumpf 1.30 // Test for VALUE.REFERENCE element
|
1709 kumpf 1.54 CIMObjectPath reference;
|
1710 kumpf 1.30 if (XmlReader::getValueReferenceElement(parser, reference))
|
1711 mike 1.25 {
1712 cimValue.set(reference);
1713 return true;
1714 }
|
1715 mike 1.23
|
1716 kumpf 1.30 // Test for VALUE.REFARRAY element
1717 if (XmlReader::getValueReferenceArrayElement(parser, cimValue))
1718 {
1719 return true;
1720 }
1721
1722 return false;
|
1723 mike 1.23 }
1724
1725 //------------------------------------------------------------------------------
1726 //
1727 // stringArrayToValue()
1728 //
1729 //------------------------------------------------------------------------------
1730
1731 template<class T>
1732 CIMValue StringArrayToValueAux(
1733 Uint32 lineNumber,
1734 const Array<const char*>& stringArray,
1735 CIMType type,
1736 T*)
1737 {
1738 Array<T> array;
1739
1740 for (Uint32 i = 0, n = stringArray.size(); i < n; i++)
1741 {
1742 CIMValue value = XmlReader::stringToValue(
1743 lineNumber, stringArray[i], type);
1744 mike 1.23
1745 T x;
1746 value.get(x);
1747 array.append(x);
1748 }
1749
1750 return CIMValue(array);
1751 }
1752
1753 CIMValue XmlReader::stringArrayToValue(
1754 Uint32 lineNumber,
1755 const Array<const char*>& array,
1756 CIMType type)
1757 {
1758 switch (type)
1759 {
|
1760 kumpf 1.61 case CIMTYPE_BOOLEAN:
|
1761 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);
1762
|
1763 kumpf 1.61 case CIMTYPE_STRING:
|
1764 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (String*)0);
1765
|
1766 kumpf 1.61 case CIMTYPE_CHAR16:
|
1767 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);
1768
|
1769 kumpf 1.61 case CIMTYPE_UINT8:
|
1770 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);
1771
|
1772 kumpf 1.61 case CIMTYPE_UINT16:
|
1773 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);
1774
|
1775 kumpf 1.61 case CIMTYPE_UINT32:
|
1776 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);
1777
|
1778 kumpf 1.61 case CIMTYPE_UINT64:
|
1779 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);
1780
|
1781 kumpf 1.61 case CIMTYPE_SINT8:
|
1782 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);
1783
|
1784 kumpf 1.61 case CIMTYPE_SINT16:
|
1785 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);
1786
|
1787 kumpf 1.61 case CIMTYPE_SINT32:
|
1788 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);
1789
|
1790 kumpf 1.61 case CIMTYPE_SINT64:
|
1791 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);
1792
|
1793 kumpf 1.61 case CIMTYPE_DATETIME:
|
1794 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (CIMDateTime*)0);
1795
|
1796 kumpf 1.61 case CIMTYPE_REAL32:
|
1797 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);
1798
|
1799 kumpf 1.61 case CIMTYPE_REAL64:
|
1800 mike 1.23 return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);
1801
1802 default:
1803 break;
1804 }
1805
1806 // Unreachable:
1807 return CIMValue();
1808 }
1809
1810 //------------------------------------------------------------------------------
1811 //
1812 // getValueArrayElement()
1813 //
1814 // <!ELEMENT VALUE.ARRAY (VALUE*)>
1815 //
|
1816 karl 1.35 // Return: Boolean. Returns false if there is no VALUE.ARRAY start element
1817 //
|
1818 mike 1.23 //------------------------------------------------------------------------------
1819
1820 Boolean XmlReader::getValueArrayElement(
1821 XmlParser& parser,
1822 CIMType type,
1823 CIMValue& value)
1824 {
|
1825 karl 1.35 // Clears any values from the Array. Assumes this is array CIMValue
|
1826 mike 1.23 value.clear();
1827
1828 // Get VALUE.ARRAY open tag:
1829
1830 XmlEntry entry;
|
1831 kumpf 1.32 Array<const char*> stringArray;
|
1832 mike 1.23
|
1833 karl 1.35 // If no VALUE.ARRAY start tag, return false
|
1834 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))
1835 return false;
|
1836 karl 1.33
|
1837 kumpf 1.32 if (entry.type != XmlEntry::EMPTY_TAG)
1838 {
1839 // For each VALUE element:
|
1840 mike 1.23
|
1841 kumpf 1.32 while (testStartTagOrEmptyTag(parser, entry, "VALUE"))
1842 {
1843 if (entry.type == XmlEntry::EMPTY_TAG)
1844 {
1845 stringArray.append("");
1846 continue;
1847 }
|
1848 mike 1.23
|
1849 kumpf 1.32 if (testContentOrCData(parser, entry))
1850 stringArray.append(entry.text);
1851 else
1852 stringArray.append("");
|
1853 mike 1.23
|
1854 kumpf 1.32 expectEndTag(parser, "VALUE");
1855 }
|
1856 mike 1.23
|
1857 kumpf 1.32 expectEndTag(parser, "VALUE.ARRAY");
|
1858 mike 1.23 }
1859
1860 value = stringArrayToValue(parser.getLine(), stringArray, type);
1861 return true;
1862 }
1863
1864 //------------------------------------------------------------------------------
1865 //
1866 // getFlavor()
1867 //
1868 // <!ENTITY % QualifierFlavor
1869 // "OVERRIDABLE (true|false) 'true'
1870 // TOSUBCLASS (true|false) 'true'
1871 // TOINSTANCE (true|false) 'false'
1872 // TRANSLATABLE (true|false) 'false'">
1873 //
1874 //------------------------------------------------------------------------------
1875
|
1876 kumpf 1.64 CIMFlavor XmlReader::getFlavor(
|
1877 mike 1.23 XmlEntry& entry,
1878 Uint32 lineNumber,
1879 const char* tagName)
1880 {
1881 // Get QUALIFIER.OVERRIDABLE
1882
1883 Boolean overridable = getCimBooleanAttribute(
1884 lineNumber, entry, tagName, "OVERRIDABLE", true, false);
1885
1886 // Get QUALIFIER.TOSUBCLASS
1887
1888 Boolean toSubClass = getCimBooleanAttribute(
1889 lineNumber, entry, tagName, "TOSUBCLASS", true, false);
1890
1891 // Get QUALIFIER.TOINSTANCE
1892
1893 Boolean toInstance = getCimBooleanAttribute(
1894 lineNumber, entry, tagName, "TOINSTANCE", false, false);
1895
1896 // Get QUALIFIER.TRANSLATABLE
1897
1898 mike 1.23 Boolean translatable = getCimBooleanAttribute(
1899 lineNumber, entry, tagName, "TRANSLATABLE", false, false);
1900
|
1901 kumpf 1.44 // Start with CIMFlavor::NONE. Defaults are specified in the
1902 // getCimBooleanAttribute() calls above.
|
1903 kumpf 1.64 CIMFlavor flavor = CIMFlavor (CIMFlavor::NONE);
|
1904 mike 1.23
1905 if (overridable)
|
1906 kumpf 1.64 flavor.addFlavor (CIMFlavor::OVERRIDABLE);
1907 else
1908 flavor.addFlavor (CIMFlavor::DISABLEOVERRIDE);
|
1909 mike 1.23
1910 if (toSubClass)
|
1911 kumpf 1.64 flavor.addFlavor (CIMFlavor::TOSUBCLASS);
1912 else
1913 flavor.addFlavor (CIMFlavor::RESTRICTED);
|
1914 mike 1.23
1915 if (toInstance)
|
1916 kumpf 1.64 flavor.addFlavor (CIMFlavor::TOINSTANCE);
|
1917 mike 1.23
1918 if (translatable)
|
1919 kumpf 1.64 flavor.addFlavor (CIMFlavor::TRANSLATABLE);
|
1920 mike 1.23
1921 return flavor;
1922 }
1923
1924 //------------------------------------------------------------------------------
1925 //
1926 // getOptionalScope()
1927 //
1928 // DTD:
1929 // <!ELEMENT SCOPE EMPTY>
1930 // <!ATTLIST SCOPE
1931 // CLASS (true|false) 'false'
1932 // ASSOCIATION (true|false) 'false'
1933 // REFERENCE (true|false) 'false'
1934 // PROPERTY (true|false) 'false'
1935 // METHOD (true|false) 'false'
1936 // PARAMETER (true|false) 'false'
1937 // INDICATION (true|false) 'false'>
1938 //
1939 //------------------------------------------------------------------------------
1940
|
1941 kumpf 1.63 CIMScope XmlReader::getOptionalScope(XmlParser& parser)
|
1942 mike 1.23 {
1943 XmlEntry entry;
|
1944 kumpf 1.65 CIMScope scope;
|
1945 mike 1.23
1946 if (!parser.next(entry))
|
1947 kumpf 1.65 return scope; // No SCOPE element found; return the empty scope
|
1948 mike 1.23
1949 Boolean isEmptyTag = entry.type == XmlEntry::EMPTY_TAG;
1950
1951 if ((!isEmptyTag &&
1952 entry.type != XmlEntry::START_TAG) ||
1953 strcmp(entry.text, "SCOPE") != 0)
1954 {
|
1955 kumpf 1.65 // No SCOPE element found; return the empty scope
|
1956 mike 1.23 parser.putBack(entry);
|
1957 kumpf 1.65 return scope;
|
1958 mike 1.23 }
1959
1960 Uint32 line = parser.getLine();
1961
1962 if (getCimBooleanAttribute(line, entry, "SCOPE", "CLASS", false, false))
|
1963 kumpf 1.63 scope.addScope (CIMScope::CLASS);
|
1964 mike 1.23
1965 if (getCimBooleanAttribute(
1966 line, entry, "SCOPE", "ASSOCIATION", false, false))
|
1967 kumpf 1.63 scope.addScope (CIMScope::ASSOCIATION);
|
1968 mike 1.23
1969 if (getCimBooleanAttribute(
1970 line, entry, "SCOPE", "REFERENCE", false, false))
|
1971 kumpf 1.63 scope.addScope (CIMScope::REFERENCE);
|
1972 mike 1.23
1973 if (getCimBooleanAttribute(line, entry, "SCOPE", "PROPERTY", false, false))
|
1974 kumpf 1.63 scope.addScope (CIMScope::PROPERTY);
|
1975 mike 1.23
1976 if (getCimBooleanAttribute(line, entry, "SCOPE", "METHOD", false, false))
|
1977 kumpf 1.63 scope.addScope (CIMScope::METHOD);
|
1978 mike 1.23
1979 if (getCimBooleanAttribute(line, entry, "SCOPE", "PARAMETER", false, false))
|
1980 kumpf 1.63 scope.addScope (CIMScope::PARAMETER);
|
1981 mike 1.23
1982 if (getCimBooleanAttribute(line, entry, "SCOPE", "INDICATION",false, false))
|
1983 kumpf 1.63 scope.addScope (CIMScope::INDICATION);
|
1984 mike 1.23
1985 if (!isEmptyTag)
1986 expectEndTag(parser, "SCOPE");
1987
1988 return scope;
1989 }
1990
1991 //------------------------------------------------------------------------------
1992 //
1993 // getQualifierElement()
1994 //
|
1995 kumpf 1.52 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)?>
|
1996 mike 1.23 // <!ATTLIST QUALIFIER
1997 // %CIMName;
1998 // %CIMType; #REQUIRED
1999 // %Propagated;
2000 // %QualifierFlavor;>
2001 //
2002 //------------------------------------------------------------------------------
2003
2004 Boolean XmlReader::getQualifierElement(
2005 XmlParser& parser,
2006 CIMQualifier& qualifier)
2007 {
2008 // Get QUALIFIER element:
2009
2010 XmlEntry entry;
|
2011 kumpf 1.103 if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER"))
|
2012 mike 1.23 return false;
2013
|
2014 kumpf 1.103 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2015
|
2016 mike 1.23 // Get QUALIFIER.NAME attribute:
2017
|
2018 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
|
2019 mike 1.23
2020 // Get QUALIFIER.TYPE attribute:
2021
|
2022 kumpf 1.67 CIMType type;
2023 getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER");
|
2024 mike 1.23
2025 // Get QUALIFIER.PROPAGATED
2026
2027 Boolean propagated = getCimBooleanAttribute(
2028 parser.getLine(), entry, "QUALIFIER", "PROPAGATED", false, false);
2029
2030 // Get flavor oriented attributes:
2031
|
2032 kumpf 1.64 CIMFlavor flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");
|
2033 mike 1.23
2034 // Get VALUE or VALUE.ARRAY element:
2035
2036 CIMValue value;
2037
|
2038 kumpf 1.103 if (empty)
|
2039 mike 1.23 {
|
2040 kumpf 1.52 value.setNullValue(type, false);
|
2041 mike 1.23 }
|
2042 kumpf 1.103 else
2043 {
2044 if (!getValueElement(parser, type, value) &&
2045 !getValueArrayElement(parser, type, value))
2046 {
2047 value.setNullValue(type, false);
2048 }
|
2049 mike 1.23
|
2050 kumpf 1.103 // Expect </QUALIFIER>:
|
2051 mike 1.23
|
2052 kumpf 1.103 expectEndTag(parser, "QUALIFIER");
2053 }
|
2054 mike 1.23
2055 // Build qualifier:
2056
2057 qualifier = CIMQualifier(name, value, flavor, propagated);
2058 return true;
2059 }
2060
2061 //------------------------------------------------------------------------------
2062 //
2063 // getQualifierElements()
2064 //
2065 //------------------------------------------------------------------------------
2066
2067 template<class CONTAINER>
2068 void getQualifierElements(XmlParser& parser, CONTAINER& container)
2069 {
2070 CIMQualifier qualifier;
2071
2072 while (XmlReader::getQualifierElement(parser, qualifier))
2073 {
2074 try
2075 mike 1.23 {
2076 container.addQualifier(qualifier);
2077 }
|
2078 kumpf 1.66 catch (AlreadyExistsException&)
|
2079 mike 1.23 {
|
2080 humberto 1.85
2081 // l10n
2082
2083 // throw XmlSemanticError(parser.getLine(), "duplicate qualifier");
2084
|
2085 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_QUALIFIER",
2086 "duplicate qualifier");
|
2087 humberto 1.85
2088 throw XmlSemanticError(parser.getLine(), mlParms);
|
2089 mike 1.23 }
2090 }
2091 }
2092
2093 //------------------------------------------------------------------------------
2094 //
2095 // getPropertyElement()
2096 //
2097 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
2098 // <!ATTLIST PROPERTY
2099 // %CIMName;
2100 // %ClassOrigin;
2101 // %Propagated;
2102 // %CIMType; #REQUIRED>
2103 //
2104 //------------------------------------------------------------------------------
2105
2106 Boolean XmlReader::getPropertyElement(XmlParser& parser, CIMProperty& property)
2107 {
2108 XmlEntry entry;
2109
2110 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY"))
2111 return false;
2112
2113 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2114
2115 // Get PROPERTY.NAME attribute:
2116
|
2117 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
|
2118 mike 1.23
2119 // Get PROPERTY.CLASSORIGIN attribute:
2120
|
2121 kumpf 1.62 CIMName classOrigin =
|
2122 mike 1.23 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
2123
2124 // Get PROPERTY.PROPAGATED
2125
2126 Boolean propagated = getCimBooleanAttribute(
2127 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
2128
2129 // Get PROPERTY.TYPE attribute:
2130
|
2131 kumpf 1.67 CIMType type;
2132 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");
|
2133 mike 1.23
|
2134 karl 1.35 // Create property: Sets type and !isarray
|
2135 mike 1.23
|
2136 kumpf 1.56 CIMValue value(type, false);
|
2137 kumpf 1.62 property = CIMProperty(name, value, 0, CIMName(), classOrigin, propagated);
|
2138 mike 1.23
2139 if (!empty)
2140 {
2141 // Get qualifiers:
2142
2143 getQualifierElements(parser, property);
2144
|
2145 karl 1.35 // Get value: Insert value if getValueElement exists (returns True)
|
2146 mike 1.23
2147 if (getValueElement(parser, type, value))
2148 property.setValue(value);
2149
2150 expectEndTag(parser, "PROPERTY");
2151 }
2152
2153 return true;
2154 }
2155
2156 //------------------------------------------------------------------------------
2157 //
2158 // getArraySizeAttribute()
2159 //
2160 // Returns true if able to get array-size. Note that array size will
2161 // always be a positive integer.
2162 //
2163 // <!ENTITY % ArraySize "ARRAYSIZE CDATA #IMPLIED">
2164 //
2165 //------------------------------------------------------------------------------
2166
2167 mike 1.23 Boolean XmlReader::getArraySizeAttribute(
2168 Uint32 lineNumber,
2169 const XmlEntry& entry,
2170 const char* tagName,
2171 Uint32& value)
2172 {
2173 const char* tmp;
2174
2175 if (!entry.getAttributeValue("ARRAYSIZE", tmp))
2176 return false;
2177
2178 Uint64 arraySize;
2179
2180 if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)
2181 {
|
2182 humberto 1.85 // l10n
2183
2184 // char message[128];
2185 // sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");
2186 // throw XmlSemanticError(lineNumber, message);
2187
2188 char message[128];
2189 sprintf(message, "%s.%s", tagName, "ARRAYSIZE");
2190
2191 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE",
2192 "Illegal value for $0",
2193 message);
2194
2195 throw XmlSemanticError(lineNumber, mlParms);
|
2196 mike 1.23 }
2197
2198 value = Uint32(arraySize);
2199 return true;
2200 }
2201
2202 //------------------------------------------------------------------------------
2203 //
2204 // getPropertyArrayElement()
2205 //
2206 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
2207 // <!ATTLIST PROPERTY.ARRAY
2208 // %CIMName;
2209 // %CIMType; #REQUIRED
2210 // %ArraySize;
2211 // %ClassOrigin;
2212 // %Propagated;>
2213 //
2214 //------------------------------------------------------------------------------
2215
2216 Boolean XmlReader::getPropertyArrayElement(
2217 mike 1.23 XmlParser& parser,
2218 CIMProperty& property)
2219 {
2220 // Get PROPERTY element:
2221
2222 XmlEntry entry;
2223
2224 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.ARRAY"))
2225 return false;
2226
2227 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2228
2229 // Get PROPERTY.NAME attribute:
2230
|
2231 kumpf 1.74 CIMName name =
|
2232 mike 1.23 getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
2233
2234 // Get PROPERTY.TYPE attribute:
2235
|
2236 kumpf 1.67 CIMType type;
2237 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY.ARRAY");
|
2238 mike 1.23
2239 // Get PROPERTY.ARRAYSIZE attribute:
2240
2241 Uint32 arraySize = 0;
2242 getArraySizeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY", arraySize);
2243
2244 // Get PROPERTY.CLASSORIGIN attribute:
2245
|
2246 kumpf 1.62 CIMName classOrigin
|
2247 mike 1.23 = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
2248
2249 // Get PROPERTY.ARRAY.PROPAGATED
2250
2251 Boolean propagated = getCimBooleanAttribute(
2252 parser.getLine(), entry, "PROPERTY.ARRAY", "PROPAGATED", false, false);
2253
2254 // Create property:
2255
|
2256 kumpf 1.56 CIMValue value(type, true, arraySize);
|
2257 mike 1.23 property = CIMProperty(
|
2258 kumpf 1.62 name, value, arraySize, CIMName(), classOrigin, propagated);
|
2259 mike 1.23
2260 if (!empty)
2261 {
2262 // Get qualifiers:
2263
2264 getQualifierElements(parser, property);
2265
2266 // Get value:
2267
2268 if (getValueArrayElement(parser, type, value))
2269 {
2270 if (arraySize && arraySize != value.getArraySize())
2271 {
|
2272 humberto 1.85
2273 // l10n
2274
2275 // throw XmlSemanticError(parser.getLine(),
2276 // "ARRAYSIZE attribute and value-array size are different");
2277
2278 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT",
|
2279 humberto 1.87 "ARRAYSIZE attribute and value-array size are different");
|
2280 humberto 1.85
2281 throw XmlSemanticError(parser.getLine(), mlParms);
|
2282 mike 1.23 }
2283
2284 property.setValue(value);
2285 }
2286
2287 expectEndTag(parser, "PROPERTY.ARRAY");
2288 }
2289
2290 return true;
2291 }
2292
2293 //------------------------------------------------------------------------------
2294 //
2295 // getHostElement()
2296 //
2297 // <!ELEMENT HOST (#PCDATA)>
2298 //
2299 //------------------------------------------------------------------------------
2300
2301 Boolean XmlReader::getHostElement(
2302 XmlParser& parser,
2303 mike 1.23 String& host)
2304 {
2305 XmlEntry entry;
2306
2307 if (!testStartTag(parser, entry, "HOST"))
2308 return false;
|
2309 karl 1.78 #ifdef PEGASUS_SNIA_INTEROP_TEST
2310 // Temp code to allow empty HOST field.
2311 // SNIA CIMOMs return empty field particularly on enumerateinstance.
2312 // Simply substitute a string for the empty.
2313 if (!parser.next(entry))
2314 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
2315
2316 if (entry.type == XmlEntry::CONTENT)
|
2317 chuck 1.98 host = String(entry.text);
|
2318 karl 1.78 else
2319 {
2320 parser.putBack(entry);
2321 host = "HOSTNAMEINSERTEDBYPEGASUSCLIENT";
2322 }
2323
2324 #else
|
2325 mike 1.23
2326 if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)
2327 {
|
2328 humberto 1.85
2329 // l10n
2330
2331 // throw XmlValidationError(parser.getLine(),
2332 // "expected content of HOST element");
2333
2334 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT",
|
2335 humberto 1.87 "expected content of HOST element");
|
2336 humberto 1.85
2337 throw XmlValidationError(parser.getLine(), mlParms);
2338
|
2339 mike 1.23 }
2340
|
2341 chuck 1.98 host = String(entry.text);
|
2342 karl 1.78 #endif
|
2343 mike 1.23 expectEndTag(parser, "HOST");
2344 return true;
2345 }
2346
2347 //------------------------------------------------------------------------------
2348 //
2349 // getNameSpaceElement()
2350 //
2351 // <!ELEMENT NAMESPACE EMPTY>
2352 // <!ATTLIST NAMESPACE %CIMName;>
2353 //
2354 //------------------------------------------------------------------------------
2355
2356 Boolean XmlReader::getNameSpaceElement(
2357 XmlParser& parser,
|
2358 kumpf 1.74 CIMName& nameSpaceComponent)
|
2359 mike 1.23 {
2360 XmlEntry entry;
2361
2362 if (!testStartTagOrEmptyTag(parser, entry, "NAMESPACE"))
2363 return false;
2364
2365 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2366
2367 nameSpaceComponent = getCimNameAttribute(
2368 parser.getLine(), entry, "NAMESPACE");
2369
2370 if (!empty)
2371 expectEndTag(parser, "NAMESPACE");
2372
2373 return true;
2374 }
2375
2376 //------------------------------------------------------------------------------
2377 //
2378 // getLocalNameSpacePathElement()
2379 //
2380 mike 1.23 // <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
2381 //
2382 //------------------------------------------------------------------------------
2383
2384 Boolean XmlReader::getLocalNameSpacePathElement(
2385 XmlParser& parser,
2386 String& nameSpace)
2387 {
2388 XmlEntry entry;
2389
2390 if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))
2391 return false;
2392
|
2393 kumpf 1.74 CIMName nameSpaceComponent;
|
2394 mike 1.23
2395 while (getNameSpaceElement(parser, nameSpaceComponent))
2396 {
2397 if (nameSpace.size())
|
2398 kumpf 1.71 nameSpace.append('/');
|
2399 mike 1.23
|
2400 kumpf 1.74 nameSpace.append(nameSpaceComponent.getString());
|
2401 mike 1.23 }
2402
2403 if (!nameSpace.size())
2404 {
|
2405 humberto 1.85
2406 // l10n
2407
2408 // throw XmlValidationError(parser.getLine(),
2409 // "Expected one or more NAMESPACE elements within "
2410 // "LOCALNAMESPACEPATH element");
2411
2412 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",
|
2413 humberto 1.87 "Expected one or more NAMESPACE elements within LOCALNAMESPACEPATH element");
|
2414 humberto 1.85
2415 throw XmlValidationError(parser.getLine(), mlParms);
2416
2417
|
2418 mike 1.23 }
2419
2420 expectEndTag(parser, "LOCALNAMESPACEPATH");
2421 return true;
2422 }
2423
2424 //------------------------------------------------------------------------------
2425 //
2426 // getNameSpacePathElement()
2427 //
2428 // <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
2429 //
2430 //------------------------------------------------------------------------------
2431
2432 Boolean XmlReader::getNameSpacePathElement(
2433 XmlParser& parser,
2434 String& host,
2435 String& nameSpace)
2436 {
2437 host.clear();
2438 nameSpace.clear();
2439 mike 1.23
2440 XmlEntry entry;
2441
2442 if (!testStartTag(parser, entry, "NAMESPACEPATH"))
2443 return false;
2444
|
2445 humberto 1.85 if (!getHostElement(parser, host)) {
2446
2447 // l10n
2448
2449 // throw XmlValidationError(parser.getLine(), "expected HOST element");
2450
|
2451 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_HOST_ELEMENT",
2452 "expected HOST element");
|
2453 humberto 1.85
2454 throw XmlValidationError(parser.getLine(), mlParms);
2455 }
|
2456 mike 1.23
2457 if (!getLocalNameSpacePathElement(parser, nameSpace))
2458 {
|
2459 humberto 1.85
2460 // l10n
2461
2462 // throw XmlValidationError(parser.getLine(),
2463 // "expected LOCALNAMESPACEPATH element");
2464
|
2465 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2466 "expected LOCALNAMESPACEPATH element");
|
2467 humberto 1.85
2468 throw XmlValidationError(parser.getLine(), mlParms);
|
2469 mike 1.23 }
2470
2471 expectEndTag(parser, "NAMESPACEPATH");
2472
2473 return true;
2474 }
2475
2476 //------------------------------------------------------------------------------
2477 //
2478 // getClassNameElement()
2479 //
2480 // <!ELEMENT CLASSNAME EMPTY>
2481 // <!ATTLIST CLASSNAME %CIMName;>
2482 //
2483 //------------------------------------------------------------------------------
2484
2485 Boolean XmlReader::getClassNameElement(
2486 XmlParser& parser,
|
2487 kumpf 1.74 CIMName& className,
|
2488 mike 1.23 Boolean required)
2489 {
2490 XmlEntry entry;
2491
2492 if (!testStartTagOrEmptyTag(parser, entry, "CLASSNAME"))
2493 {
2494 if (required)
2495 {
|
2496 humberto 1.85
2497 // l10n
2498
2499 // throw XmlValidationError(parser.getLine(),
2500 // "expected CLASSNAME element");
2501
|
2502 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2503 "expected CLASSNAME element");
|
2504 humberto 1.85
2505 throw XmlValidationError(parser.getLine(), mlParms);
|
2506 mike 1.23 }
2507 else
2508 return false;
2509 }
2510 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2511
2512 className = getCimNameAttribute(
|
2513 kumpf 1.81 parser.getLine(), entry, "CLASSNAME", false);
|
2514 mike 1.23
2515 if (!empty)
2516 expectEndTag(parser, "CLASSNAME");
2517
2518 return true;
2519 }
2520
2521 //------------------------------------------------------------------------------
2522 //
2523 // getValueTypeAttribute()
2524 //
2525 // VALUETYPE (string|boolean|numeric) 'string'
2526 //
2527 //------------------------------------------------------------------------------
2528
|
2529 kumpf 1.73 CIMKeyBinding::Type XmlReader::getValueTypeAttribute(
|
2530 mike 1.23 Uint32 lineNumber,
2531 const XmlEntry& entry,
2532 const char* elementName)
2533 {
2534 String tmp;
2535
2536 if (!entry.getAttributeValue("VALUETYPE", tmp))
|
2537 kumpf 1.73 return CIMKeyBinding::STRING;
|
2538 mike 1.23
2539 if (String::equal(tmp, "string"))
|
2540 kumpf 1.73 return CIMKeyBinding::STRING;
|
2541 mike 1.23 else if (String::equal(tmp, "boolean"))
|
2542 kumpf 1.73 return CIMKeyBinding::BOOLEAN;
|
2543 mike 1.23 else if (String::equal(tmp, "numeric"))
|
2544 kumpf 1.73 return CIMKeyBinding::NUMERIC;
|
2545 mike 1.23
|
2546 humberto 1.85 // char buffer[MESSAGE_SIZE];
2547
2548 // sprintf(buffer,
2549 // "Illegal value for %s.VALUETYPE attribute; "
2550 // "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",
2551 // elementName);
2552
2553 // throw XmlSemanticError(lineNumber, buffer);
2554
2555
|
2556 mike 1.23 char buffer[MESSAGE_SIZE];
|
2557 humberto 1.85 sprintf(buffer, "%s.VALUETYPE", elementName);
2558
2559 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",
|
2560 humberto 1.87 "Illegal value for $0 attribute; CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", buffer);
|
2561 humberto 1.85
2562 throw XmlSemanticError(lineNumber, mlParms);
|
2563 mike 1.23
|
2564 kumpf 1.73 return CIMKeyBinding::BOOLEAN;
|
2565 mike 1.23 }
2566
2567 //------------------------------------------------------------------------------
2568 //
2569 // getKeyValueElement()
2570 //
2571 // <!ELEMENT KEYVALUE (#PCDATA)>
2572 // <!ATTLIST KEYVALUE
2573 // VALUETYPE (string|boolean|numeric) 'string'>
2574 //
2575 //------------------------------------------------------------------------------
2576
2577 Boolean XmlReader::getKeyValueElement(
2578 XmlParser& parser,
|
2579 kumpf 1.73 CIMKeyBinding::Type& type,
|
2580 mike 1.23 String& value)
2581 {
2582 XmlEntry entry;
2583
2584 if (!testStartTagOrEmptyTag(parser, entry, "KEYVALUE"))
2585 return false;
2586
2587 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2588
2589 type = getValueTypeAttribute(parser.getLine(), entry, "KEYVALUE");
2590
2591 value.clear();
2592
2593 if (!empty)
2594 {
2595 if (!parser.next(entry))
2596 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
2597
2598 if (entry.type == XmlEntry::CONTENT)
|
2599 chuck 1.98 value = String(entry.text);
|
2600 mike 1.23 else
2601 parser.putBack(entry);
2602
2603 expectEndTag(parser, "KEYVALUE");
2604 }
2605
2606 return true;
2607 }
2608
2609 //------------------------------------------------------------------------------
2610 //
2611 // getKeyBindingElement()
2612 //
2613 // <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>
2614 // <!ATTLIST KEYBINDING
2615 // %CIMName;>
2616 //
2617 //------------------------------------------------------------------------------
2618
2619 Boolean XmlReader::getKeyBindingElement(
2620 XmlParser& parser,
|
2621 kumpf 1.74 CIMName& name,
|
2622 mike 1.23 String& value,
|
2623 kumpf 1.73 CIMKeyBinding::Type& type)
|
2624 mike 1.23 {
2625 XmlEntry entry;
2626
2627 if (!testStartTag(parser, entry, "KEYBINDING"))
2628 return false;
2629
2630 name = getCimNameAttribute(parser.getLine(), entry, "KEYBINDING");
2631
2632 if (!getKeyValueElement(parser, type, value))
|
2633 mike 1.25 {
|
2634 kumpf 1.54 CIMObjectPath reference;
|
2635 mike 1.25
2636 if (!getValueReferenceElement(parser, reference))
2637 {
|
2638 humberto 1.85
2639 // l10n
2640
2641 // throw XmlValidationError(parser.getLine(),
2642 // "Expected KEYVALUE or VALUE.REFERENCE element");
2643
|
2644 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",
2645 "Expected KEYVALUE or VALUE.REFERENCE element");
|
2646 humberto 1.85
2647 throw XmlValidationError(parser.getLine(), mlParms);
|
2648 mike 1.25 }
2649
|
2650 kumpf 1.73 type = CIMKeyBinding::REFERENCE;
|
2651 mike 1.25 value = reference.toString();
2652 }
|
2653 mike 1.23
2654 expectEndTag(parser, "KEYBINDING");
2655 return true;
2656 }
2657
2658 //------------------------------------------------------------------------------
2659 //
2660 // getInstanceNameElement()
2661 //
2662 // <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
2663 // <!ATTLIST INSTANCENAME
2664 // %ClassName;>
2665 //
|
2666 mike 1.25 // Note: An empty key name is used in the keyBinding when the INSTANCENAME is
2667 // specified using a KEYVALUE or a VALUE.REFERENCE.
|
2668 mike 1.23 //
2669 //------------------------------------------------------------------------------
2670
2671 Boolean XmlReader::getInstanceNameElement(
2672 XmlParser& parser,
2673 String& className,
|
2674 kumpf 1.73 Array<CIMKeyBinding>& keyBindings)
|
2675 mike 1.23 {
2676 className.clear();
2677 keyBindings.clear();
2678
2679 XmlEntry entry;
2680
2681 if (!testStartTagOrEmptyTag(parser, entry, "INSTANCENAME"))
2682 return false;
2683
2684 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2685
2686 className = getClassNameAttribute(parser.getLine(), entry, "INSTANCENAME");
2687
|
2688 mike 1.25 if (empty)
|
2689 mike 1.23 {
|
2690 mike 1.25 return true;
2691 }
|
2692 mike 1.23
|
2693 kumpf 1.74 CIMName name;
|
2694 kumpf 1.73 CIMKeyBinding::Type type;
|
2695 mike 1.25 String value;
|
2696 kumpf 1.54 CIMObjectPath reference;
|
2697 mike 1.25
2698 if (getKeyValueElement(parser, type, value))
2699 {
2700 // Use empty key name because none was specified
|
2701 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2702 mike 1.25 }
2703 else if (getValueReferenceElement(parser, reference))
2704 {
2705 // Use empty key name because none was specified
|
2706 kumpf 1.73 type = CIMKeyBinding::REFERENCE;
|
2707 mike 1.25 value = reference.toString();
|
2708 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2709 mike 1.25 }
2710 else
2711 {
|
2712 mike 1.23 while (getKeyBindingElement(parser, name, value, type))
|
2713 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2714 mike 1.25 }
|
2715 mike 1.23
|
2716 mike 1.25 expectEndTag(parser, "INSTANCENAME");
|
2717 mike 1.23
2718 return true;
2719 }
2720
2721 Boolean XmlReader::getInstanceNameElement(
2722 XmlParser& parser,
|
2723 kumpf 1.54 CIMObjectPath& instanceName)
|
2724 mike 1.23 {
2725 String className;
|
2726 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2727 mike 1.23
2728 if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
2729 return false;
2730
|
2731 kumpf 1.62 instanceName.set(String(), CIMNamespaceName(), className, keyBindings);
|
2732 mike 1.23 return true;
2733 }
2734
2735 //------------------------------------------------------------------------------
2736 //
2737 // getInstancePathElement()
2738 //
2739 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2740 //
2741 //------------------------------------------------------------------------------
2742
2743 Boolean XmlReader::getInstancePathElement(
2744 XmlParser& parser,
|
2745 kumpf 1.54 CIMObjectPath& reference)
|
2746 mike 1.23 {
2747 XmlEntry entry;
2748
2749 if (!testStartTag(parser, entry, "INSTANCEPATH"))
2750 return false;
2751
2752 String host;
2753 String nameSpace;
2754
2755 if (!getNameSpacePathElement(parser, host, nameSpace))
2756 {
|
2757 humberto 1.85
2758 // l10n
2759
2760 // throw XmlValidationError(parser.getLine(),
2761 // "expected NAMESPACEPATH element");
2762
|
2763 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
2764 "expected NAMESPACEPATH element");
|
2765 humberto 1.85
2766 throw XmlValidationError(parser.getLine(), mlParms);
2767
|
2768 mike 1.23 }
2769
2770 String className;
|
2771 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2772 mike 1.23
2773 if (!getInstanceNameElement(parser, className, keyBindings))
2774 {
|
2775 humberto 1.85
2776 // l10n
2777
2778 // throw XmlValidationError(parser.getLine(),
2779 // "expected INSTANCENAME element");
2780
2781
|
2782 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
2783 "expected INSTANCENAME element");
|
2784 humberto 1.85
2785 throw XmlValidationError(parser.getLine(), mlParms);
2786
|
2787 mike 1.23 }
2788
2789 reference.set(host, nameSpace, className, keyBindings);
2790
2791 expectEndTag(parser, "INSTANCEPATH");
2792 return true;
2793 }
2794
2795 //------------------------------------------------------------------------------
2796 //
2797 // getLocalInstancePathElement()
2798 //
2799 // <!ELEMENT LOCALINSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2800 //
2801 //------------------------------------------------------------------------------
2802
2803 Boolean XmlReader::getLocalInstancePathElement(
2804 XmlParser& parser,
|
2805 kumpf 1.54 CIMObjectPath& reference)
|
2806 mike 1.23 {
2807 XmlEntry entry;
2808
2809 if (!testStartTag(parser, entry, "LOCALINSTANCEPATH"))
2810 return false;
2811
2812 String nameSpace;
2813
2814 if (!getLocalNameSpacePathElement(parser, nameSpace))
2815 {
|
2816 humberto 1.85
2817 // l10n
2818
2819 // throw XmlValidationError(parser.getLine(),
2820 // "expected LOCALNAMESPACEPATH element");
2821
|
2822 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2823 "expected LOCALNAMESPACEPATH element");
|
2824 humberto 1.85
2825 throw XmlValidationError(parser.getLine(), mlParms);
2826
|
2827 mike 1.23 }
2828
2829 String className;
|
2830 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2831 mike 1.23
2832 if (!getInstanceNameElement(parser, className, keyBindings))
2833 {
|
2834 humberto 1.85
2835 // l10n
2836
2837 // throw XmlValidationError(parser.getLine(),
2838 // "expected INSTANCENAME element");
2839
|
2840 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
2841 "expected INSTANCENAME element");
|
2842 humberto 1.85
2843 throw XmlValidationError(parser.getLine(), mlParms);
2844
|
2845 mike 1.23 }
2846
2847 reference.set(String(), nameSpace, className, keyBindings);
2848
2849 expectEndTag(parser, "LOCALINSTANCEPATH");
2850 return true;
2851 }
2852
2853 //------------------------------------------------------------------------------
2854 //
2855 // getClassPathElement()
2856 //
2857 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
2858 //
2859 //------------------------------------------------------------------------------
2860
2861 Boolean XmlReader::getClassPathElement(
2862 XmlParser& parser,
|
2863 kumpf 1.54 CIMObjectPath& reference)
|
2864 mike 1.23 {
2865 XmlEntry entry;
2866
2867 if (!testStartTag(parser, entry, "CLASSPATH"))
2868 return false;
2869
2870 String host;
2871 String nameSpace;
2872
2873 if (!getNameSpacePathElement(parser, host, nameSpace))
2874 {
|
2875 humberto 1.85
2876 // l10n
2877
2878 // throw XmlValidationError(parser.getLine(),
2879 // "expected NAMESPACEPATH element");
2880
|
2881 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
2882 "expected NAMESPACEPATH element");
|
2883 humberto 1.85
2884 throw XmlValidationError(parser.getLine(), mlParms);
2885
|
2886 mike 1.23 }
2887
|
2888 kumpf 1.74 CIMName className;
|
2889 mike 1.23
2890 if (!getClassNameElement(parser, className))
2891 {
|
2892 humberto 1.85
2893 // l10n
2894
2895 // throw XmlValidationError(parser.getLine(),
2896 // "expected CLASSNAME element");
2897
|
2898 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2899 "expected CLASSNAME element");
|
2900 humberto 1.85
2901 throw XmlValidationError(parser.getLine(), mlParms);
2902
|
2903 mike 1.23 }
2904
2905 reference.set(host, nameSpace, className);
2906
2907 expectEndTag(parser, "CLASSPATH");
2908 return true;
2909 }
2910
2911 //------------------------------------------------------------------------------
2912 //
2913 // getLocalClassPathElement()
2914 //
2915 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH,CLASSNAME)>
2916 //
2917 //------------------------------------------------------------------------------
2918
2919 Boolean XmlReader::getLocalClassPathElement(
2920 XmlParser& parser,
|
2921 kumpf 1.54 CIMObjectPath& reference)
|
2922 mike 1.23 {
2923 XmlEntry entry;
2924
2925 if (!testStartTag(parser, entry, "LOCALCLASSPATH"))
2926 return false;
2927
2928 String nameSpace;
2929
2930 if (!getLocalNameSpacePathElement(parser, nameSpace))
2931 {
|
2932 humberto 1.85
2933 // l10n
2934
2935 // throw XmlValidationError(parser.getLine(),
2936 // "expected LOCALNAMESPACEPATH element");
2937
|
2938 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2939 "expected LOCALNAMESPACEPATH element");
|
2940 humberto 1.85
2941 throw XmlValidationError(parser.getLine(), mlParms);
2942
|
2943 mike 1.23 }
2944
|
2945 kumpf 1.74 CIMName className;
|
2946 mike 1.23
2947 if (!getClassNameElement(parser, className))
2948 {
|
2949 humberto 1.85
2950 // l10n
2951
2952 // throw XmlValidationError(parser.getLine(),
2953 // "expected CLASSNAME element");
2954
|
2955 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2956 "expected CLASSNAME element");
|
2957 humberto 1.85
2958 throw XmlValidationError(parser.getLine(), mlParms);
2959
|
2960 mike 1.23 }
2961
2962 reference.set(String(), nameSpace, className);
2963
2964 expectEndTag(parser, "LOCALCLASSPATH");
2965
2966 return true;
2967 }
2968
2969 //------------------------------------------------------------------------------
2970 //
2971 // getValueReferenceElement()
2972 //
2973 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
2974 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
2975 //
2976 //
2977 //------------------------------------------------------------------------------
2978
2979 Boolean XmlReader::getValueReferenceElement(
2980 XmlParser& parser,
|
2981 kumpf 1.54 CIMObjectPath& reference)
|
2982 mike 1.23 {
2983 XmlEntry entry;
2984
2985 if (!testStartTag(parser, entry, "VALUE.REFERENCE"))
2986 return false;
2987
2988 if (!parser.next(entry))
2989 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
2990
2991 if (entry.type != XmlEntry::START_TAG &&
2992 entry.type != XmlEntry::EMPTY_TAG)
2993 {
|
2994 humberto 1.85
2995 // l10n
2996
2997 // throw XmlValidationError(parser.getLine(),
2998 // "Expected one of the following start tags: "
2999 // "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "
3000 // "LOCALINSTANCEPATH, INSTANCENAME");
3001
3002 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS",
|
3003 humberto 1.87 "Expected one of the following start tags: CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME");
|
3004 humberto 1.85
3005 throw XmlValidationError(parser.getLine(), mlParms);
3006
|
3007 mike 1.23 }
3008
3009 if (strcmp(entry.text, "CLASSPATH") == 0)
3010 {
3011 parser.putBack(entry);
3012 getClassPathElement(parser, reference);
3013 }
3014 else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)
3015 {
3016 parser.putBack(entry);
3017 getLocalClassPathElement(parser, reference);
3018 }
3019 else if (strcmp(entry.text, "CLASSNAME") == 0)
3020 {
3021 parser.putBack(entry);
|
3022 kumpf 1.74 CIMName className;
|
3023 mike 1.23 getClassNameElement(parser, className);
|
3024 kumpf 1.62 reference.set(String(), CIMNamespaceName(), className);
|
3025 mike 1.23 }
3026 else if (strcmp(entry.text, "INSTANCEPATH") == 0)
3027 {
3028 parser.putBack(entry);
3029 getInstancePathElement(parser, reference);
3030 }
3031 else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)
3032 {
3033 parser.putBack(entry);
3034 getLocalInstancePathElement(parser, reference);
3035 }
3036 else if (strcmp(entry.text, "INSTANCENAME") == 0)
3037 {
3038 parser.putBack(entry);
3039 String className;
|
3040 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
3041 mike 1.23 getInstanceNameElement(parser, className, keyBindings);
|
3042 kumpf 1.62 reference.set(String(), CIMNamespaceName(), className, keyBindings);
|
3043 mike 1.23 }
3044
3045 expectEndTag(parser, "VALUE.REFERENCE");
3046 return true;
3047 }
3048
3049 //------------------------------------------------------------------------------
3050 //
|
3051 kumpf 1.28 // getValueReferenceArrayElement()
3052 //
3053 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
3054 //
3055 //------------------------------------------------------------------------------
3056
3057 Boolean XmlReader::getValueReferenceArrayElement(
3058 XmlParser& parser,
3059 CIMValue& value)
3060 {
3061 XmlEntry entry;
|
3062 kumpf 1.54 Array<CIMObjectPath> referenceArray;
3063 CIMObjectPath reference;
|
3064 kumpf 1.28
3065 value.clear();
3066
3067 // Get VALUE.REFARRAY open tag:
3068
3069 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.REFARRAY"))
3070 return false;
3071
|
3072 kumpf 1.32 if (entry.type != XmlEntry::EMPTY_TAG)
3073 {
3074 // For each VALUE.REFERENCE element:
|
3075 kumpf 1.28
|
3076 kumpf 1.32 while (getValueReferenceElement(parser, reference))
3077 {
3078 referenceArray.append(reference);
3079 }
|
3080 kumpf 1.28
|
3081 kumpf 1.32 expectEndTag(parser, "VALUE.REFARRAY");
|
3082 kumpf 1.28 }
3083
3084 value.set(referenceArray);
3085 return true;
3086 }
3087
3088 //------------------------------------------------------------------------------
3089 //
|
3090 mike 1.23 // getPropertyReferenceElement()
3091 //
3092 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)>
3093 // <!ATTLIST PROPERTY.REFERENCE
3094 // %CIMName;
3095 // %ReferenceClass;
3096 // %ClassOrigin;
3097 // %Propagated;>
3098 //
3099 //------------------------------------------------------------------------------
3100
3101 Boolean XmlReader::getPropertyReferenceElement(
3102 XmlParser& parser,
3103 CIMProperty& property)
3104 {
3105 XmlEntry entry;
3106
3107 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.REFERENCE"))
3108 return false;
3109
3110 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3111 mike 1.23
3112 // Get PROPERTY.NAME attribute:
3113
|
3114 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3115 mike 1.23 parser.getLine(), entry, "PROPERTY.REFERENCE");
3116
3117 // Get PROPERTY.REFERENCECLASS attribute:
3118
|
3119 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
3120 mike 1.23 parser.getLine(), entry, "PROPERTY.REFERENCE");
3121
3122 // Get PROPERTY.CLASSORIGIN attribute:
3123
|
3124 kumpf 1.62 CIMName classOrigin =
|
3125 mike 1.23 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");
3126
3127 // Get PROPERTY.PROPAGATED
3128
3129 Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,
3130 "PROPERTY.REFERENCE", "PROPAGATED", false, false);
3131
3132 // Create property:
3133
|
3134 kumpf 1.61 CIMValue value = CIMValue(CIMTYPE_REFERENCE, false, 0);
|
3135 kumpf 1.54 // value.set(CIMObjectPath());
|
3136 mike 1.23 property = CIMProperty(
3137 name, value, 0, referenceClass, classOrigin, propagated);
3138
3139 if (!empty)
3140 {
3141 getQualifierElements(parser, property);
3142
|
3143 kumpf 1.54 CIMObjectPath reference;
|
3144 mike 1.23
3145 if (getValueReferenceElement(parser, reference))
3146 property.setValue(reference);
3147
3148 expectEndTag(parser, "PROPERTY.REFERENCE");
3149 }
3150
3151 return true;
3152 }
3153
3154 //------------------------------------------------------------------------------
3155 //
3156 // GetPropertyElements()
3157 //
3158 //------------------------------------------------------------------------------
3159
3160 template<class CONTAINER>
3161 void GetPropertyElements(XmlParser& parser, CONTAINER& container)
3162 {
3163 CIMProperty property;
3164
3165 mike 1.23 while (XmlReader::getPropertyElement(parser, property) ||
3166 XmlReader::getPropertyArrayElement(parser, property) ||
3167 XmlReader::getPropertyReferenceElement(parser, property))
3168 {
3169 try
3170 {
3171 container.addProperty(property);
3172 }
|
3173 kumpf 1.66 catch (AlreadyExistsException&)
|
3174 mike 1.23 {
|
3175 humberto 1.85
3176 // l10n
3177
3178 // throw XmlSemanticError(parser.getLine(), "duplicate property");
3179
|
3180 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PROPERTY",
3181 "duplicate property");
|
3182 humberto 1.85
3183 throw XmlSemanticError(parser.getLine(), mlParms);
|
3184 mike 1.23 }
3185 }
3186 }
3187
3188 //------------------------------------------------------------------------------
3189 //
3190 // getParameterElement()
3191 //
3192 // <!ELEMENT PARAMETER (QUALIFIER*)>
3193 // <!ATTLIST PARAMETER
3194 // %CIMName;
3195 // %CIMType; #REQUIRED>
3196 //
3197 //------------------------------------------------------------------------------
3198
3199 Boolean XmlReader::getParameterElement(
3200 XmlParser& parser,
3201 CIMParameter& parameter)
3202 {
3203 XmlEntry entry;
3204
3205 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER"))
3206 return false;
3207
3208 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3209
3210 // Get PARAMETER.NAME attribute:
3211
|
3212 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");
|
3213 mike 1.23
3214 // Get PARAMETER.TYPE attribute:
3215
|
3216 kumpf 1.67 CIMType type;
3217 getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER");
|
3218 mike 1.23
3219 // Create parameter:
3220
3221 parameter = CIMParameter(name, type);
3222
3223 if (!empty)
3224 {
3225 getQualifierElements(parser, parameter);
3226
3227 expectEndTag(parser, "PARAMETER");
3228 }
3229
3230 return true;
3231 }
3232
3233 //------------------------------------------------------------------------------
3234 //
3235 // getParameterArrayElement()
3236 //
3237 // <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
3238 // <!ATTLIST PARAMETER.ARRAY
3239 mike 1.23 // %CIMName;
3240 // %CIMType; #REQUIRED
3241 // %ArraySize;>
3242 //
3243 //------------------------------------------------------------------------------
3244
3245 Boolean XmlReader::getParameterArrayElement(
3246 XmlParser& parser,
3247 CIMParameter& parameter)
3248 {
3249 XmlEntry entry;
3250
3251 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.ARRAY"))
3252 return false;
3253
3254 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3255
3256 // Get PARAMETER.ARRAY.NAME attribute:
3257
|
3258 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3259 mike 1.23 parser.getLine(), entry, "PARAMETER.ARRAY");
3260
3261 // Get PARAMETER.ARRAY.TYPE attribute:
3262
|
3263 kumpf 1.67 CIMType type;
3264 getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER.ARRAY");
|
3265 mike 1.23
3266 // Get PARAMETER.ARRAYSIZE attribute:
3267
3268 Uint32 arraySize = 0;
3269 getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY",arraySize);
3270
3271 // Create parameter:
3272
3273 parameter = CIMParameter(name, type, true, arraySize);
3274
3275 if (!empty)
3276 {
3277 getQualifierElements(parser, parameter);
3278
3279 expectEndTag(parser, "PARAMETER.ARRAY");
3280 }
3281
3282 return true;
3283 }
3284
3285 //------------------------------------------------------------------------------
3286 mike 1.23 //
3287 // getParameterReferenceElement()
3288 //
3289 // <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
3290 // <!ATTLIST PARAMETER.REFERENCE
3291 // %CIMName;
3292 // %ReferenceClass;>
3293 //
3294 //------------------------------------------------------------------------------
3295
3296 Boolean XmlReader::getParameterReferenceElement(
3297 XmlParser& parser,
3298 CIMParameter& parameter)
3299 {
3300 XmlEntry entry;
3301
3302 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFERENCE"))
3303 return false;
3304
3305 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3306
3307 mike 1.23 // Get PARAMETER.NAME attribute:
3308
|
3309 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3310 mike 1.23 parser.getLine(), entry, "PARAMETER.REFERENCE");
3311
3312 // Get PARAMETER.REFERENCECLASS attribute:
3313
|
3314 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
3315 mike 1.23 parser.getLine(), entry, "PARAMETER.REFERENCE");
3316
3317 // Create parameter:
3318
|
3319 kumpf 1.61 parameter = CIMParameter(name, CIMTYPE_REFERENCE, false, 0, referenceClass);
|
3320 mike 1.23
3321 if (!empty)
3322 {
3323 getQualifierElements(parser, parameter);
3324 expectEndTag(parser, "PARAMETER.REFERENCE");
3325 }
3326
3327 return true;
3328 }
3329
3330 //------------------------------------------------------------------------------
3331 //
|
3332 kumpf 1.26 // getParameterReferenceArrayElement()
3333 //
3334 // <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
3335 // <!ATTLIST PARAMETER.REFARRAY
3336 // %CIMName;
3337 // %ReferenceClass;
3338 // %ArraySize;>
3339 //
3340 //------------------------------------------------------------------------------
3341
3342 Boolean XmlReader::getParameterReferenceArrayElement(
3343 XmlParser& parser,
3344 CIMParameter& parameter)
3345 {
3346 XmlEntry entry;
3347
3348 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFARRAY"))
3349 return false;
3350
3351 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3352
3353 kumpf 1.26 // Get PARAMETER.NAME attribute:
3354
|
3355 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3356 kumpf 1.26 parser.getLine(), entry, "PARAMETER.REFARRAY");
3357
3358 // Get PARAMETER.REFERENCECLASS attribute:
3359
|
3360 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
3361 kumpf 1.26 parser.getLine(), entry, "PARAMETER.REFARRAY");
3362
3363 // Get PARAMETER.ARRAYSIZE attribute:
3364
3365 Uint32 arraySize = 0;
3366 getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.REFARRAY",
3367 arraySize);
3368
3369 // Create parameter:
3370
|
3371 kumpf 1.61 parameter = CIMParameter(name, CIMTYPE_REFERENCE, true, arraySize,
|
3372 kumpf 1.26 referenceClass);
3373
3374 if (!empty)
3375 {
3376 getQualifierElements(parser, parameter);
3377 expectEndTag(parser, "PARAMETER.REFARRAY");
3378 }
3379
3380 return true;
3381 }
3382
3383 //------------------------------------------------------------------------------
3384 //
|
3385 mike 1.23 // GetParameterElements()
3386 //
3387 //------------------------------------------------------------------------------
3388
3389 template<class CONTAINER>
3390 void GetParameterElements(XmlParser& parser, CONTAINER& container)
3391 {
3392 CIMParameter parameter;
3393
3394 while (XmlReader::getParameterElement(parser, parameter) ||
3395 XmlReader::getParameterArrayElement(parser, parameter) ||
|
3396 kumpf 1.26 XmlReader::getParameterReferenceElement(parser, parameter) ||
3397 XmlReader::getParameterReferenceArrayElement(parser, parameter))
|
3398 mike 1.23 {
3399 try
3400 {
3401 container.addParameter(parameter);
3402 }
|
3403 kumpf 1.66 catch (AlreadyExistsException&)
|
3404 mike 1.23 {
|
3405 humberto 1.85
3406 // l10n
3407
3408 // throw XmlSemanticError(parser.getLine(), "duplicate parameter");
3409
|
3410 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PARAMETER",
3411 "duplicate parameter");
|
3412 humberto 1.85
3413 throw XmlSemanticError(parser.getLine(), mlParms);
|
3414 mike 1.23 }
3415 }
3416 }
3417
3418 //------------------------------------------------------------------------------
3419 //
3420 // getQualifierDeclElement()
3421 //
3422 // <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
3423 // <!ATTLIST QUALIFIER.DECLARATION
3424 // %CIMName;
3425 // %CIMType; #REQUIRED
3426 // ISARRAY (true|false) #IMPLIED
3427 // %ArraySize;
3428 // %QualifierFlavor;>
3429 //
3430 //------------------------------------------------------------------------------
3431
3432 Boolean XmlReader::getQualifierDeclElement(
3433 XmlParser& parser,
3434 CIMQualifierDecl& qualifierDecl)
3435 mike 1.23 {
3436 XmlEntry entry;
3437
3438 if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER.DECLARATION"))
3439 return false;
3440
3441 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3442
3443 // Get NAME attribute:
3444
|
3445 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3446 mike 1.23 parser.getLine(), entry, "QUALIFIER.DECLARATION");
3447
3448 // Get TYPE attribute:
3449
|
3450 kumpf 1.67 CIMType type;
3451 getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER.DECLARATION");
|
3452 mike 1.23
3453 // Get ISARRAY attribute:
3454
|
3455 mike 1.25 Boolean isArray = getCimBooleanAttribute(
3456 parser.getLine(), entry, "QUALIFIER.DECLARATION", "ISARRAY",
3457 false, false);
|
3458 mike 1.23
3459 // Get ARRAYSIZE attribute:
3460
3461 Uint32 arraySize = 0;
3462 Boolean gotArraySize = getArraySizeAttribute(parser.getLine(),
3463 entry, "QUALIFIER.DECLARATION", arraySize);
3464
3465 // Get flavor oriented attributes:
3466
|
3467 kumpf 1.64 CIMFlavor flavor = getFlavor (entry, parser.getLine (),
3468 "QUALIFIER.DECLARATION");
|
3469 mike 1.23
3470 // No need to look for interior elements if empty tag:
3471
|
3472 kumpf 1.63 CIMScope scope = CIMScope ();
|
3473 mike 1.23 CIMValue value;
|
3474 kumpf 1.67 Boolean gotValue = false;
|
3475 mike 1.23
3476 if (!empty)
3477 {
3478 // Get the option SCOPE element:
3479
3480 scope = getOptionalScope(parser);
3481
3482 // Get VALUE or VALUE.ARRAY element:
3483
3484 if (getValueArrayElement(parser, type, value))
3485 {
3486 if (!isArray)
3487 {
|
3488 humberto 1.85
3489 // l10n
3490
3491 // throw XmlSemanticError(parser.getLine(),
3492 // "VALUE.ARRAY element encountered without "
3493 // "ISARRAY attribute");
3494
3495 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY",
|
3496 humberto 1.87 "VALUE.ARRAY element encountered without ISARRAY attribute");
|
3497 humberto 1.85
3498 throw XmlSemanticError(parser.getLine(), mlParms);
|
3499 mike 1.23 }
3500
3501 if (arraySize && arraySize != value.getArraySize())
3502 {
|
3503 humberto 1.85
3504 // l10n
3505
3506 // throw XmlSemanticError(parser.getLine(),
3507 // "VALUE.ARRAY size is not the same as "
3508 // "ARRAYSIZE attribute");
3509
3510 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME",
|
3511 humberto 1.87 "VALUE.ARRAY size is not the same as ARRAYSIZE attribute");
|
3512 humberto 1.85
3513 throw XmlSemanticError(parser.getLine(), mlParms);
|
3514 mike 1.23 }
|
3515 kumpf 1.67
3516 gotValue = true;
|
3517 mike 1.23 }
3518 else if (getValueElement(parser, type, value))
3519 {
3520 if (isArray)
3521 {
|
3522 humberto 1.85
3523 // l10n
3524
3525 // throw XmlSemanticError(parser.getLine(),
3526 // "ISARRAY attribute used but VALUE element encountered");
3527
3528 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",
|
3529 humberto 1.87 "ISARRAY attribute used but VALUE element encountered");
|
3530 humberto 1.85
3531 throw XmlSemanticError(parser.getLine(), mlParms);
|
3532 mike 1.23 }
|
3533 kumpf 1.67
3534 gotValue = true;
|
3535 mike 1.23 }
3536
3537 // Now get the closing tag:
3538
3539 expectEndTag(parser, "QUALIFIER.DECLARATION");
3540 }
3541
|
3542 kumpf 1.67 if (!gotValue)
|
3543 mike 1.23 {
3544 if (isArray)
3545 value.setNullValue(type, true, arraySize);
3546 else
3547 value.setNullValue(type, false);
3548 }
3549
3550 CIMQualifierDecl tmp(name, value, scope, flavor, arraySize);
3551 qualifierDecl = CIMQualifierDecl(name, value, scope, flavor, arraySize);
3552 return true;
3553 }
3554
3555 //------------------------------------------------------------------------------
3556 // getMethodElement()
3557 //
3558 // <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|
3559 // PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
3560 // <!ATTLIST METHOD
3561 // %CIMName;
3562 // %CIMType; #IMPLIED
3563 // %ClassOrigin;
3564 mike 1.23 // %Propagated;>
3565 //
3566 //------------------------------------------------------------------------------
3567
3568 Boolean XmlReader::getMethodElement(XmlParser& parser, CIMMethod& method)
3569 {
3570 XmlEntry entry;
3571
3572 if (!testStartTagOrEmptyTag(parser, entry, "METHOD"))
3573 return false;
3574
3575 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3576
|
3577 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
|
3578 mike 1.23
|
3579 kumpf 1.67 CIMType type;
3580 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");
|
3581 mike 1.23
|
3582 kumpf 1.62 CIMName classOrigin =
|
3583 mike 1.23 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
3584
3585 Boolean propagated = getCimBooleanAttribute(
3586 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
3587
3588 method = CIMMethod(name, type, classOrigin, propagated);
3589
3590 if (!empty)
3591 {
|
3592 kumpf 1.26 // ATTN-RK-P2-20020219: Decoding algorithm must not depend on the
3593 // ordering of qualifiers and parameters.
|
3594 mike 1.23 getQualifierElements(parser, method);
3595
3596 GetParameterElements(parser, method);
3597
3598 expectEndTag(parser, "METHOD");
3599 }
3600
3601 return true;
3602 }
3603
3604 //------------------------------------------------------------------------------
3605 // getClassElement()
3606 //
3607 // <!ELEMENT CLASS (QUALIFIER*,
3608 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
3609 // <!ATTLIST CLASS %CIMName; %SuperClass;>
3610 //
3611 //------------------------------------------------------------------------------
3612
3613 Boolean XmlReader::getClassElement(XmlParser& parser, CIMClass& cimClass)
3614 {
3615 mike 1.23 XmlEntry entry;
3616
|
3617 a.dunfey 1.96 if (!testStartTagOrEmptyTag(parser, entry, "CLASS"))
|
3618 mike 1.23 return false;
3619
|
3620 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
|
3621 mike 1.23
|
3622 kumpf 1.62 CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");
|
3623 mike 1.23
3624 cimClass = CIMClass(name, superClass);
3625
|
3626 a.dunfey 1.97 if(entry.type != XmlEntry::EMPTY_TAG)
3627 {
3628
|
3629 mike 1.23 // Get QUALIFIER elements:
3630
3631 getQualifierElements(parser, cimClass);
3632
3633 // Get PROPERTY elements:
3634
3635 GetPropertyElements(parser, cimClass);
3636
3637 // Get METHOD elements:
3638
3639 CIMMethod method;
3640
3641 while (getMethodElement(parser, method))
3642 cimClass.addMethod(method);
3643
3644 // Get CLASS end tag:
|
3645 a.dunfey 1.97
3646 expectEndTag(parser, "CLASS");
3647 }
|
3648 mike 1.23
3649 return true;
3650 }
3651
3652 //------------------------------------------------------------------------------
3653 // getInstanceElement()
3654 //
3655 // <!ELEMENT INSTANCE (QUALIFIER*,
3656 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*) >
3657 // <!ATTLIST INSTANCE
3658 // %ClassName;>
3659 //
3660 //------------------------------------------------------------------------------
3661
3662 Boolean XmlReader::getInstanceElement(
3663 XmlParser& parser,
3664 CIMInstance& cimInstance)
3665 {
3666 XmlEntry entry;
3667
|
3668 kumpf 1.89 if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE"))
|
3669 mike 1.23 return false;
3670
|
3671 kumpf 1.89 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3672
|
3673 mike 1.23 String className = getClassNameAttribute(
3674 parser.getLine(), entry, "INSTANCE");
3675
3676 cimInstance = CIMInstance(className);
3677
|
3678 kumpf 1.89 if (!empty)
3679 {
3680 // Get QUALIFIER elements:
3681 getQualifierElements(parser, cimInstance);
3682
3683 // Get PROPERTY elements:
3684 GetPropertyElements(parser, cimInstance);
3685
3686 // Get INSTANCE end tag:
3687 expectEndTag(parser, "INSTANCE");
3688 }
|
3689 mike 1.23
3690 return true;
3691 }
3692
3693 //------------------------------------------------------------------------------
|
3694 mike 1.25 // getNamedInstanceElement()
3695 //
3696 // <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
3697 //
3698 //------------------------------------------------------------------------------
3699
3700 Boolean XmlReader::getNamedInstanceElement(
3701 XmlParser& parser,
|
3702 kumpf 1.55 CIMInstance& namedInstance)
|
3703 mike 1.25 {
3704 XmlEntry entry;
3705
3706 if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))
3707 return false;
3708
|
3709 kumpf 1.54 CIMObjectPath instanceName;
|
3710 mike 1.25
3711 // Get INSTANCENAME elements:
3712
3713 if (!getInstanceNameElement(parser, instanceName))
3714 {
|
3715 humberto 1.85
3716 // l10n
3717
3718 // throw XmlValidationError(parser.getLine(),
3719 // "expected INSTANCENAME element");
3720
|
3721 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
3722 "expected INSTANCENAME element");
|
3723 humberto 1.85
3724 throw XmlValidationError(parser.getLine(), mlParms);
|
3725 mike 1.25 }
3726
3727 // Get INSTANCE elements:
3728
|
3729 kumpf 1.55 if (!getInstanceElement(parser, namedInstance))
|
3730 mike 1.25 {
|
3731 humberto 1.85
3732 // l10n
3733
3734 // throw XmlValidationError(parser.getLine(),
3735 // "expected INSTANCE element");
3736
3737
|
3738 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3739 "expected INSTANCE element");
|
3740 humberto 1.85
3741 throw XmlValidationError(parser.getLine(), mlParms);
|
3742 mike 1.25 }
3743
3744 // Get VALUE.NAMEDINSTANCE end tag:
3745
3746 expectEndTag(parser, "VALUE.NAMEDINSTANCE");
3747
|
3748 kumpf 1.55 namedInstance.setPath (instanceName);
|
3749 mike 1.25
3750 return true;
3751 }
3752
3753 //------------------------------------------------------------------------------
|
3754 mike 1.23 //
3755 // getObject()
3756 //
3757 //------------------------------------------------------------------------------
3758
3759 void XmlReader::getObject(XmlParser& parser, CIMClass& x)
3760 {
3761 if (!getClassElement(parser, x))
3762 {
|
3763 humberto 1.85
3764 // l10n
3765
3766 // throw XmlValidationError(parser.getLine(),
3767 // "expected CLASS element");
3768
|
3769 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
3770 "expected CLASS element");
|
3771 humberto 1.85
3772 throw XmlValidationError(parser.getLine(), mlParms);
|
3773 mike 1.23 }
3774 }
3775
3776 //------------------------------------------------------------------------------
3777 //
3778 // getObject()
3779 //
3780 //------------------------------------------------------------------------------
3781
3782 void XmlReader::getObject(XmlParser& parser, CIMInstance& x)
3783 {
3784 if (!getInstanceElement(parser, x))
3785 {
|
3786 humberto 1.85
3787 // l10n
3788
3789 // throw XmlValidationError(parser.getLine(),
3790 // "expected INSTANCE element");
3791
|
3792 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3793 "expected INSTANCE element");
|
3794 humberto 1.85
3795 throw XmlValidationError(parser.getLine(), mlParms);
|
3796 mike 1.23 }
3797 }
3798
3799 //------------------------------------------------------------------------------
3800 //
3801 // getObject()
3802 //
3803 //------------------------------------------------------------------------------
3804
3805 void XmlReader::getObject(XmlParser& parser, CIMQualifierDecl& x)
3806 {
3807 if (!getQualifierDeclElement(parser, x))
3808 {
|
3809 humberto 1.85
3810 // l10n
3811
3812 // throw XmlValidationError(parser.getLine(),
3813 // "expected QUALIFIER.DECLARATION element");
3814
|
3815 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",
3816 "expected QUALIFIER.DECLARATION element");
|
3817 humberto 1.85
3818 throw XmlValidationError(parser.getLine(), mlParms);
|
3819 mike 1.23 }
3820 }
3821
3822 //------------------------------------------------------------------------------
3823 //
3824 // getMessageStartTag()
3825 //
3826 //------------------------------------------------------------------------------
3827
3828 Boolean XmlReader::getMessageStartTag(
3829 XmlParser& parser,
3830 String& id,
|
3831 kumpf 1.34 String& protocolVersion)
|
3832 mike 1.23 {
3833 XmlEntry entry;
3834
3835 if (!testStartTag(parser, entry, "MESSAGE"))
3836 return false;
3837
3838 // Get MESSAGE.ID:
3839
|
3840 humberto 1.85 if (!entry.getAttributeValue("ID", id)) {
3841
3842 // l10n
3843
3844 // throw XmlValidationError(parser.getLine(),
3845 // "Invalid or missing MESSAGE.ID attribute");
3846
|
3847 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",
3848 "Invalid or missing MESSAGE.ID attribute");
|
3849 humberto 1.85
3850 throw XmlValidationError(parser.getLine(), mlParms);
3851 }
3852
|
3853 mike 1.23
3854 // Get MESSAGE.PROTOCOLVERSION:
3855
|
3856 humberto 1.85 if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion)) {
3857
3858 // l10n
|
3859 mike 1.23
|
3860 humberto 1.85 // throw XmlValidationError(parser.getLine(),
3861 // "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
3862
|
3863 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",
3864 "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
|
3865 humberto 1.85
3866 throw XmlValidationError(parser.getLine(), mlParms);
3867 }
3868
|
3869 mike 1.23 return true;
3870 }
3871
3872 //------------------------------------------------------------------------------
3873 //
3874 // getIMethodCallStartTag()
3875 //
3876 //------------------------------------------------------------------------------
3877
3878 Boolean XmlReader::getIMethodCallStartTag(
3879 XmlParser& parser,
3880 const char*& name)
3881 {
3882 XmlEntry entry;
3883
3884 if (!testStartTag(parser, entry, "IMETHODCALL"))
3885 return false;
3886
3887 // Get IMETHODCALL.NAME attribute:
3888
|
3889 humberto 1.85
3890 if (!entry.getAttributeValue("NAME", name)) {
3891
3892 // l10n
3893
3894 // throw XmlValidationError(parser.getLine(),
3895 // "Missing IMETHODCALL.NAME attribute");
3896
|
3897 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",
3898 "Missing IMETHODCALL.NAME attribute");
|
3899 humberto 1.85
3900 throw XmlValidationError(parser.getLine(), mlParms);
3901 }
3902
|
3903 mike 1.23
3904 return true;
3905 }
3906
3907 //------------------------------------------------------------------------------
3908 //
3909 // getIMethodResponseStartTag()
3910 //
3911 //------------------------------------------------------------------------------
3912
3913 Boolean XmlReader::getIMethodResponseStartTag(
3914 XmlParser& parser,
|
3915 kumpf 1.101 const char*& name,
3916 Boolean& isEmptyTag)
|
3917 mike 1.23 {
3918 XmlEntry entry;
3919
|
3920 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "IMETHODRESPONSE"))
|
3921 mike 1.23 return false;
3922
|
3923 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
3924
|
3925 mike 1.23 // Get IMETHODRESPONSE.NAME attribute:
3926
|
3927 humberto 1.85 if (!entry.getAttributeValue("NAME", name)) {
3928
3929 // l10n
3930
3931 // throw XmlValidationError(parser.getLine(),
3932 // "Missing IMETHODRESPONSE.NAME attribute");
3933
|
3934 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",
3935 "Missing IMETHODRESPONSE.NAME attribute");
|
3936 humberto 1.85
3937 throw XmlValidationError(parser.getLine(), mlParms);
3938 }
3939
|
3940 mike 1.23
3941 return true;
3942 }
3943
3944 //------------------------------------------------------------------------------
3945 //
3946 // getIParamValueTag()
3947 //
3948 //------------------------------------------------------------------------------
3949
3950 Boolean XmlReader::getIParamValueTag(
3951 XmlParser& parser,
|
3952 kumpf 1.99 const char*& name,
3953 Boolean& isEmptyTag)
|
3954 mike 1.23 {
3955 XmlEntry entry;
3956
|
3957 kumpf 1.99 if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE"))
|
3958 mike 1.23 return false;
3959
|
3960 kumpf 1.99 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
3961
|
3962 mike 1.23 // Get IPARAMVALUE.NAME attribute:
3963
|
3964 humberto 1.85 if (!entry.getAttributeValue("NAME", name)) {
3965
3966 // l10n
3967
3968 // throw XmlValidationError(parser.getLine(),
3969 // "Missing IPARAMVALUE.NAME attribute");
3970
|
3971 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",
3972 "Missing IPARAMVALUE.NAME attribute");
|
3973 humberto 1.85
3974 throw XmlValidationError(parser.getLine(), mlParms);
3975 }
|
3976 mike 1.23
3977 return true;
3978 }
3979
3980 //------------------------------------------------------------------------------
3981 //
|
3982 kumpf 1.99 // rejectNullIParamValue()
3983 //
3984 //------------------------------------------------------------------------------
3985
3986 void XmlReader::rejectNullIParamValue(
3987 XmlParser& parser,
3988 Boolean isEmptyTag,
3989 const char* paramName)
3990 {
3991 if (isEmptyTag)
3992 {
3993 MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE",
3994 "A null value is not valid for IPARAMVALUE \"$0\".",
3995 paramName);
3996 throw XmlValidationError(parser.getLine(), mlParms);
3997 }
3998 }
3999
4000 //------------------------------------------------------------------------------
4001 //
|
4002 mike 1.23 // getBooleanValueElement()
4003 //
4004 // Get an elements like: "<VALUE>FALSE</VALUE>"
4005 //
4006 //------------------------------------------------------------------------------
4007
4008 Boolean XmlReader::getBooleanValueElement(
4009 XmlParser& parser,
4010 Boolean& result,
4011 Boolean required)
4012 {
4013 XmlEntry entry;
4014
4015 if (!testStartTag(parser, entry, "VALUE"))
4016 {
4017 if (required)
4018 {
|
4019 humberto 1.85
4020 // l10n
4021
4022 // throw XmlValidationError(parser.getLine(),
4023 // "Expected VALUE element");
4024
|
4025 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
4026 "Expected VALUE element");
|
4027 humberto 1.85
4028 throw XmlValidationError(parser.getLine(), mlParms);
|
4029 mike 1.23 }
4030 return false;
4031 }
4032
4033 expectContentOrCData(parser, entry);
4034
|
4035 kumpf 1.72 if (System::strcasecmp(entry.text, "TRUE") == 0)
|
4036 mike 1.23 result = true;
|
4037 kumpf 1.72 else if (System::strcasecmp(entry.text, "FALSE") == 0)
|
4038 mike 1.23 result = false;
|
4039 humberto 1.85 else {
4040
4041 // l10n
4042
4043 // throw XmlSemanticError(parser.getLine(),
4044 // "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
4045
4046 MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",
|
4047 humberto 1.87 "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
|
4048 humberto 1.85
4049 throw XmlSemanticError(parser.getLine(), mlParms);
4050 }
|
4051 mike 1.23
4052 expectEndTag(parser, "VALUE");
4053
4054 return true;
4055 }
4056
4057 //------------------------------------------------------------------------------
4058 //
|
4059 kumpf 1.95 // DMTF CR Pending
|
4060 mike 1.23 //
|
4061 kumpf 1.95 // <!ELEMENT ERROR (INSTANCE*)>
|
4062 mike 1.23 // <!ATTLIST ERROR
4063 // CODE CDATA #REQUIRED
4064 // DESCRIPTION CDATA #IMPLIED>
4065 //
4066 //------------------------------------------------------------------------------
4067
4068 Boolean XmlReader::getErrorElement(
4069 XmlParser& parser,
|
4070 kumpf 1.50 CIMException& cimException,
|
4071 mike 1.23 Boolean required)
4072 {
4073 XmlEntry entry;
4074
4075 if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))
4076 {
|
4077 humberto 1.85 if (required) {
4078
4079 // l10n
4080
4081 // throw XmlValidationError(parser.getLine(),"Expected ERROR element");
4082
|
4083 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ERROR_ELEMENT",
4084 "Expected ERROR element");
|
4085 humberto 1.85
4086 throw XmlValidationError(parser.getLine(), mlParms);
4087
4088 }
4089 return false;
|
4090 mike 1.23 }
4091
4092 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
4093
4094 // Get ERROR.CODE
4095
4096 Uint32 tmpCode;
4097
|
4098 humberto 1.85 if (!entry.getAttributeValue("CODE", tmpCode)) {
4099
4100
4101 // l10n
4102
4103 // throw XmlValidationError(
4104 // parser.getLine(), "missing ERROR.CODE attribute");
4105
|
4106 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",
4107 "missing ERROR.CODE attribute");
|
4108 humberto 1.85
4109 throw XmlValidationError(parser.getLine(), mlParms);
4110
4111 }
|
4112 mike 1.23
|
4113 kumpf 1.50 // Get ERROR.DESCRIPTION:
|
4114 mike 1.23
|
4115 kumpf 1.50 String tmpDescription;
|
4116 mike 1.23
|
4117 kumpf 1.50 entry.getAttributeValue("DESCRIPTION", tmpDescription);
|
4118 mike 1.23
4119 if (!empty)
|
4120 kumpf 1.95 {
4121 while (testStartTagOrEmptyTag(parser, entry))
4122 {
4123 skipElement(parser, entry);
4124 }
4125
|
4126 mike 1.23 expectEndTag(parser, "ERROR");
|
4127 kumpf 1.95 }
|
4128 mike 1.23
|
4129 kumpf 1.50 cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);
|
4130 mike 1.23 return true;
4131 }
4132
4133
4134 //------------------------------------------------------------------------------
|
4135 kumpf 1.48 // getValueObjectElement()
4136 //
4137 // <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>
4138 //
4139 //------------------------------------------------------------------------------
4140
4141 Boolean XmlReader::getValueObjectElement(
4142 XmlParser& parser,
4143 CIMObject& object)
4144 {
4145 XmlEntry entry;
4146
4147 if (!testStartTag(parser, entry, "VALUE.OBJECT"))
4148 return false;
4149
4150 CIMInstance cimInstance;
4151 CIMClass cimClass;
4152
4153 if (XmlReader::getInstanceElement(parser, cimInstance))
4154 {
4155 object = CIMObject(cimInstance);
4156 kumpf 1.48 }
4157 else if (!XmlReader::getClassElement(parser, cimClass))
4158 {
4159 object = CIMObject(cimClass);
4160 }
4161 else
4162 {
|
4163 humberto 1.85
4164 // l10n
4165
4166 // throw XmlValidationError(parser.getLine(),
4167 // "Expected INSTANCE or CLASS element");
4168
|
4169 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
4170 "Expected INSTANCE or CLASS element");
|
4171 humberto 1.85
4172 throw XmlValidationError(parser.getLine(), mlParms);
4173
|
4174 kumpf 1.48 }
4175
4176 expectEndTag(parser, "VALUE.OBJECT");
4177
4178 return true;
4179 }
4180
4181 //------------------------------------------------------------------------------
4182 // getValueObjectWithPathElement()
|
4183 mike 1.23 //
4184 // <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
4185 //
4186 //------------------------------------------------------------------------------
4187
|
4188 kumpf 1.48 Boolean XmlReader::getValueObjectWithPathElement(
|
4189 mike 1.23 XmlParser& parser,
|
4190 kumpf 1.57 CIMObject& objectWithPath)
|
4191 mike 1.23 {
4192 XmlEntry entry;
4193
4194 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))
4195 return false;
4196
|
4197 kumpf 1.54 CIMObjectPath reference;
|
4198 mike 1.23 Boolean isInstance = false;
4199
4200 if (XmlReader::getInstancePathElement(parser, reference))
4201 isInstance = true;
4202 else if (!XmlReader::getClassPathElement(parser, reference))
4203 {
|
4204 humberto 1.85
|
4205 humberto 1.90 // l10n 485
|
4206 humberto 1.85
4207 // throw XmlValidationError(parser.getLine(),
4208 // "Expected INSTANCEPATH or CLASSPATH element");
4209
|
4210 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
|
4211 humberto 1.90 "Expected INSTANCEPATH or CLASSPATH element");
|
4212 humberto 1.85
4213 throw XmlValidationError(parser.getLine(), mlParms);
|
4214 mike 1.23 }
4215
4216 if (isInstance)
4217 {
4218 CIMInstance cimInstance;
4219
4220 if (!XmlReader::getInstanceElement(parser, cimInstance))
4221 {
|
4222 humberto 1.85
4223 // l10n
4224
4225 // throw XmlValidationError(parser.getLine(),
4226 // "Expected INSTANCE element");
4227
|
4228 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
4229 "Expected INSTANCE element");
|
4230 humberto 1.85
4231 throw XmlValidationError(parser.getLine(), mlParms);
|
4232 mike 1.23 }
|
4233 kumpf 1.57 objectWithPath = CIMObject (cimInstance);
4234 objectWithPath.setPath (reference);
|
4235 mike 1.23 }
4236 else
4237 {
4238 CIMClass cimClass;
4239
4240 if (!XmlReader::getClassElement(parser, cimClass))
4241 {
|
4242 humberto 1.85
4243 // l10n
4244
4245 // throw XmlValidationError(parser.getLine(),
4246 // "Expected CLASS element");
4247
|
4248 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
4249 "Expected CLASS element");
|
4250 humberto 1.85
4251 throw XmlValidationError(parser.getLine(), mlParms);
|
4252 mike 1.23 }
|
4253 kumpf 1.57 objectWithPath = CIMObject (cimClass);
4254 objectWithPath.setPath (reference);
|
4255 mike 1.23 }
4256
4257 expectEndTag(parser, "VALUE.OBJECTWITHPATH");
4258
4259 return true;
|
4260 kumpf 1.48 }
4261
4262 //------------------------------------------------------------------------------
4263 // getValueObjectWithLocalPathElement()
4264 //
4265 // <!ELEMENT VALUE.OBJECTWITHLOCALPATH
4266 // ((LOCALCLASSPATH,CLASS)|(LOCALINSTANCEPATH,INSTANCE))>
4267 //
4268 //------------------------------------------------------------------------------
4269
4270 Boolean XmlReader::getValueObjectWithLocalPathElement(
4271 XmlParser& parser,
|
4272 kumpf 1.57 CIMObject& objectWithPath)
|
4273 kumpf 1.48 {
4274 XmlEntry entry;
4275
4276 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))
4277 return false;
4278
|
4279 kumpf 1.54 CIMObjectPath reference;
|
4280 kumpf 1.48 Boolean isInstance = false;
4281
4282 if (XmlReader::getLocalInstancePathElement(parser, reference))
4283 isInstance = true;
4284 else if (!XmlReader::getLocalClassPathElement(parser, reference))
4285 {
|
4286 humberto 1.85
4287 // l10n
4288
4289 // throw XmlValidationError(parser.getLine(),
4290 // "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");
4291
|
4292 humberto 1.91 //l10n updated
4293 MessageLoaderParms mlParms("Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
4294 MISSING_ELEMENT_LOCALPATH);
|
4295 humberto 1.85
4296 throw XmlValidationError(parser.getLine(), mlParms);
4297
|
4298 kumpf 1.48 }
4299
4300 if (isInstance)
4301 {
4302 CIMInstance cimInstance;
4303
4304 if (!XmlReader::getInstanceElement(parser, cimInstance))
4305 {
|
4306 humberto 1.85
4307 // l10n
4308
4309 // throw XmlValidationError(parser.getLine(),
4310 // "Expected INSTANCE element");
4311
|
4312 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
4313 "Expected INSTANCE element");
|
4314 humberto 1.85
4315 throw XmlValidationError(parser.getLine(), mlParms);
4316
|
4317 kumpf 1.48 }
|
4318 kumpf 1.57 objectWithPath = CIMObject (cimInstance);
4319 objectWithPath.setPath (reference);
|
4320 kumpf 1.48 }
4321 else
4322 {
4323 CIMClass cimClass;
4324
4325 if (!XmlReader::getClassElement(parser, cimClass))
4326 {
|
4327 humberto 1.85
4328 // l10n
4329
4330 // throw XmlValidationError(parser.getLine(),
4331 // "Expected CLASS element");
4332
|
4333 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
4334 "Expected CLASS element");
|
4335 humberto 1.85
4336 throw XmlValidationError(parser.getLine(), mlParms);
4337
4338
|
4339 kumpf 1.48 }
|
4340 kumpf 1.57 objectWithPath = CIMObject (cimClass);
4341 objectWithPath.setPath (reference);
|
4342 kumpf 1.48 }
4343
4344 expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");
4345
4346 return true;
4347 }
4348
4349 //------------------------------------------------------------------------------
4350 // getObjectArray()
4351 //
4352 // <object>
4353 // (VALUE.OBJECT|VALUE.OBJECTWITHLOCALPATH|VALUE.OBJECTWITHPATH)
4354 //
4355 //------------------------------------------------------------------------------
4356
4357 void XmlReader::getObjectArray(
4358 XmlParser& parser,
|
4359 kumpf 1.57 Array<CIMObject>& objectArray)
|
4360 kumpf 1.48 {
4361 CIMObject object;
|
4362 kumpf 1.57 CIMObject objectWithPath;
|
4363 kumpf 1.48
4364 objectArray.clear();
4365
4366 if (getValueObjectElement(parser, object))
4367 {
|
4368 kumpf 1.57 objectArray.append(object);
|
4369 kumpf 1.48 while (getValueObjectElement(parser, object))
|
4370 kumpf 1.57 objectArray.append(object);
|
4371 kumpf 1.48 }
4372 else if (getValueObjectWithPathElement(parser, objectWithPath))
4373 {
4374 objectArray.append(objectWithPath);
4375 while (getValueObjectWithPathElement(parser, objectWithPath))
4376 objectArray.append(objectWithPath);
4377 }
4378 else if (getValueObjectWithLocalPathElement(parser, objectWithPath))
4379 {
4380 objectArray.append(objectWithPath);
4381 while (getValueObjectWithLocalPathElement(parser, objectWithPath))
4382 objectArray.append(objectWithPath);
4383 }
|
4384 mike 1.23 }
4385
4386 //------------------------------------------------------------------------------
4387 //
4388 // <objectName>: (CLASSNAME|INSTANCENAME)
4389 //
4390 //------------------------------------------------------------------------------
4391
4392 Boolean XmlReader::getObjectNameElement(
4393 XmlParser& parser,
|
4394 kumpf 1.54 CIMObjectPath& objectName)
|
4395 mike 1.23 {
|
4396 kumpf 1.74 CIMName className;
|
4397 mike 1.23
4398 if (getClassNameElement(parser, className, false))
4399 {
|
4400 kumpf 1.62 objectName.set(String(), CIMNamespaceName(), className);
|
4401 mike 1.23 return true;
4402 }
4403 else if (getInstanceNameElement(parser, objectName))
4404 return true;
4405 else
4406 {
|
4407 humberto 1.85
4408 // l10n
4409
4410 // throw XmlValidationError(parser.getLine(),
4411 // "expected CLASSNAME or INSTANCENAME element");
4412
|
4413 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",
4414 "Expected CLASSNAME or INSTANCENAME element");
|
4415 humberto 1.85
4416 throw XmlValidationError(parser.getLine(), mlParms);
4417
|
4418 mike 1.23 }
4419
4420 return false;
4421 }
4422
4423 //------------------------------------------------------------------------------
4424 //
4425 // <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>
4426 //
4427 //------------------------------------------------------------------------------
4428
4429 Boolean XmlReader::getObjectPathElement(
4430 XmlParser& parser,
|
4431 kumpf 1.54 CIMObjectPath& objectPath)
|
4432 mike 1.23 {
4433 XmlEntry entry;
4434
4435 if (!testStartTag(parser, entry, "OBJECTPATH"))
4436 return false;
4437
4438 if (getClassPathElement(parser, objectPath))
4439 {
4440 expectEndTag(parser, "OBJECTPATH");
4441 return true;
4442 }
4443 else if (getInstancePathElement(parser, objectPath))
4444 {
4445 expectEndTag(parser, "OBJECTPATH");
4446 return true;
4447 }
4448 else
4449 {
|
4450 humberto 1.85
4451 // l10n
4452
4453 // throw XmlValidationError(parser.getLine(),
4454 // "expected INSTANCEPATH or CLASSPATH element");
4455
|
4456 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
4457 "expected INSTANCEPATH or CLASSPATH element");
|
4458 humberto 1.85
4459 throw XmlValidationError(parser.getLine(), mlParms);
|
4460 mike 1.23 }
4461
|
4462 mike 1.24 PEGASUS_UNREACHABLE ( return false; )
|
4463 mike 1.25 }
4464
4465 //------------------------------------------------------------------------------
4466 //
4467 // getEMethodCallStartTag()
4468 //
4469 //------------------------------------------------------------------------------
4470
4471 Boolean XmlReader::getEMethodCallStartTag(
4472 XmlParser& parser,
4473 const char*& name)
4474 {
4475 XmlEntry entry;
4476
4477 if (!testStartTag(parser, entry, "EXPMETHODCALL"))
4478 return false;
4479
4480 // Get EXPMETHODCALL.NAME attribute:
4481
|
4482 humberto 1.85
4483 if (!entry.getAttributeValue("NAME", name)) {
4484
4485 // l10n
4486
4487 // throw XmlValidationError(parser.getLine(),
4488 // "Missing EXPMETHODCALL.NAME attribute");
4489
|
4490 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",
4491 "Missing EXPMETHODCALL.NAME attribute");
|
4492 humberto 1.85
4493 throw XmlValidationError(parser.getLine(), mlParms);
4494 }
|
4495 mike 1.25
4496 return true;
4497 }
4498
4499 //------------------------------------------------------------------------------
4500 //
4501 // getEMethodResponseStartTag()
4502 //
4503 //------------------------------------------------------------------------------
4504
4505 Boolean XmlReader::getEMethodResponseStartTag(
4506 XmlParser& parser,
|
4507 kumpf 1.101 const char*& name,
4508 Boolean& isEmptyTag)
|
4509 mike 1.25 {
4510 XmlEntry entry;
4511
|
4512 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "EXPMETHODRESPONSE"))
|
4513 mike 1.25 return false;
4514
|
4515 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
4516
|
4517 mike 1.25 // Get EXPMETHODRESPONSE.NAME attribute:
4518
|
4519 humberto 1.85
4520 if (!entry.getAttributeValue("NAME", name)) {
4521 // l10n
4522
4523 // throw XmlValidationError(
4524 // parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute");
4525
|
4526 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",
4527 "Missing EXPMETHODRESPONSE.NAME attribute");
|
4528 humberto 1.85
4529 throw XmlValidationError(parser.getLine(), mlParms);
4530 }
|
4531 mike 1.25
4532 return true;
4533 }
4534
4535 //------------------------------------------------------------------------------
4536 //
|
4537 kumpf 1.83 // getEParamValueTag()
4538 //
4539 //------------------------------------------------------------------------------
4540
4541 Boolean XmlReader::getEParamValueTag(
4542 XmlParser& parser,
4543 const char*& name)
4544 {
4545 XmlEntry entry;
4546
4547 if (!testStartTag(parser, entry, "EXPPARAMVALUE"))
4548 return false;
4549
4550 // Get EXPPARAMVALUE.NAME attribute:
4551
|
4552 humberto 1.85
4553 if (!entry.getAttributeValue("NAME", name)) {
4554
4555 // l10n
4556
4557 // throw XmlValidationError(parser.getLine(),
4558 // "Missing EXPPARAMVALUE.NAME attribute");
4559
|
4560 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",
4561 "Missing EXPPARAMVALUE.NAME attribute");
|
4562 humberto 1.85
4563 throw XmlValidationError(parser.getLine(), mlParms);
4564 }
4565
4566
|
4567 kumpf 1.83
4568 return true;
4569 }
4570
4571 //------------------------------------------------------------------------------
4572 //
|
4573 mike 1.25 // getMethodCallStartTag()
4574 //
4575 //------------------------------------------------------------------------------
4576
4577 Boolean XmlReader::getMethodCallStartTag(
4578 XmlParser& parser,
4579 const char*& name)
4580 {
4581 XmlEntry entry;
4582
4583 if (!testStartTag(parser, entry, "METHODCALL"))
4584 return false;
4585
4586 // Get METHODCALL.NAME attribute:
4587
|
4588 humberto 1.85
4589 if (!entry.getAttributeValue("NAME", name)) {
4590
4591 // l10n
4592
4593 // throw XmlValidationError(parser.getLine(),
4594 // "Missing METHODCALL.NAME attribute");
4595
|
4596 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",
4597 "Missing METHODCALL.NAME attribute");
|
4598 humberto 1.85
4599 throw XmlValidationError(parser.getLine(), mlParms);
4600 }
4601
|
4602 mike 1.25
4603 return true;
4604 }
4605
4606 //------------------------------------------------------------------------------
4607 //
4608 // getMethodResponseStartTag()
4609 //
4610 //------------------------------------------------------------------------------
4611
4612 Boolean XmlReader::getMethodResponseStartTag(
4613 XmlParser& parser,
|
4614 kumpf 1.101 const char*& name,
4615 Boolean& isEmptyTag)
|
4616 mike 1.25 {
4617 XmlEntry entry;
4618
|
4619 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "METHODRESPONSE"))
|
4620 mike 1.25 return false;
4621
|
4622 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
4623
|
4624 mike 1.25 // Get METHODRESPONSE.NAME attribute:
4625
|
4626 humberto 1.85
4627 if (!entry.getAttributeValue("NAME", name)) {
4628
4629 // l10n
4630
4631 // throw XmlValidationError(parser.getLine(),
4632 // "Missing METHODRESPONSE.NAME attribute");
4633
|
4634 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",
4635 "Missing METHODRESPONSE.NAME attribute");
|
4636 humberto 1.85
4637 throw XmlValidationError(parser.getLine(), mlParms);
4638 }
|
4639 mike 1.25
4640 return true;
4641 }
4642
4643 //------------------------------------------------------------------------------
4644 //
|
4645 kumpf 1.26 // getParamValueElement()
4646 //
4647 // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
4648 // <!ATTLIST PARAMVALUE
4649 // %CIMName;
4650 // %ParamType;>
|
4651 mike 1.25 //
4652 //------------------------------------------------------------------------------
4653
|
4654 kumpf 1.26 Boolean XmlReader::getParamValueElement(
|
4655 mike 1.25 XmlParser& parser,
|
4656 kumpf 1.26 CIMParamValue& paramValue)
|
4657 mike 1.25 {
4658 XmlEntry entry;
|
4659 kumpf 1.26 const char* name;
|
4660 marek 1.100 CIMType type=CIMTYPE_BOOLEAN;
|
4661 kumpf 1.26 CIMValue value;
|
4662 mike 1.25
|
4663 kumpf 1.26 if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))
|
4664 mike 1.25 return false;
4665
|
4666 kumpf 1.26 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
4667
4668 // Get PARAMVALUE.NAME attribute:
|
4669 mike 1.25
|
4670 humberto 1.85 if (!entry.getAttributeValue("NAME", name)) {
4671
4672 // l10n
4673
4674 // throw XmlValidationError(parser.getLine(),
4675 // "Missing PARAMVALUE.NAME attribute");
4676
|
4677 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",
4678 "Missing PARAMVALUE.NAME attribute");
|
4679 humberto 1.85
4680 throw XmlValidationError(parser.getLine(), mlParms);
4681 }
4682
|
4683 kumpf 1.26
4684 // Get PARAMVALUE.PARAMTYPE attribute:
4685
|
4686 kumpf 1.67 Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,
4687 "PARAMVALUE", "PARAMTYPE", false);
|
4688 kumpf 1.26
4689 if (!empty)
4690 {
4691 // Parse VALUE.REFERENCE and VALUE.REFARRAY type
|
4692 kumpf 1.67 if ( (type == CIMTYPE_REFERENCE) || !gotType )
|
4693 kumpf 1.26 {
|
4694 kumpf 1.54 CIMObjectPath reference;
|
4695 kumpf 1.26 if (XmlReader::getValueReferenceElement(parser, reference))
4696 {
4697 value.set(reference);
|
4698 kumpf 1.61 type = CIMTYPE_REFERENCE;
|
4699 kumpf 1.67 gotType = true;
|
4700 kumpf 1.26 }
|
4701 kumpf 1.28 else if (XmlReader::getValueReferenceArrayElement(parser, value))
4702 {
|
4703 kumpf 1.61 type = CIMTYPE_REFERENCE;
|
4704 kumpf 1.67 gotType = true;
|
4705 kumpf 1.28 }
|
4706 kumpf 1.27 // If type==reference but no VALUE.REFERENCE found, use null value
|
4707 kumpf 1.26 }
4708
4709 // Parse non-reference value
|
4710 kumpf 1.61 if ( type != CIMTYPE_REFERENCE )
|
4711 kumpf 1.26 {
|
4712 kumpf 1.67 CIMType effectiveType;
4713 if (!gotType)
|
4714 kumpf 1.26 {
|
4715 kumpf 1.67 // If we don't know what type the value is, read it as a String
|
4716 kumpf 1.61 effectiveType = CIMTYPE_STRING;
|
4717 kumpf 1.26 }
|
4718 kumpf 1.67 else
4719 {
4720 effectiveType = type;
4721 }
|
4722 kumpf 1.26
4723 if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&
4724 !XmlReader::getValueElement(parser, effectiveType, value) )
4725 {
4726 value.clear(); // Isn't necessary; should already be cleared
4727 }
4728 }
4729
4730 expectEndTag(parser, "PARAMVALUE");
4731 }
4732
|
4733 kumpf 1.67 paramValue = CIMParamValue(name, value, gotType);
|
4734 kumpf 1.27
4735 return true;
4736 }
4737
4738 //------------------------------------------------------------------------------
4739 //
4740 // getReturnValueElement()
4741 //
4742 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
4743 // <!ATTLIST RETURNVALUE
4744 // %ParamType;>
4745 //
4746 //------------------------------------------------------------------------------
4747
4748 Boolean XmlReader::getReturnValueElement(
4749 XmlParser& parser,
4750 CIMValue& returnValue)
4751 {
4752 XmlEntry entry;
4753 CIMType type;
4754 CIMValue value;
4755 kumpf 1.27
4756 if (!testStartTag(parser, entry, "RETURNVALUE"))
4757 return false;
4758
4759 // Get RETURNVALUE.PARAMTYPE attribute:
4760 // NOTE: Array type return values are not allowed (2/20/02)
4761
|
4762 kumpf 1.67 Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,
4763 "RETURNVALUE", "PARAMTYPE", false);
|
4764 kumpf 1.27
4765 // Parse VALUE.REFERENCE type
|
4766 kumpf 1.67 if ( (type == CIMTYPE_REFERENCE) || !gotType )
|
4767 kumpf 1.27 {
|
4768 kumpf 1.54 CIMObjectPath reference;
|
4769 kumpf 1.27 if (XmlReader::getValueReferenceElement(parser, reference))
4770 {
4771 returnValue.set(reference);
|
4772 kumpf 1.61 type = CIMTYPE_REFERENCE;
|
4773 kumpf 1.67 gotType = true;
|
4774 kumpf 1.27 }
|
4775 kumpf 1.61 else if (type == CIMTYPE_REFERENCE)
|
4776 kumpf 1.27 {
|
4777 humberto 1.85
4778 // l10n
4779
4780 // throw XmlValidationError(parser.getLine(),
4781 // "expected VALUE.REFERENCE element");
4782
|
4783 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",
4784 "expected VALUE.REFERENCE element");
|
4785 humberto 1.85
4786 throw XmlValidationError(parser.getLine(), mlParms);
|
4787 kumpf 1.27 }
4788 }
4789
4790 // Parse non-reference return value
|
4791 kumpf 1.61 if ( type != CIMTYPE_REFERENCE )
|
4792 kumpf 1.27 {
|
4793 kumpf 1.67 if (!gotType)
|
4794 kumpf 1.27 {
|
4795 kumpf 1.67 // If we don't know what type the value is, read it as a String
|
4796 kumpf 1.61 type = CIMTYPE_STRING;
|
4797 kumpf 1.27 }
4798
4799 if ( !XmlReader::getValueElement(parser, type, returnValue) )
4800 {
|
4801 humberto 1.85
4802 // l10n
4803
4804 // throw XmlValidationError(parser.getLine(),
4805 // "expected VALUE element");
4806
|
4807 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
4808 "expected VALUE element");
|
4809 humberto 1.85
4810 throw XmlValidationError(parser.getLine(), mlParms);
|
4811 kumpf 1.27 }
4812 }
4813
4814 expectEndTag(parser, "RETURNVALUE");
|
4815 mike 1.25
4816 return true;
|
4817 mike 1.23 }
4818
4819 PEGASUS_NAMESPACE_END
|
4820 s.hills 1.93
|
Return to
XmlReader.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common