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 if (!testStartTag(parser, entry, "QUALIFIER"))
2012 return false;
2013
2014 // Get QUALIFIER.NAME attribute:
2015
|
2016 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
|
2017 mike 1.23
2018 // Get QUALIFIER.TYPE attribute:
2019
|
2020 kumpf 1.67 CIMType type;
2021 getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER");
|
2022 mike 1.23
2023 // Get QUALIFIER.PROPAGATED
2024
2025 Boolean propagated = getCimBooleanAttribute(
2026 parser.getLine(), entry, "QUALIFIER", "PROPAGATED", false, false);
2027
2028 // Get flavor oriented attributes:
2029
|
2030 kumpf 1.64 CIMFlavor flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");
|
2031 mike 1.23
2032 // Get VALUE or VALUE.ARRAY element:
2033
2034 CIMValue value;
2035
2036 if (!getValueElement(parser, type, value) &&
2037 !getValueArrayElement(parser, type, value))
2038 {
|
2039 kumpf 1.52 value.setNullValue(type, false);
|
2040 mike 1.23 }
2041
2042 // Expect </QUALIFIER>:
2043
2044 expectEndTag(parser, "QUALIFIER");
2045
2046 // Build qualifier:
2047
2048 qualifier = CIMQualifier(name, value, flavor, propagated);
2049 return true;
2050 }
2051
2052 //------------------------------------------------------------------------------
2053 //
2054 // getQualifierElements()
2055 //
2056 //------------------------------------------------------------------------------
2057
2058 template<class CONTAINER>
2059 void getQualifierElements(XmlParser& parser, CONTAINER& container)
2060 {
2061 mike 1.23 CIMQualifier qualifier;
2062
2063 while (XmlReader::getQualifierElement(parser, qualifier))
2064 {
2065 try
2066 {
2067 container.addQualifier(qualifier);
2068 }
|
2069 kumpf 1.66 catch (AlreadyExistsException&)
|
2070 mike 1.23 {
|
2071 humberto 1.85
2072 // l10n
2073
2074 // throw XmlSemanticError(parser.getLine(), "duplicate qualifier");
2075
|
2076 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_QUALIFIER",
2077 "duplicate qualifier");
|
2078 humberto 1.85
2079 throw XmlSemanticError(parser.getLine(), mlParms);
|
2080 mike 1.23 }
2081 }
2082 }
2083
2084 //------------------------------------------------------------------------------
2085 //
2086 // getPropertyElement()
2087 //
2088 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
2089 // <!ATTLIST PROPERTY
2090 // %CIMName;
2091 // %ClassOrigin;
2092 // %Propagated;
2093 // %CIMType; #REQUIRED>
2094 //
2095 //------------------------------------------------------------------------------
2096
2097 Boolean XmlReader::getPropertyElement(XmlParser& parser, CIMProperty& property)
2098 {
2099 XmlEntry entry;
2100
2101 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY"))
2102 return false;
2103
2104 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2105
2106 // Get PROPERTY.NAME attribute:
2107
|
2108 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
|
2109 mike 1.23
2110 // Get PROPERTY.CLASSORIGIN attribute:
2111
|
2112 kumpf 1.62 CIMName classOrigin =
|
2113 mike 1.23 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
2114
2115 // Get PROPERTY.PROPAGATED
2116
2117 Boolean propagated = getCimBooleanAttribute(
2118 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
2119
2120 // Get PROPERTY.TYPE attribute:
2121
|
2122 kumpf 1.67 CIMType type;
2123 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");
|
2124 mike 1.23
|
2125 karl 1.35 // Create property: Sets type and !isarray
|
2126 mike 1.23
|
2127 kumpf 1.56 CIMValue value(type, false);
|
2128 kumpf 1.62 property = CIMProperty(name, value, 0, CIMName(), classOrigin, propagated);
|
2129 mike 1.23
2130 if (!empty)
2131 {
2132 // Get qualifiers:
2133
2134 getQualifierElements(parser, property);
2135
|
2136 karl 1.35 // Get value: Insert value if getValueElement exists (returns True)
|
2137 mike 1.23
2138 if (getValueElement(parser, type, value))
2139 property.setValue(value);
2140
2141 expectEndTag(parser, "PROPERTY");
2142 }
2143
2144 return true;
2145 }
2146
2147 //------------------------------------------------------------------------------
2148 //
2149 // getArraySizeAttribute()
2150 //
2151 // Returns true if able to get array-size. Note that array size will
2152 // always be a positive integer.
2153 //
2154 // <!ENTITY % ArraySize "ARRAYSIZE CDATA #IMPLIED">
2155 //
2156 //------------------------------------------------------------------------------
2157
2158 mike 1.23 Boolean XmlReader::getArraySizeAttribute(
2159 Uint32 lineNumber,
2160 const XmlEntry& entry,
2161 const char* tagName,
2162 Uint32& value)
2163 {
2164 const char* tmp;
2165
2166 if (!entry.getAttributeValue("ARRAYSIZE", tmp))
2167 return false;
2168
2169 Uint64 arraySize;
2170
2171 if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)
2172 {
|
2173 humberto 1.85 // l10n
2174
2175 // char message[128];
2176 // sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");
2177 // throw XmlSemanticError(lineNumber, message);
2178
2179 char message[128];
2180 sprintf(message, "%s.%s", tagName, "ARRAYSIZE");
2181
2182 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE",
2183 "Illegal value for $0",
2184 message);
2185
2186 throw XmlSemanticError(lineNumber, mlParms);
|
2187 mike 1.23 }
2188
2189 value = Uint32(arraySize);
2190 return true;
2191 }
2192
2193 //------------------------------------------------------------------------------
2194 //
2195 // getPropertyArrayElement()
2196 //
2197 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
2198 // <!ATTLIST PROPERTY.ARRAY
2199 // %CIMName;
2200 // %CIMType; #REQUIRED
2201 // %ArraySize;
2202 // %ClassOrigin;
2203 // %Propagated;>
2204 //
2205 //------------------------------------------------------------------------------
2206
2207 Boolean XmlReader::getPropertyArrayElement(
2208 mike 1.23 XmlParser& parser,
2209 CIMProperty& property)
2210 {
2211 // Get PROPERTY element:
2212
2213 XmlEntry entry;
2214
2215 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.ARRAY"))
2216 return false;
2217
2218 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2219
2220 // Get PROPERTY.NAME attribute:
2221
|
2222 kumpf 1.74 CIMName name =
|
2223 mike 1.23 getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
2224
2225 // Get PROPERTY.TYPE attribute:
2226
|
2227 kumpf 1.67 CIMType type;
2228 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY.ARRAY");
|
2229 mike 1.23
2230 // Get PROPERTY.ARRAYSIZE attribute:
2231
2232 Uint32 arraySize = 0;
2233 getArraySizeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY", arraySize);
2234
2235 // Get PROPERTY.CLASSORIGIN attribute:
2236
|
2237 kumpf 1.62 CIMName classOrigin
|
2238 mike 1.23 = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
2239
2240 // Get PROPERTY.ARRAY.PROPAGATED
2241
2242 Boolean propagated = getCimBooleanAttribute(
2243 parser.getLine(), entry, "PROPERTY.ARRAY", "PROPAGATED", false, false);
2244
2245 // Create property:
2246
|
2247 kumpf 1.56 CIMValue value(type, true, arraySize);
|
2248 mike 1.23 property = CIMProperty(
|
2249 kumpf 1.62 name, value, arraySize, CIMName(), classOrigin, propagated);
|
2250 mike 1.23
2251 if (!empty)
2252 {
2253 // Get qualifiers:
2254
2255 getQualifierElements(parser, property);
2256
2257 // Get value:
2258
2259 if (getValueArrayElement(parser, type, value))
2260 {
2261 if (arraySize && arraySize != value.getArraySize())
2262 {
|
2263 humberto 1.85
2264 // l10n
2265
2266 // throw XmlSemanticError(parser.getLine(),
2267 // "ARRAYSIZE attribute and value-array size are different");
2268
2269 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT",
|
2270 humberto 1.87 "ARRAYSIZE attribute and value-array size are different");
|
2271 humberto 1.85
2272 throw XmlSemanticError(parser.getLine(), mlParms);
|
2273 mike 1.23 }
2274
2275 property.setValue(value);
2276 }
2277
2278 expectEndTag(parser, "PROPERTY.ARRAY");
2279 }
2280
2281 return true;
2282 }
2283
2284 //------------------------------------------------------------------------------
2285 //
2286 // getHostElement()
2287 //
2288 // <!ELEMENT HOST (#PCDATA)>
2289 //
2290 //------------------------------------------------------------------------------
2291
2292 Boolean XmlReader::getHostElement(
2293 XmlParser& parser,
2294 mike 1.23 String& host)
2295 {
2296 XmlEntry entry;
2297
2298 if (!testStartTag(parser, entry, "HOST"))
2299 return false;
|
2300 karl 1.78 #ifdef PEGASUS_SNIA_INTEROP_TEST
2301 // Temp code to allow empty HOST field.
2302 // SNIA CIMOMs return empty field particularly on enumerateinstance.
2303 // Simply substitute a string for the empty.
2304 if (!parser.next(entry))
2305 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
2306
2307 if (entry.type == XmlEntry::CONTENT)
|
2308 chuck 1.98 host = String(entry.text);
|
2309 karl 1.78 else
2310 {
2311 parser.putBack(entry);
2312 host = "HOSTNAMEINSERTEDBYPEGASUSCLIENT";
2313 }
2314
2315 #else
|
2316 mike 1.23
2317 if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)
2318 {
|
2319 humberto 1.85
2320 // l10n
2321
2322 // throw XmlValidationError(parser.getLine(),
2323 // "expected content of HOST element");
2324
2325 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT",
|
2326 humberto 1.87 "expected content of HOST element");
|
2327 humberto 1.85
2328 throw XmlValidationError(parser.getLine(), mlParms);
2329
|
2330 mike 1.23 }
2331
|
2332 chuck 1.98 host = String(entry.text);
|
2333 karl 1.78 #endif
|
2334 mike 1.23 expectEndTag(parser, "HOST");
2335 return true;
2336 }
2337
2338 //------------------------------------------------------------------------------
2339 //
2340 // getNameSpaceElement()
2341 //
2342 // <!ELEMENT NAMESPACE EMPTY>
2343 // <!ATTLIST NAMESPACE %CIMName;>
2344 //
2345 //------------------------------------------------------------------------------
2346
2347 Boolean XmlReader::getNameSpaceElement(
2348 XmlParser& parser,
|
2349 kumpf 1.74 CIMName& nameSpaceComponent)
|
2350 mike 1.23 {
2351 XmlEntry entry;
2352
2353 if (!testStartTagOrEmptyTag(parser, entry, "NAMESPACE"))
2354 return false;
2355
2356 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2357
2358 nameSpaceComponent = getCimNameAttribute(
2359 parser.getLine(), entry, "NAMESPACE");
2360
2361 if (!empty)
2362 expectEndTag(parser, "NAMESPACE");
2363
2364 return true;
2365 }
2366
2367 //------------------------------------------------------------------------------
2368 //
2369 // getLocalNameSpacePathElement()
2370 //
2371 mike 1.23 // <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
2372 //
2373 //------------------------------------------------------------------------------
2374
2375 Boolean XmlReader::getLocalNameSpacePathElement(
2376 XmlParser& parser,
2377 String& nameSpace)
2378 {
2379 XmlEntry entry;
2380
2381 if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))
2382 return false;
2383
|
2384 kumpf 1.74 CIMName nameSpaceComponent;
|
2385 mike 1.23
2386 while (getNameSpaceElement(parser, nameSpaceComponent))
2387 {
2388 if (nameSpace.size())
|
2389 kumpf 1.71 nameSpace.append('/');
|
2390 mike 1.23
|
2391 kumpf 1.74 nameSpace.append(nameSpaceComponent.getString());
|
2392 mike 1.23 }
2393
2394 if (!nameSpace.size())
2395 {
|
2396 humberto 1.85
2397 // l10n
2398
2399 // throw XmlValidationError(parser.getLine(),
2400 // "Expected one or more NAMESPACE elements within "
2401 // "LOCALNAMESPACEPATH element");
2402
2403 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",
|
2404 humberto 1.87 "Expected one or more NAMESPACE elements within LOCALNAMESPACEPATH element");
|
2405 humberto 1.85
2406 throw XmlValidationError(parser.getLine(), mlParms);
2407
2408
|
2409 mike 1.23 }
2410
2411 expectEndTag(parser, "LOCALNAMESPACEPATH");
2412 return true;
2413 }
2414
2415 //------------------------------------------------------------------------------
2416 //
2417 // getNameSpacePathElement()
2418 //
2419 // <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
2420 //
2421 //------------------------------------------------------------------------------
2422
2423 Boolean XmlReader::getNameSpacePathElement(
2424 XmlParser& parser,
2425 String& host,
2426 String& nameSpace)
2427 {
2428 host.clear();
2429 nameSpace.clear();
2430 mike 1.23
2431 XmlEntry entry;
2432
2433 if (!testStartTag(parser, entry, "NAMESPACEPATH"))
2434 return false;
2435
|
2436 humberto 1.85 if (!getHostElement(parser, host)) {
2437
2438 // l10n
2439
2440 // throw XmlValidationError(parser.getLine(), "expected HOST element");
2441
|
2442 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_HOST_ELEMENT",
2443 "expected HOST element");
|
2444 humberto 1.85
2445 throw XmlValidationError(parser.getLine(), mlParms);
2446 }
|
2447 mike 1.23
2448 if (!getLocalNameSpacePathElement(parser, nameSpace))
2449 {
|
2450 humberto 1.85
2451 // l10n
2452
2453 // throw XmlValidationError(parser.getLine(),
2454 // "expected LOCALNAMESPACEPATH element");
2455
|
2456 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2457 "expected LOCALNAMESPACEPATH element");
|
2458 humberto 1.85
2459 throw XmlValidationError(parser.getLine(), mlParms);
|
2460 mike 1.23 }
2461
2462 expectEndTag(parser, "NAMESPACEPATH");
2463
2464 return true;
2465 }
2466
2467 //------------------------------------------------------------------------------
2468 //
2469 // getClassNameElement()
2470 //
2471 // <!ELEMENT CLASSNAME EMPTY>
2472 // <!ATTLIST CLASSNAME %CIMName;>
2473 //
2474 //------------------------------------------------------------------------------
2475
2476 Boolean XmlReader::getClassNameElement(
2477 XmlParser& parser,
|
2478 kumpf 1.74 CIMName& className,
|
2479 mike 1.23 Boolean required)
2480 {
2481 XmlEntry entry;
2482
2483 if (!testStartTagOrEmptyTag(parser, entry, "CLASSNAME"))
2484 {
2485 if (required)
2486 {
|
2487 humberto 1.85
2488 // l10n
2489
2490 // throw XmlValidationError(parser.getLine(),
2491 // "expected CLASSNAME element");
2492
|
2493 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2494 "expected CLASSNAME element");
|
2495 humberto 1.85
2496 throw XmlValidationError(parser.getLine(), mlParms);
|
2497 mike 1.23 }
2498 else
2499 return false;
2500 }
2501 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2502
2503 className = getCimNameAttribute(
|
2504 kumpf 1.81 parser.getLine(), entry, "CLASSNAME", false);
|
2505 mike 1.23
2506 if (!empty)
2507 expectEndTag(parser, "CLASSNAME");
2508
2509 return true;
2510 }
2511
2512 //------------------------------------------------------------------------------
2513 //
2514 // getValueTypeAttribute()
2515 //
2516 // VALUETYPE (string|boolean|numeric) 'string'
2517 //
2518 //------------------------------------------------------------------------------
2519
|
2520 kumpf 1.73 CIMKeyBinding::Type XmlReader::getValueTypeAttribute(
|
2521 mike 1.23 Uint32 lineNumber,
2522 const XmlEntry& entry,
2523 const char* elementName)
2524 {
2525 String tmp;
2526
2527 if (!entry.getAttributeValue("VALUETYPE", tmp))
|
2528 kumpf 1.73 return CIMKeyBinding::STRING;
|
2529 mike 1.23
2530 if (String::equal(tmp, "string"))
|
2531 kumpf 1.73 return CIMKeyBinding::STRING;
|
2532 mike 1.23 else if (String::equal(tmp, "boolean"))
|
2533 kumpf 1.73 return CIMKeyBinding::BOOLEAN;
|
2534 mike 1.23 else if (String::equal(tmp, "numeric"))
|
2535 kumpf 1.73 return CIMKeyBinding::NUMERIC;
|
2536 mike 1.23
|
2537 humberto 1.85 // char buffer[MESSAGE_SIZE];
2538
2539 // sprintf(buffer,
2540 // "Illegal value for %s.VALUETYPE attribute; "
2541 // "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",
2542 // elementName);
2543
2544 // throw XmlSemanticError(lineNumber, buffer);
2545
2546
|
2547 mike 1.23 char buffer[MESSAGE_SIZE];
|
2548 humberto 1.85 sprintf(buffer, "%s.VALUETYPE", elementName);
2549
2550 MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",
|
2551 humberto 1.87 "Illegal value for $0 attribute; CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", buffer);
|
2552 humberto 1.85
2553 throw XmlSemanticError(lineNumber, mlParms);
|
2554 mike 1.23
|
2555 kumpf 1.73 return CIMKeyBinding::BOOLEAN;
|
2556 mike 1.23 }
2557
2558 //------------------------------------------------------------------------------
2559 //
2560 // getKeyValueElement()
2561 //
2562 // <!ELEMENT KEYVALUE (#PCDATA)>
2563 // <!ATTLIST KEYVALUE
2564 // VALUETYPE (string|boolean|numeric) 'string'>
2565 //
2566 //------------------------------------------------------------------------------
2567
2568 Boolean XmlReader::getKeyValueElement(
2569 XmlParser& parser,
|
2570 kumpf 1.73 CIMKeyBinding::Type& type,
|
2571 mike 1.23 String& value)
2572 {
2573 XmlEntry entry;
2574
2575 if (!testStartTagOrEmptyTag(parser, entry, "KEYVALUE"))
2576 return false;
2577
2578 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2579
2580 type = getValueTypeAttribute(parser.getLine(), entry, "KEYVALUE");
2581
2582 value.clear();
2583
2584 if (!empty)
2585 {
2586 if (!parser.next(entry))
2587 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
2588
2589 if (entry.type == XmlEntry::CONTENT)
|
2590 chuck 1.98 value = String(entry.text);
|
2591 mike 1.23 else
2592 parser.putBack(entry);
2593
2594 expectEndTag(parser, "KEYVALUE");
2595 }
2596
2597 return true;
2598 }
2599
2600 //------------------------------------------------------------------------------
2601 //
2602 // getKeyBindingElement()
2603 //
2604 // <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>
2605 // <!ATTLIST KEYBINDING
2606 // %CIMName;>
2607 //
2608 //------------------------------------------------------------------------------
2609
2610 Boolean XmlReader::getKeyBindingElement(
2611 XmlParser& parser,
|
2612 kumpf 1.74 CIMName& name,
|
2613 mike 1.23 String& value,
|
2614 kumpf 1.73 CIMKeyBinding::Type& type)
|
2615 mike 1.23 {
2616 XmlEntry entry;
2617
2618 if (!testStartTag(parser, entry, "KEYBINDING"))
2619 return false;
2620
2621 name = getCimNameAttribute(parser.getLine(), entry, "KEYBINDING");
2622
2623 if (!getKeyValueElement(parser, type, value))
|
2624 mike 1.25 {
|
2625 kumpf 1.54 CIMObjectPath reference;
|
2626 mike 1.25
2627 if (!getValueReferenceElement(parser, reference))
2628 {
|
2629 humberto 1.85
2630 // l10n
2631
2632 // throw XmlValidationError(parser.getLine(),
2633 // "Expected KEYVALUE or VALUE.REFERENCE element");
2634
|
2635 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",
2636 "Expected KEYVALUE or VALUE.REFERENCE element");
|
2637 humberto 1.85
2638 throw XmlValidationError(parser.getLine(), mlParms);
|
2639 mike 1.25 }
2640
|
2641 kumpf 1.73 type = CIMKeyBinding::REFERENCE;
|
2642 mike 1.25 value = reference.toString();
2643 }
|
2644 mike 1.23
2645 expectEndTag(parser, "KEYBINDING");
2646 return true;
2647 }
2648
2649 //------------------------------------------------------------------------------
2650 //
2651 // getInstanceNameElement()
2652 //
2653 // <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
2654 // <!ATTLIST INSTANCENAME
2655 // %ClassName;>
2656 //
|
2657 mike 1.25 // Note: An empty key name is used in the keyBinding when the INSTANCENAME is
2658 // specified using a KEYVALUE or a VALUE.REFERENCE.
|
2659 mike 1.23 //
2660 //------------------------------------------------------------------------------
2661
2662 Boolean XmlReader::getInstanceNameElement(
2663 XmlParser& parser,
2664 String& className,
|
2665 kumpf 1.73 Array<CIMKeyBinding>& keyBindings)
|
2666 mike 1.23 {
2667 className.clear();
2668 keyBindings.clear();
2669
2670 XmlEntry entry;
2671
2672 if (!testStartTagOrEmptyTag(parser, entry, "INSTANCENAME"))
2673 return false;
2674
2675 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
2676
2677 className = getClassNameAttribute(parser.getLine(), entry, "INSTANCENAME");
2678
|
2679 mike 1.25 if (empty)
|
2680 mike 1.23 {
|
2681 mike 1.25 return true;
2682 }
|
2683 mike 1.23
|
2684 kumpf 1.74 CIMName name;
|
2685 kumpf 1.73 CIMKeyBinding::Type type;
|
2686 mike 1.25 String value;
|
2687 kumpf 1.54 CIMObjectPath reference;
|
2688 mike 1.25
2689 if (getKeyValueElement(parser, type, value))
2690 {
2691 // Use empty key name because none was specified
|
2692 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2693 mike 1.25 }
2694 else if (getValueReferenceElement(parser, reference))
2695 {
2696 // Use empty key name because none was specified
|
2697 kumpf 1.73 type = CIMKeyBinding::REFERENCE;
|
2698 mike 1.25 value = reference.toString();
|
2699 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2700 mike 1.25 }
2701 else
2702 {
|
2703 mike 1.23 while (getKeyBindingElement(parser, name, value, type))
|
2704 kumpf 1.73 keyBindings.append(CIMKeyBinding(name, value, type));
|
2705 mike 1.25 }
|
2706 mike 1.23
|
2707 mike 1.25 expectEndTag(parser, "INSTANCENAME");
|
2708 mike 1.23
2709 return true;
2710 }
2711
2712 Boolean XmlReader::getInstanceNameElement(
2713 XmlParser& parser,
|
2714 kumpf 1.54 CIMObjectPath& instanceName)
|
2715 mike 1.23 {
2716 String className;
|
2717 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2718 mike 1.23
2719 if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
2720 return false;
2721
|
2722 kumpf 1.62 instanceName.set(String(), CIMNamespaceName(), className, keyBindings);
|
2723 mike 1.23 return true;
2724 }
2725
2726 //------------------------------------------------------------------------------
2727 //
2728 // getInstancePathElement()
2729 //
2730 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2731 //
2732 //------------------------------------------------------------------------------
2733
2734 Boolean XmlReader::getInstancePathElement(
2735 XmlParser& parser,
|
2736 kumpf 1.54 CIMObjectPath& reference)
|
2737 mike 1.23 {
2738 XmlEntry entry;
2739
2740 if (!testStartTag(parser, entry, "INSTANCEPATH"))
2741 return false;
2742
2743 String host;
2744 String nameSpace;
2745
2746 if (!getNameSpacePathElement(parser, host, nameSpace))
2747 {
|
2748 humberto 1.85
2749 // l10n
2750
2751 // throw XmlValidationError(parser.getLine(),
2752 // "expected NAMESPACEPATH element");
2753
|
2754 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
2755 "expected NAMESPACEPATH element");
|
2756 humberto 1.85
2757 throw XmlValidationError(parser.getLine(), mlParms);
2758
|
2759 mike 1.23 }
2760
2761 String className;
|
2762 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2763 mike 1.23
2764 if (!getInstanceNameElement(parser, className, keyBindings))
2765 {
|
2766 humberto 1.85
2767 // l10n
2768
2769 // throw XmlValidationError(parser.getLine(),
2770 // "expected INSTANCENAME element");
2771
2772
|
2773 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
2774 "expected INSTANCENAME element");
|
2775 humberto 1.85
2776 throw XmlValidationError(parser.getLine(), mlParms);
2777
|
2778 mike 1.23 }
2779
2780 reference.set(host, nameSpace, className, keyBindings);
2781
2782 expectEndTag(parser, "INSTANCEPATH");
2783 return true;
2784 }
2785
2786 //------------------------------------------------------------------------------
2787 //
2788 // getLocalInstancePathElement()
2789 //
2790 // <!ELEMENT LOCALINSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
2791 //
2792 //------------------------------------------------------------------------------
2793
2794 Boolean XmlReader::getLocalInstancePathElement(
2795 XmlParser& parser,
|
2796 kumpf 1.54 CIMObjectPath& reference)
|
2797 mike 1.23 {
2798 XmlEntry entry;
2799
2800 if (!testStartTag(parser, entry, "LOCALINSTANCEPATH"))
2801 return false;
2802
2803 String nameSpace;
2804
2805 if (!getLocalNameSpacePathElement(parser, nameSpace))
2806 {
|
2807 humberto 1.85
2808 // l10n
2809
2810 // throw XmlValidationError(parser.getLine(),
2811 // "expected LOCALNAMESPACEPATH element");
2812
|
2813 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2814 "expected LOCALNAMESPACEPATH element");
|
2815 humberto 1.85
2816 throw XmlValidationError(parser.getLine(), mlParms);
2817
|
2818 mike 1.23 }
2819
2820 String className;
|
2821 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
2822 mike 1.23
2823 if (!getInstanceNameElement(parser, className, keyBindings))
2824 {
|
2825 humberto 1.85
2826 // l10n
2827
2828 // throw XmlValidationError(parser.getLine(),
2829 // "expected INSTANCENAME element");
2830
|
2831 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
2832 "expected INSTANCENAME element");
|
2833 humberto 1.85
2834 throw XmlValidationError(parser.getLine(), mlParms);
2835
|
2836 mike 1.23 }
2837
2838 reference.set(String(), nameSpace, className, keyBindings);
2839
2840 expectEndTag(parser, "LOCALINSTANCEPATH");
2841 return true;
2842 }
2843
2844 //------------------------------------------------------------------------------
2845 //
2846 // getClassPathElement()
2847 //
2848 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
2849 //
2850 //------------------------------------------------------------------------------
2851
2852 Boolean XmlReader::getClassPathElement(
2853 XmlParser& parser,
|
2854 kumpf 1.54 CIMObjectPath& reference)
|
2855 mike 1.23 {
2856 XmlEntry entry;
2857
2858 if (!testStartTag(parser, entry, "CLASSPATH"))
2859 return false;
2860
2861 String host;
2862 String nameSpace;
2863
2864 if (!getNameSpacePathElement(parser, host, nameSpace))
2865 {
|
2866 humberto 1.85
2867 // l10n
2868
2869 // throw XmlValidationError(parser.getLine(),
2870 // "expected NAMESPACEPATH element");
2871
|
2872 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
2873 "expected NAMESPACEPATH element");
|
2874 humberto 1.85
2875 throw XmlValidationError(parser.getLine(), mlParms);
2876
|
2877 mike 1.23 }
2878
|
2879 kumpf 1.74 CIMName className;
|
2880 mike 1.23
2881 if (!getClassNameElement(parser, className))
2882 {
|
2883 humberto 1.85
2884 // l10n
2885
2886 // throw XmlValidationError(parser.getLine(),
2887 // "expected CLASSNAME element");
2888
|
2889 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2890 "expected CLASSNAME element");
|
2891 humberto 1.85
2892 throw XmlValidationError(parser.getLine(), mlParms);
2893
|
2894 mike 1.23 }
2895
2896 reference.set(host, nameSpace, className);
2897
2898 expectEndTag(parser, "CLASSPATH");
2899 return true;
2900 }
2901
2902 //------------------------------------------------------------------------------
2903 //
2904 // getLocalClassPathElement()
2905 //
2906 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH,CLASSNAME)>
2907 //
2908 //------------------------------------------------------------------------------
2909
2910 Boolean XmlReader::getLocalClassPathElement(
2911 XmlParser& parser,
|
2912 kumpf 1.54 CIMObjectPath& reference)
|
2913 mike 1.23 {
2914 XmlEntry entry;
2915
2916 if (!testStartTag(parser, entry, "LOCALCLASSPATH"))
2917 return false;
2918
2919 String nameSpace;
2920
2921 if (!getLocalNameSpacePathElement(parser, nameSpace))
2922 {
|
2923 humberto 1.85
2924 // l10n
2925
2926 // throw XmlValidationError(parser.getLine(),
2927 // "expected LOCALNAMESPACEPATH element");
2928
|
2929 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
2930 "expected LOCALNAMESPACEPATH element");
|
2931 humberto 1.85
2932 throw XmlValidationError(parser.getLine(), mlParms);
2933
|
2934 mike 1.23 }
2935
|
2936 kumpf 1.74 CIMName className;
|
2937 mike 1.23
2938 if (!getClassNameElement(parser, className))
2939 {
|
2940 humberto 1.85
2941 // l10n
2942
2943 // throw XmlValidationError(parser.getLine(),
2944 // "expected CLASSNAME element");
2945
|
2946 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
2947 "expected CLASSNAME element");
|
2948 humberto 1.85
2949 throw XmlValidationError(parser.getLine(), mlParms);
2950
|
2951 mike 1.23 }
2952
2953 reference.set(String(), nameSpace, className);
2954
2955 expectEndTag(parser, "LOCALCLASSPATH");
2956
2957 return true;
2958 }
2959
2960 //------------------------------------------------------------------------------
2961 //
2962 // getValueReferenceElement()
2963 //
2964 // <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
2965 // INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
2966 //
2967 //
2968 //------------------------------------------------------------------------------
2969
2970 Boolean XmlReader::getValueReferenceElement(
2971 XmlParser& parser,
|
2972 kumpf 1.54 CIMObjectPath& reference)
|
2973 mike 1.23 {
2974 XmlEntry entry;
2975
2976 if (!testStartTag(parser, entry, "VALUE.REFERENCE"))
2977 return false;
2978
2979 if (!parser.next(entry))
2980 throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
2981
2982 if (entry.type != XmlEntry::START_TAG &&
2983 entry.type != XmlEntry::EMPTY_TAG)
2984 {
|
2985 humberto 1.85
2986 // l10n
2987
2988 // throw XmlValidationError(parser.getLine(),
2989 // "Expected one of the following start tags: "
2990 // "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "
2991 // "LOCALINSTANCEPATH, INSTANCENAME");
2992
2993 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS",
|
2994 humberto 1.87 "Expected one of the following start tags: CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME");
|
2995 humberto 1.85
2996 throw XmlValidationError(parser.getLine(), mlParms);
2997
|
2998 mike 1.23 }
2999
3000 if (strcmp(entry.text, "CLASSPATH") == 0)
3001 {
3002 parser.putBack(entry);
3003 getClassPathElement(parser, reference);
3004 }
3005 else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)
3006 {
3007 parser.putBack(entry);
3008 getLocalClassPathElement(parser, reference);
3009 }
3010 else if (strcmp(entry.text, "CLASSNAME") == 0)
3011 {
3012 parser.putBack(entry);
|
3013 kumpf 1.74 CIMName className;
|
3014 mike 1.23 getClassNameElement(parser, className);
|
3015 kumpf 1.62 reference.set(String(), CIMNamespaceName(), className);
|
3016 mike 1.23 }
3017 else if (strcmp(entry.text, "INSTANCEPATH") == 0)
3018 {
3019 parser.putBack(entry);
3020 getInstancePathElement(parser, reference);
3021 }
3022 else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)
3023 {
3024 parser.putBack(entry);
3025 getLocalInstancePathElement(parser, reference);
3026 }
3027 else if (strcmp(entry.text, "INSTANCENAME") == 0)
3028 {
3029 parser.putBack(entry);
3030 String className;
|
3031 kumpf 1.73 Array<CIMKeyBinding> keyBindings;
|
3032 mike 1.23 getInstanceNameElement(parser, className, keyBindings);
|
3033 kumpf 1.62 reference.set(String(), CIMNamespaceName(), className, keyBindings);
|
3034 mike 1.23 }
3035
3036 expectEndTag(parser, "VALUE.REFERENCE");
3037 return true;
3038 }
3039
3040 //------------------------------------------------------------------------------
3041 //
|
3042 kumpf 1.28 // getValueReferenceArrayElement()
3043 //
3044 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
3045 //
3046 //------------------------------------------------------------------------------
3047
3048 Boolean XmlReader::getValueReferenceArrayElement(
3049 XmlParser& parser,
3050 CIMValue& value)
3051 {
3052 XmlEntry entry;
|
3053 kumpf 1.54 Array<CIMObjectPath> referenceArray;
3054 CIMObjectPath reference;
|
3055 kumpf 1.28
3056 value.clear();
3057
3058 // Get VALUE.REFARRAY open tag:
3059
3060 if (!testStartTagOrEmptyTag(parser, entry, "VALUE.REFARRAY"))
3061 return false;
3062
|
3063 kumpf 1.32 if (entry.type != XmlEntry::EMPTY_TAG)
3064 {
3065 // For each VALUE.REFERENCE element:
|
3066 kumpf 1.28
|
3067 kumpf 1.32 while (getValueReferenceElement(parser, reference))
3068 {
3069 referenceArray.append(reference);
3070 }
|
3071 kumpf 1.28
|
3072 kumpf 1.32 expectEndTag(parser, "VALUE.REFARRAY");
|
3073 kumpf 1.28 }
3074
3075 value.set(referenceArray);
3076 return true;
3077 }
3078
3079 //------------------------------------------------------------------------------
3080 //
|
3081 mike 1.23 // getPropertyReferenceElement()
3082 //
3083 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)>
3084 // <!ATTLIST PROPERTY.REFERENCE
3085 // %CIMName;
3086 // %ReferenceClass;
3087 // %ClassOrigin;
3088 // %Propagated;>
3089 //
3090 //------------------------------------------------------------------------------
3091
3092 Boolean XmlReader::getPropertyReferenceElement(
3093 XmlParser& parser,
3094 CIMProperty& property)
3095 {
3096 XmlEntry entry;
3097
3098 if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.REFERENCE"))
3099 return false;
3100
3101 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3102 mike 1.23
3103 // Get PROPERTY.NAME attribute:
3104
|
3105 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3106 mike 1.23 parser.getLine(), entry, "PROPERTY.REFERENCE");
3107
3108 // Get PROPERTY.REFERENCECLASS attribute:
3109
|
3110 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
3111 mike 1.23 parser.getLine(), entry, "PROPERTY.REFERENCE");
3112
3113 // Get PROPERTY.CLASSORIGIN attribute:
3114
|
3115 kumpf 1.62 CIMName classOrigin =
|
3116 mike 1.23 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");
3117
3118 // Get PROPERTY.PROPAGATED
3119
3120 Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,
3121 "PROPERTY.REFERENCE", "PROPAGATED", false, false);
3122
3123 // Create property:
3124
|
3125 kumpf 1.61 CIMValue value = CIMValue(CIMTYPE_REFERENCE, false, 0);
|
3126 kumpf 1.54 // value.set(CIMObjectPath());
|
3127 mike 1.23 property = CIMProperty(
3128 name, value, 0, referenceClass, classOrigin, propagated);
3129
3130 if (!empty)
3131 {
3132 getQualifierElements(parser, property);
3133
|
3134 kumpf 1.54 CIMObjectPath reference;
|
3135 mike 1.23
3136 if (getValueReferenceElement(parser, reference))
3137 property.setValue(reference);
3138
3139 expectEndTag(parser, "PROPERTY.REFERENCE");
3140 }
3141
3142 return true;
3143 }
3144
3145 //------------------------------------------------------------------------------
3146 //
3147 // GetPropertyElements()
3148 //
3149 //------------------------------------------------------------------------------
3150
3151 template<class CONTAINER>
3152 void GetPropertyElements(XmlParser& parser, CONTAINER& container)
3153 {
3154 CIMProperty property;
3155
3156 mike 1.23 while (XmlReader::getPropertyElement(parser, property) ||
3157 XmlReader::getPropertyArrayElement(parser, property) ||
3158 XmlReader::getPropertyReferenceElement(parser, property))
3159 {
3160 try
3161 {
3162 container.addProperty(property);
3163 }
|
3164 kumpf 1.66 catch (AlreadyExistsException&)
|
3165 mike 1.23 {
|
3166 humberto 1.85
3167 // l10n
3168
3169 // throw XmlSemanticError(parser.getLine(), "duplicate property");
3170
|
3171 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PROPERTY",
3172 "duplicate property");
|
3173 humberto 1.85
3174 throw XmlSemanticError(parser.getLine(), mlParms);
|
3175 mike 1.23 }
3176 }
3177 }
3178
3179 //------------------------------------------------------------------------------
3180 //
3181 // getParameterElement()
3182 //
3183 // <!ELEMENT PARAMETER (QUALIFIER*)>
3184 // <!ATTLIST PARAMETER
3185 // %CIMName;
3186 // %CIMType; #REQUIRED>
3187 //
3188 //------------------------------------------------------------------------------
3189
3190 Boolean XmlReader::getParameterElement(
3191 XmlParser& parser,
3192 CIMParameter& parameter)
3193 {
3194 XmlEntry entry;
3195
3196 mike 1.23 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER"))
3197 return false;
3198
3199 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3200
3201 // Get PARAMETER.NAME attribute:
3202
|
3203 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");
|
3204 mike 1.23
3205 // Get PARAMETER.TYPE attribute:
3206
|
3207 kumpf 1.67 CIMType type;
3208 getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER");
|
3209 mike 1.23
3210 // Create parameter:
3211
3212 parameter = CIMParameter(name, type);
3213
3214 if (!empty)
3215 {
3216 getQualifierElements(parser, parameter);
3217
3218 expectEndTag(parser, "PARAMETER");
3219 }
3220
3221 return true;
3222 }
3223
3224 //------------------------------------------------------------------------------
3225 //
3226 // getParameterArrayElement()
3227 //
3228 // <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
3229 // <!ATTLIST PARAMETER.ARRAY
3230 mike 1.23 // %CIMName;
3231 // %CIMType; #REQUIRED
3232 // %ArraySize;>
3233 //
3234 //------------------------------------------------------------------------------
3235
3236 Boolean XmlReader::getParameterArrayElement(
3237 XmlParser& parser,
3238 CIMParameter& parameter)
3239 {
3240 XmlEntry entry;
3241
3242 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.ARRAY"))
3243 return false;
3244
3245 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3246
3247 // Get PARAMETER.ARRAY.NAME attribute:
3248
|
3249 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3250 mike 1.23 parser.getLine(), entry, "PARAMETER.ARRAY");
3251
3252 // Get PARAMETER.ARRAY.TYPE attribute:
3253
|
3254 kumpf 1.67 CIMType type;
3255 getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER.ARRAY");
|
3256 mike 1.23
3257 // Get PARAMETER.ARRAYSIZE attribute:
3258
3259 Uint32 arraySize = 0;
3260 getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY",arraySize);
3261
3262 // Create parameter:
3263
3264 parameter = CIMParameter(name, type, true, arraySize);
3265
3266 if (!empty)
3267 {
3268 getQualifierElements(parser, parameter);
3269
3270 expectEndTag(parser, "PARAMETER.ARRAY");
3271 }
3272
3273 return true;
3274 }
3275
3276 //------------------------------------------------------------------------------
3277 mike 1.23 //
3278 // getParameterReferenceElement()
3279 //
3280 // <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
3281 // <!ATTLIST PARAMETER.REFERENCE
3282 // %CIMName;
3283 // %ReferenceClass;>
3284 //
3285 //------------------------------------------------------------------------------
3286
3287 Boolean XmlReader::getParameterReferenceElement(
3288 XmlParser& parser,
3289 CIMParameter& parameter)
3290 {
3291 XmlEntry entry;
3292
3293 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFERENCE"))
3294 return false;
3295
3296 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3297
3298 mike 1.23 // Get PARAMETER.NAME attribute:
3299
|
3300 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3301 mike 1.23 parser.getLine(), entry, "PARAMETER.REFERENCE");
3302
3303 // Get PARAMETER.REFERENCECLASS attribute:
3304
|
3305 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
3306 mike 1.23 parser.getLine(), entry, "PARAMETER.REFERENCE");
3307
3308 // Create parameter:
3309
|
3310 kumpf 1.61 parameter = CIMParameter(name, CIMTYPE_REFERENCE, false, 0, referenceClass);
|
3311 mike 1.23
3312 if (!empty)
3313 {
3314 getQualifierElements(parser, parameter);
3315 expectEndTag(parser, "PARAMETER.REFERENCE");
3316 }
3317
3318 return true;
3319 }
3320
3321 //------------------------------------------------------------------------------
3322 //
|
3323 kumpf 1.26 // getParameterReferenceArrayElement()
3324 //
3325 // <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
3326 // <!ATTLIST PARAMETER.REFARRAY
3327 // %CIMName;
3328 // %ReferenceClass;
3329 // %ArraySize;>
3330 //
3331 //------------------------------------------------------------------------------
3332
3333 Boolean XmlReader::getParameterReferenceArrayElement(
3334 XmlParser& parser,
3335 CIMParameter& parameter)
3336 {
3337 XmlEntry entry;
3338
3339 if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFARRAY"))
3340 return false;
3341
3342 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3343
3344 kumpf 1.26 // Get PARAMETER.NAME attribute:
3345
|
3346 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3347 kumpf 1.26 parser.getLine(), entry, "PARAMETER.REFARRAY");
3348
3349 // Get PARAMETER.REFERENCECLASS attribute:
3350
|
3351 kumpf 1.62 CIMName referenceClass = getReferenceClassAttribute(
|
3352 kumpf 1.26 parser.getLine(), entry, "PARAMETER.REFARRAY");
3353
3354 // Get PARAMETER.ARRAYSIZE attribute:
3355
3356 Uint32 arraySize = 0;
3357 getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.REFARRAY",
3358 arraySize);
3359
3360 // Create parameter:
3361
|
3362 kumpf 1.61 parameter = CIMParameter(name, CIMTYPE_REFERENCE, true, arraySize,
|
3363 kumpf 1.26 referenceClass);
3364
3365 if (!empty)
3366 {
3367 getQualifierElements(parser, parameter);
3368 expectEndTag(parser, "PARAMETER.REFARRAY");
3369 }
3370
3371 return true;
3372 }
3373
3374 //------------------------------------------------------------------------------
3375 //
|
3376 mike 1.23 // GetParameterElements()
3377 //
3378 //------------------------------------------------------------------------------
3379
3380 template<class CONTAINER>
3381 void GetParameterElements(XmlParser& parser, CONTAINER& container)
3382 {
3383 CIMParameter parameter;
3384
3385 while (XmlReader::getParameterElement(parser, parameter) ||
3386 XmlReader::getParameterArrayElement(parser, parameter) ||
|
3387 kumpf 1.26 XmlReader::getParameterReferenceElement(parser, parameter) ||
3388 XmlReader::getParameterReferenceArrayElement(parser, parameter))
|
3389 mike 1.23 {
3390 try
3391 {
3392 container.addParameter(parameter);
3393 }
|
3394 kumpf 1.66 catch (AlreadyExistsException&)
|
3395 mike 1.23 {
|
3396 humberto 1.85
3397 // l10n
3398
3399 // throw XmlSemanticError(parser.getLine(), "duplicate parameter");
3400
|
3401 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PARAMETER",
3402 "duplicate parameter");
|
3403 humberto 1.85
3404 throw XmlSemanticError(parser.getLine(), mlParms);
|
3405 mike 1.23 }
3406 }
3407 }
3408
3409 //------------------------------------------------------------------------------
3410 //
3411 // getQualifierDeclElement()
3412 //
3413 // <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
3414 // <!ATTLIST QUALIFIER.DECLARATION
3415 // %CIMName;
3416 // %CIMType; #REQUIRED
3417 // ISARRAY (true|false) #IMPLIED
3418 // %ArraySize;
3419 // %QualifierFlavor;>
3420 //
3421 //------------------------------------------------------------------------------
3422
3423 Boolean XmlReader::getQualifierDeclElement(
3424 XmlParser& parser,
3425 CIMQualifierDecl& qualifierDecl)
3426 mike 1.23 {
3427 XmlEntry entry;
3428
3429 if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER.DECLARATION"))
3430 return false;
3431
3432 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3433
3434 // Get NAME attribute:
3435
|
3436 kumpf 1.74 CIMName name = getCimNameAttribute(
|
3437 mike 1.23 parser.getLine(), entry, "QUALIFIER.DECLARATION");
3438
3439 // Get TYPE attribute:
3440
|
3441 kumpf 1.67 CIMType type;
3442 getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER.DECLARATION");
|
3443 mike 1.23
3444 // Get ISARRAY attribute:
3445
|
3446 mike 1.25 Boolean isArray = getCimBooleanAttribute(
3447 parser.getLine(), entry, "QUALIFIER.DECLARATION", "ISARRAY",
3448 false, false);
|
3449 mike 1.23
3450 // Get ARRAYSIZE attribute:
3451
3452 Uint32 arraySize = 0;
3453 Boolean gotArraySize = getArraySizeAttribute(parser.getLine(),
3454 entry, "QUALIFIER.DECLARATION", arraySize);
3455
3456 // Get flavor oriented attributes:
3457
|
3458 kumpf 1.64 CIMFlavor flavor = getFlavor (entry, parser.getLine (),
3459 "QUALIFIER.DECLARATION");
|
3460 mike 1.23
3461 // No need to look for interior elements if empty tag:
3462
|
3463 kumpf 1.63 CIMScope scope = CIMScope ();
|
3464 mike 1.23 CIMValue value;
|
3465 kumpf 1.67 Boolean gotValue = false;
|
3466 mike 1.23
3467 if (!empty)
3468 {
3469 // Get the option SCOPE element:
3470
3471 scope = getOptionalScope(parser);
3472
3473 // Get VALUE or VALUE.ARRAY element:
3474
3475 if (getValueArrayElement(parser, type, value))
3476 {
3477 if (!isArray)
3478 {
|
3479 humberto 1.85
3480 // l10n
3481
3482 // throw XmlSemanticError(parser.getLine(),
3483 // "VALUE.ARRAY element encountered without "
3484 // "ISARRAY attribute");
3485
3486 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY",
|
3487 humberto 1.87 "VALUE.ARRAY element encountered without ISARRAY attribute");
|
3488 humberto 1.85
3489 throw XmlSemanticError(parser.getLine(), mlParms);
|
3490 mike 1.23 }
3491
3492 if (arraySize && arraySize != value.getArraySize())
3493 {
|
3494 humberto 1.85
3495 // l10n
3496
3497 // throw XmlSemanticError(parser.getLine(),
3498 // "VALUE.ARRAY size is not the same as "
3499 // "ARRAYSIZE attribute");
3500
3501 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME",
|
3502 humberto 1.87 "VALUE.ARRAY size is not the same as ARRAYSIZE attribute");
|
3503 humberto 1.85
3504 throw XmlSemanticError(parser.getLine(), mlParms);
|
3505 mike 1.23 }
|
3506 kumpf 1.67
3507 gotValue = true;
|
3508 mike 1.23 }
3509 else if (getValueElement(parser, type, value))
3510 {
3511 if (isArray)
3512 {
|
3513 humberto 1.85
3514 // l10n
3515
3516 // throw XmlSemanticError(parser.getLine(),
3517 // "ISARRAY attribute used but VALUE element encountered");
3518
3519 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",
|
3520 humberto 1.87 "ISARRAY attribute used but VALUE element encountered");
|
3521 humberto 1.85
3522 throw XmlSemanticError(parser.getLine(), mlParms);
|
3523 mike 1.23 }
|
3524 kumpf 1.67
3525 gotValue = true;
|
3526 mike 1.23 }
3527
3528 // Now get the closing tag:
3529
3530 expectEndTag(parser, "QUALIFIER.DECLARATION");
3531 }
3532
|
3533 kumpf 1.67 if (!gotValue)
|
3534 mike 1.23 {
3535 if (isArray)
3536 value.setNullValue(type, true, arraySize);
3537 else
3538 value.setNullValue(type, false);
3539 }
3540
3541 CIMQualifierDecl tmp(name, value, scope, flavor, arraySize);
3542 qualifierDecl = CIMQualifierDecl(name, value, scope, flavor, arraySize);
3543 return true;
3544 }
3545
3546 //------------------------------------------------------------------------------
3547 // getMethodElement()
3548 //
3549 // <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|
3550 // PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
3551 // <!ATTLIST METHOD
3552 // %CIMName;
3553 // %CIMType; #IMPLIED
3554 // %ClassOrigin;
3555 mike 1.23 // %Propagated;>
3556 //
3557 //------------------------------------------------------------------------------
3558
3559 Boolean XmlReader::getMethodElement(XmlParser& parser, CIMMethod& method)
3560 {
3561 XmlEntry entry;
3562
3563 if (!testStartTagOrEmptyTag(parser, entry, "METHOD"))
3564 return false;
3565
3566 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3567
|
3568 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
|
3569 mike 1.23
|
3570 kumpf 1.67 CIMType type;
3571 getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");
|
3572 mike 1.23
|
3573 kumpf 1.62 CIMName classOrigin =
|
3574 mike 1.23 getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
3575
3576 Boolean propagated = getCimBooleanAttribute(
3577 parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
3578
3579 method = CIMMethod(name, type, classOrigin, propagated);
3580
3581 if (!empty)
3582 {
|
3583 kumpf 1.26 // ATTN-RK-P2-20020219: Decoding algorithm must not depend on the
3584 // ordering of qualifiers and parameters.
|
3585 mike 1.23 getQualifierElements(parser, method);
3586
3587 GetParameterElements(parser, method);
3588
3589 expectEndTag(parser, "METHOD");
3590 }
3591
3592 return true;
3593 }
3594
3595 //------------------------------------------------------------------------------
3596 // getClassElement()
3597 //
3598 // <!ELEMENT CLASS (QUALIFIER*,
3599 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
3600 // <!ATTLIST CLASS %CIMName; %SuperClass;>
3601 //
3602 //------------------------------------------------------------------------------
3603
3604 Boolean XmlReader::getClassElement(XmlParser& parser, CIMClass& cimClass)
3605 {
3606 mike 1.23 XmlEntry entry;
3607
|
3608 a.dunfey 1.96 if (!testStartTagOrEmptyTag(parser, entry, "CLASS"))
|
3609 mike 1.23 return false;
3610
|
3611 kumpf 1.74 CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
|
3612 mike 1.23
|
3613 kumpf 1.62 CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");
|
3614 mike 1.23
3615 cimClass = CIMClass(name, superClass);
3616
|
3617 a.dunfey 1.97 if(entry.type != XmlEntry::EMPTY_TAG)
3618 {
3619
|
3620 mike 1.23 // Get QUALIFIER elements:
3621
3622 getQualifierElements(parser, cimClass);
3623
3624 // Get PROPERTY elements:
3625
3626 GetPropertyElements(parser, cimClass);
3627
3628 // Get METHOD elements:
3629
3630 CIMMethod method;
3631
3632 while (getMethodElement(parser, method))
3633 cimClass.addMethod(method);
3634
3635 // Get CLASS end tag:
|
3636 a.dunfey 1.97
3637 expectEndTag(parser, "CLASS");
3638 }
|
3639 mike 1.23
3640 return true;
3641 }
3642
3643 //------------------------------------------------------------------------------
3644 // getInstanceElement()
3645 //
3646 // <!ELEMENT INSTANCE (QUALIFIER*,
3647 // (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*) >
3648 // <!ATTLIST INSTANCE
3649 // %ClassName;>
3650 //
3651 //------------------------------------------------------------------------------
3652
3653 Boolean XmlReader::getInstanceElement(
3654 XmlParser& parser,
3655 CIMInstance& cimInstance)
3656 {
3657 XmlEntry entry;
3658
|
3659 kumpf 1.89 if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE"))
|
3660 mike 1.23 return false;
3661
|
3662 kumpf 1.89 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
3663
|
3664 mike 1.23 String className = getClassNameAttribute(
3665 parser.getLine(), entry, "INSTANCE");
3666
3667 cimInstance = CIMInstance(className);
3668
|
3669 kumpf 1.89 if (!empty)
3670 {
3671 // Get QUALIFIER elements:
3672 getQualifierElements(parser, cimInstance);
3673
3674 // Get PROPERTY elements:
3675 GetPropertyElements(parser, cimInstance);
3676
3677 // Get INSTANCE end tag:
3678 expectEndTag(parser, "INSTANCE");
3679 }
|
3680 mike 1.23
3681 return true;
3682 }
3683
3684 //------------------------------------------------------------------------------
|
3685 mike 1.25 // getNamedInstanceElement()
3686 //
3687 // <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
3688 //
3689 //------------------------------------------------------------------------------
3690
3691 Boolean XmlReader::getNamedInstanceElement(
3692 XmlParser& parser,
|
3693 kumpf 1.55 CIMInstance& namedInstance)
|
3694 mike 1.25 {
3695 XmlEntry entry;
3696
3697 if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))
3698 return false;
3699
|
3700 kumpf 1.54 CIMObjectPath instanceName;
|
3701 mike 1.25
3702 // Get INSTANCENAME elements:
3703
3704 if (!getInstanceNameElement(parser, instanceName))
3705 {
|
3706 humberto 1.85
3707 // l10n
3708
3709 // throw XmlValidationError(parser.getLine(),
3710 // "expected INSTANCENAME element");
3711
|
3712 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
3713 "expected INSTANCENAME element");
|
3714 humberto 1.85
3715 throw XmlValidationError(parser.getLine(), mlParms);
|
3716 mike 1.25 }
3717
3718 // Get INSTANCE elements:
3719
|
3720 kumpf 1.55 if (!getInstanceElement(parser, namedInstance))
|
3721 mike 1.25 {
|
3722 humberto 1.85
3723 // l10n
3724
3725 // throw XmlValidationError(parser.getLine(),
3726 // "expected INSTANCE element");
3727
3728
|
3729 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3730 "expected INSTANCE element");
|
3731 humberto 1.85
3732 throw XmlValidationError(parser.getLine(), mlParms);
|
3733 mike 1.25 }
3734
3735 // Get VALUE.NAMEDINSTANCE end tag:
3736
3737 expectEndTag(parser, "VALUE.NAMEDINSTANCE");
3738
|
3739 kumpf 1.55 namedInstance.setPath (instanceName);
|
3740 mike 1.25
3741 return true;
3742 }
3743
3744 //------------------------------------------------------------------------------
|
3745 mike 1.23 //
3746 // getObject()
3747 //
3748 //------------------------------------------------------------------------------
3749
3750 void XmlReader::getObject(XmlParser& parser, CIMClass& x)
3751 {
3752 if (!getClassElement(parser, x))
3753 {
|
3754 humberto 1.85
3755 // l10n
3756
3757 // throw XmlValidationError(parser.getLine(),
3758 // "expected CLASS element");
3759
|
3760 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
3761 "expected CLASS element");
|
3762 humberto 1.85
3763 throw XmlValidationError(parser.getLine(), mlParms);
|
3764 mike 1.23 }
3765 }
3766
3767 //------------------------------------------------------------------------------
3768 //
3769 // getObject()
3770 //
3771 //------------------------------------------------------------------------------
3772
3773 void XmlReader::getObject(XmlParser& parser, CIMInstance& x)
3774 {
3775 if (!getInstanceElement(parser, x))
3776 {
|
3777 humberto 1.85
3778 // l10n
3779
3780 // throw XmlValidationError(parser.getLine(),
3781 // "expected INSTANCE element");
3782
|
3783 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
3784 "expected INSTANCE element");
|
3785 humberto 1.85
3786 throw XmlValidationError(parser.getLine(), mlParms);
|
3787 mike 1.23 }
3788 }
3789
3790 //------------------------------------------------------------------------------
3791 //
3792 // getObject()
3793 //
3794 //------------------------------------------------------------------------------
3795
3796 void XmlReader::getObject(XmlParser& parser, CIMQualifierDecl& x)
3797 {
3798 if (!getQualifierDeclElement(parser, x))
3799 {
|
3800 humberto 1.85
3801 // l10n
3802
3803 // throw XmlValidationError(parser.getLine(),
3804 // "expected QUALIFIER.DECLARATION element");
3805
|
3806 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",
3807 "expected QUALIFIER.DECLARATION element");
|
3808 humberto 1.85
3809 throw XmlValidationError(parser.getLine(), mlParms);
|
3810 mike 1.23 }
3811 }
3812
3813 //------------------------------------------------------------------------------
3814 //
3815 // getMessageStartTag()
3816 //
3817 //------------------------------------------------------------------------------
3818
3819 Boolean XmlReader::getMessageStartTag(
3820 XmlParser& parser,
3821 String& id,
|
3822 kumpf 1.34 String& protocolVersion)
|
3823 mike 1.23 {
3824 XmlEntry entry;
3825
3826 if (!testStartTag(parser, entry, "MESSAGE"))
3827 return false;
3828
3829 // Get MESSAGE.ID:
3830
|
3831 humberto 1.85 if (!entry.getAttributeValue("ID", id)) {
3832
3833 // l10n
3834
3835 // throw XmlValidationError(parser.getLine(),
3836 // "Invalid or missing MESSAGE.ID attribute");
3837
|
3838 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",
3839 "Invalid or missing MESSAGE.ID attribute");
|
3840 humberto 1.85
3841 throw XmlValidationError(parser.getLine(), mlParms);
3842 }
3843
|
3844 mike 1.23
3845 // Get MESSAGE.PROTOCOLVERSION:
3846
|
3847 humberto 1.85 if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion)) {
3848
3849 // l10n
|
3850 mike 1.23
|
3851 humberto 1.85 // throw XmlValidationError(parser.getLine(),
3852 // "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
3853
|
3854 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",
3855 "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
|
3856 humberto 1.85
3857 throw XmlValidationError(parser.getLine(), mlParms);
3858 }
3859
|
3860 mike 1.23 return true;
3861 }
3862
3863 //------------------------------------------------------------------------------
3864 //
3865 // getIMethodCallStartTag()
3866 //
3867 //------------------------------------------------------------------------------
3868
3869 Boolean XmlReader::getIMethodCallStartTag(
3870 XmlParser& parser,
3871 const char*& name)
3872 {
3873 XmlEntry entry;
3874
3875 if (!testStartTag(parser, entry, "IMETHODCALL"))
3876 return false;
3877
3878 // Get IMETHODCALL.NAME attribute:
3879
|
3880 humberto 1.85
3881 if (!entry.getAttributeValue("NAME", name)) {
3882
3883 // l10n
3884
3885 // throw XmlValidationError(parser.getLine(),
3886 // "Missing IMETHODCALL.NAME attribute");
3887
|
3888 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",
3889 "Missing IMETHODCALL.NAME attribute");
|
3890 humberto 1.85
3891 throw XmlValidationError(parser.getLine(), mlParms);
3892 }
3893
|
3894 mike 1.23
3895 return true;
3896 }
3897
3898 //------------------------------------------------------------------------------
3899 //
3900 // getIMethodResponseStartTag()
3901 //
3902 //------------------------------------------------------------------------------
3903
3904 Boolean XmlReader::getIMethodResponseStartTag(
3905 XmlParser& parser,
|
3906 kumpf 1.101 const char*& name,
3907 Boolean& isEmptyTag)
|
3908 mike 1.23 {
3909 XmlEntry entry;
3910
|
3911 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "IMETHODRESPONSE"))
|
3912 mike 1.23 return false;
3913
|
3914 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
3915
|
3916 mike 1.23 // Get IMETHODRESPONSE.NAME attribute:
3917
|
3918 humberto 1.85 if (!entry.getAttributeValue("NAME", name)) {
3919
3920 // l10n
3921
3922 // throw XmlValidationError(parser.getLine(),
3923 // "Missing IMETHODRESPONSE.NAME attribute");
3924
|
3925 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",
3926 "Missing IMETHODRESPONSE.NAME attribute");
|
3927 humberto 1.85
3928 throw XmlValidationError(parser.getLine(), mlParms);
3929 }
3930
|
3931 mike 1.23
3932 return true;
3933 }
3934
3935 //------------------------------------------------------------------------------
3936 //
3937 // getIParamValueTag()
3938 //
3939 //------------------------------------------------------------------------------
3940
3941 Boolean XmlReader::getIParamValueTag(
3942 XmlParser& parser,
|
3943 kumpf 1.99 const char*& name,
3944 Boolean& isEmptyTag)
|
3945 mike 1.23 {
3946 XmlEntry entry;
3947
|
3948 kumpf 1.99 if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE"))
|
3949 mike 1.23 return false;
3950
|
3951 kumpf 1.99 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
3952
|
3953 mike 1.23 // Get IPARAMVALUE.NAME attribute:
3954
|
3955 humberto 1.85 if (!entry.getAttributeValue("NAME", name)) {
3956
3957 // l10n
3958
3959 // throw XmlValidationError(parser.getLine(),
3960 // "Missing IPARAMVALUE.NAME attribute");
3961
|
3962 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",
3963 "Missing IPARAMVALUE.NAME attribute");
|
3964 humberto 1.85
3965 throw XmlValidationError(parser.getLine(), mlParms);
3966 }
|
3967 mike 1.23
3968 return true;
3969 }
3970
3971 //------------------------------------------------------------------------------
3972 //
|
3973 kumpf 1.99 // rejectNullIParamValue()
3974 //
3975 //------------------------------------------------------------------------------
3976
3977 void XmlReader::rejectNullIParamValue(
3978 XmlParser& parser,
3979 Boolean isEmptyTag,
3980 const char* paramName)
3981 {
3982 if (isEmptyTag)
3983 {
3984 MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE",
3985 "A null value is not valid for IPARAMVALUE \"$0\".",
3986 paramName);
3987 throw XmlValidationError(parser.getLine(), mlParms);
3988 }
3989 }
3990
3991 //------------------------------------------------------------------------------
3992 //
|
3993 mike 1.23 // getBooleanValueElement()
3994 //
3995 // Get an elements like: "<VALUE>FALSE</VALUE>"
3996 //
3997 //------------------------------------------------------------------------------
3998
3999 Boolean XmlReader::getBooleanValueElement(
4000 XmlParser& parser,
4001 Boolean& result,
4002 Boolean required)
4003 {
4004 XmlEntry entry;
4005
4006 if (!testStartTag(parser, entry, "VALUE"))
4007 {
4008 if (required)
4009 {
|
4010 humberto 1.85
4011 // l10n
4012
4013 // throw XmlValidationError(parser.getLine(),
4014 // "Expected VALUE element");
4015
|
4016 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
4017 "Expected VALUE element");
|
4018 humberto 1.85
4019 throw XmlValidationError(parser.getLine(), mlParms);
|
4020 mike 1.23 }
4021 return false;
4022 }
4023
4024 expectContentOrCData(parser, entry);
4025
|
4026 kumpf 1.72 if (System::strcasecmp(entry.text, "TRUE") == 0)
|
4027 mike 1.23 result = true;
|
4028 kumpf 1.72 else if (System::strcasecmp(entry.text, "FALSE") == 0)
|
4029 mike 1.23 result = false;
|
4030 humberto 1.85 else {
4031
4032 // l10n
4033
4034 // throw XmlSemanticError(parser.getLine(),
4035 // "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
4036
4037 MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",
|
4038 humberto 1.87 "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
|
4039 humberto 1.85
4040 throw XmlSemanticError(parser.getLine(), mlParms);
4041 }
|
4042 mike 1.23
4043 expectEndTag(parser, "VALUE");
4044
4045 return true;
4046 }
4047
4048 //------------------------------------------------------------------------------
4049 //
|
4050 kumpf 1.95 // DMTF CR Pending
|
4051 mike 1.23 //
|
4052 kumpf 1.95 // <!ELEMENT ERROR (INSTANCE*)>
|
4053 mike 1.23 // <!ATTLIST ERROR
4054 // CODE CDATA #REQUIRED
4055 // DESCRIPTION CDATA #IMPLIED>
4056 //
4057 //------------------------------------------------------------------------------
4058
4059 Boolean XmlReader::getErrorElement(
4060 XmlParser& parser,
|
4061 kumpf 1.50 CIMException& cimException,
|
4062 mike 1.23 Boolean required)
4063 {
4064 XmlEntry entry;
4065
4066 if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))
4067 {
|
4068 humberto 1.85 if (required) {
4069
4070 // l10n
4071
4072 // throw XmlValidationError(parser.getLine(),"Expected ERROR element");
4073
|
4074 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ERROR_ELEMENT",
4075 "Expected ERROR element");
|
4076 humberto 1.85
4077 throw XmlValidationError(parser.getLine(), mlParms);
4078
4079 }
4080 return false;
|
4081 mike 1.23 }
4082
4083 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
4084
4085 // Get ERROR.CODE
4086
4087 Uint32 tmpCode;
4088
|
4089 humberto 1.85 if (!entry.getAttributeValue("CODE", tmpCode)) {
4090
4091
4092 // l10n
4093
4094 // throw XmlValidationError(
4095 // parser.getLine(), "missing ERROR.CODE attribute");
4096
|
4097 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",
4098 "missing ERROR.CODE attribute");
|
4099 humberto 1.85
4100 throw XmlValidationError(parser.getLine(), mlParms);
4101
4102 }
|
4103 mike 1.23
|
4104 kumpf 1.50 // Get ERROR.DESCRIPTION:
|
4105 mike 1.23
|
4106 kumpf 1.50 String tmpDescription;
|
4107 mike 1.23
|
4108 kumpf 1.50 entry.getAttributeValue("DESCRIPTION", tmpDescription);
|
4109 mike 1.23
4110 if (!empty)
|
4111 kumpf 1.95 {
4112 while (testStartTagOrEmptyTag(parser, entry))
4113 {
4114 skipElement(parser, entry);
4115 }
4116
|
4117 mike 1.23 expectEndTag(parser, "ERROR");
|
4118 kumpf 1.95 }
|
4119 mike 1.23
|
4120 kumpf 1.50 cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);
|
4121 mike 1.23 return true;
4122 }
4123
4124
4125 //------------------------------------------------------------------------------
|
4126 kumpf 1.48 // getValueObjectElement()
4127 //
4128 // <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>
4129 //
4130 //------------------------------------------------------------------------------
4131
4132 Boolean XmlReader::getValueObjectElement(
4133 XmlParser& parser,
4134 CIMObject& object)
4135 {
4136 XmlEntry entry;
4137
4138 if (!testStartTag(parser, entry, "VALUE.OBJECT"))
4139 return false;
4140
4141 CIMInstance cimInstance;
4142 CIMClass cimClass;
4143
4144 if (XmlReader::getInstanceElement(parser, cimInstance))
4145 {
4146 object = CIMObject(cimInstance);
4147 kumpf 1.48 }
4148 else if (!XmlReader::getClassElement(parser, cimClass))
4149 {
4150 object = CIMObject(cimClass);
4151 }
4152 else
4153 {
|
4154 humberto 1.85
4155 // l10n
4156
4157 // throw XmlValidationError(parser.getLine(),
4158 // "Expected INSTANCE or CLASS element");
4159
|
4160 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
4161 "Expected INSTANCE or CLASS element");
|
4162 humberto 1.85
4163 throw XmlValidationError(parser.getLine(), mlParms);
4164
|
4165 kumpf 1.48 }
4166
4167 expectEndTag(parser, "VALUE.OBJECT");
4168
4169 return true;
4170 }
4171
4172 //------------------------------------------------------------------------------
4173 // getValueObjectWithPathElement()
|
4174 mike 1.23 //
4175 // <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
4176 //
4177 //------------------------------------------------------------------------------
4178
|
4179 kumpf 1.48 Boolean XmlReader::getValueObjectWithPathElement(
|
4180 mike 1.23 XmlParser& parser,
|
4181 kumpf 1.57 CIMObject& objectWithPath)
|
4182 mike 1.23 {
4183 XmlEntry entry;
4184
4185 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))
4186 return false;
4187
|
4188 kumpf 1.54 CIMObjectPath reference;
|
4189 mike 1.23 Boolean isInstance = false;
4190
4191 if (XmlReader::getInstancePathElement(parser, reference))
4192 isInstance = true;
4193 else if (!XmlReader::getClassPathElement(parser, reference))
4194 {
|
4195 humberto 1.85
|
4196 humberto 1.90 // l10n 485
|
4197 humberto 1.85
4198 // throw XmlValidationError(parser.getLine(),
4199 // "Expected INSTANCEPATH or CLASSPATH element");
4200
|
4201 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
|
4202 humberto 1.90 "Expected INSTANCEPATH or CLASSPATH element");
|
4203 humberto 1.85
4204 throw XmlValidationError(parser.getLine(), mlParms);
|
4205 mike 1.23 }
4206
4207 if (isInstance)
4208 {
4209 CIMInstance cimInstance;
4210
4211 if (!XmlReader::getInstanceElement(parser, cimInstance))
4212 {
|
4213 humberto 1.85
4214 // l10n
4215
4216 // throw XmlValidationError(parser.getLine(),
4217 // "Expected INSTANCE element");
4218
|
4219 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
4220 "Expected INSTANCE element");
|
4221 humberto 1.85
4222 throw XmlValidationError(parser.getLine(), mlParms);
|
4223 mike 1.23 }
|
4224 kumpf 1.57 objectWithPath = CIMObject (cimInstance);
4225 objectWithPath.setPath (reference);
|
4226 mike 1.23 }
4227 else
4228 {
4229 CIMClass cimClass;
4230
4231 if (!XmlReader::getClassElement(parser, cimClass))
4232 {
|
4233 humberto 1.85
4234 // l10n
4235
4236 // throw XmlValidationError(parser.getLine(),
4237 // "Expected CLASS element");
4238
|
4239 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
4240 "Expected CLASS element");
|
4241 humberto 1.85
4242 throw XmlValidationError(parser.getLine(), mlParms);
|
4243 mike 1.23 }
|
4244 kumpf 1.57 objectWithPath = CIMObject (cimClass);
4245 objectWithPath.setPath (reference);
|
4246 mike 1.23 }
4247
4248 expectEndTag(parser, "VALUE.OBJECTWITHPATH");
4249
4250 return true;
|
4251 kumpf 1.48 }
4252
4253 //------------------------------------------------------------------------------
4254 // getValueObjectWithLocalPathElement()
4255 //
4256 // <!ELEMENT VALUE.OBJECTWITHLOCALPATH
4257 // ((LOCALCLASSPATH,CLASS)|(LOCALINSTANCEPATH,INSTANCE))>
4258 //
4259 //------------------------------------------------------------------------------
4260
4261 Boolean XmlReader::getValueObjectWithLocalPathElement(
4262 XmlParser& parser,
|
4263 kumpf 1.57 CIMObject& objectWithPath)
|
4264 kumpf 1.48 {
4265 XmlEntry entry;
4266
4267 if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))
4268 return false;
4269
|
4270 kumpf 1.54 CIMObjectPath reference;
|
4271 kumpf 1.48 Boolean isInstance = false;
4272
4273 if (XmlReader::getLocalInstancePathElement(parser, reference))
4274 isInstance = true;
4275 else if (!XmlReader::getLocalClassPathElement(parser, reference))
4276 {
|
4277 humberto 1.85
4278 // l10n
4279
4280 // throw XmlValidationError(parser.getLine(),
4281 // "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");
4282
|
4283 humberto 1.91 //l10n updated
4284 MessageLoaderParms mlParms("Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
4285 MISSING_ELEMENT_LOCALPATH);
|
4286 humberto 1.85
4287 throw XmlValidationError(parser.getLine(), mlParms);
4288
|
4289 kumpf 1.48 }
4290
4291 if (isInstance)
4292 {
4293 CIMInstance cimInstance;
4294
4295 if (!XmlReader::getInstanceElement(parser, cimInstance))
4296 {
|
4297 humberto 1.85
4298 // l10n
4299
4300 // throw XmlValidationError(parser.getLine(),
4301 // "Expected INSTANCE element");
4302
|
4303 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
4304 "Expected INSTANCE element");
|
4305 humberto 1.85
4306 throw XmlValidationError(parser.getLine(), mlParms);
4307
|
4308 kumpf 1.48 }
|
4309 kumpf 1.57 objectWithPath = CIMObject (cimInstance);
4310 objectWithPath.setPath (reference);
|
4311 kumpf 1.48 }
4312 else
4313 {
4314 CIMClass cimClass;
4315
4316 if (!XmlReader::getClassElement(parser, cimClass))
4317 {
|
4318 humberto 1.85
4319 // l10n
4320
4321 // throw XmlValidationError(parser.getLine(),
4322 // "Expected CLASS element");
4323
|
4324 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
4325 "Expected CLASS element");
|
4326 humberto 1.85
4327 throw XmlValidationError(parser.getLine(), mlParms);
4328
4329
|
4330 kumpf 1.48 }
|
4331 kumpf 1.57 objectWithPath = CIMObject (cimClass);
4332 objectWithPath.setPath (reference);
|
4333 kumpf 1.48 }
4334
4335 expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");
4336
4337 return true;
4338 }
4339
4340 //------------------------------------------------------------------------------
4341 // getObjectArray()
4342 //
4343 // <object>
4344 // (VALUE.OBJECT|VALUE.OBJECTWITHLOCALPATH|VALUE.OBJECTWITHPATH)
4345 //
4346 //------------------------------------------------------------------------------
4347
4348 void XmlReader::getObjectArray(
4349 XmlParser& parser,
|
4350 kumpf 1.57 Array<CIMObject>& objectArray)
|
4351 kumpf 1.48 {
4352 CIMObject object;
|
4353 kumpf 1.57 CIMObject objectWithPath;
|
4354 kumpf 1.48
4355 objectArray.clear();
4356
4357 if (getValueObjectElement(parser, object))
4358 {
|
4359 kumpf 1.57 objectArray.append(object);
|
4360 kumpf 1.48 while (getValueObjectElement(parser, object))
|
4361 kumpf 1.57 objectArray.append(object);
|
4362 kumpf 1.48 }
4363 else if (getValueObjectWithPathElement(parser, objectWithPath))
4364 {
4365 objectArray.append(objectWithPath);
4366 while (getValueObjectWithPathElement(parser, objectWithPath))
4367 objectArray.append(objectWithPath);
4368 }
4369 else if (getValueObjectWithLocalPathElement(parser, objectWithPath))
4370 {
4371 objectArray.append(objectWithPath);
4372 while (getValueObjectWithLocalPathElement(parser, objectWithPath))
4373 objectArray.append(objectWithPath);
4374 }
|
4375 mike 1.23 }
4376
4377 //------------------------------------------------------------------------------
4378 //
4379 // <objectName>: (CLASSNAME|INSTANCENAME)
4380 //
4381 //------------------------------------------------------------------------------
4382
4383 Boolean XmlReader::getObjectNameElement(
4384 XmlParser& parser,
|
4385 kumpf 1.54 CIMObjectPath& objectName)
|
4386 mike 1.23 {
|
4387 kumpf 1.74 CIMName className;
|
4388 mike 1.23
4389 if (getClassNameElement(parser, className, false))
4390 {
|
4391 kumpf 1.62 objectName.set(String(), CIMNamespaceName(), className);
|
4392 mike 1.23 return true;
4393 }
4394 else if (getInstanceNameElement(parser, objectName))
4395 return true;
4396 else
4397 {
|
4398 humberto 1.85
4399 // l10n
4400
4401 // throw XmlValidationError(parser.getLine(),
4402 // "expected CLASSNAME or INSTANCENAME element");
4403
|
4404 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",
4405 "Expected CLASSNAME or INSTANCENAME element");
|
4406 humberto 1.85
4407 throw XmlValidationError(parser.getLine(), mlParms);
4408
|
4409 mike 1.23 }
4410
4411 return false;
4412 }
4413
4414 //------------------------------------------------------------------------------
4415 //
4416 // <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>
4417 //
4418 //------------------------------------------------------------------------------
4419
4420 Boolean XmlReader::getObjectPathElement(
4421 XmlParser& parser,
|
4422 kumpf 1.54 CIMObjectPath& objectPath)
|
4423 mike 1.23 {
4424 XmlEntry entry;
4425
4426 if (!testStartTag(parser, entry, "OBJECTPATH"))
4427 return false;
4428
4429 if (getClassPathElement(parser, objectPath))
4430 {
4431 expectEndTag(parser, "OBJECTPATH");
4432 return true;
4433 }
4434 else if (getInstancePathElement(parser, objectPath))
4435 {
4436 expectEndTag(parser, "OBJECTPATH");
4437 return true;
4438 }
4439 else
4440 {
|
4441 humberto 1.85
4442 // l10n
4443
4444 // throw XmlValidationError(parser.getLine(),
4445 // "expected INSTANCEPATH or CLASSPATH element");
4446
|
4447 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
4448 "expected INSTANCEPATH or CLASSPATH element");
|
4449 humberto 1.85
4450 throw XmlValidationError(parser.getLine(), mlParms);
|
4451 mike 1.23 }
4452
|
4453 mike 1.24 PEGASUS_UNREACHABLE ( return false; )
|
4454 mike 1.25 }
4455
4456 //------------------------------------------------------------------------------
4457 //
4458 // getEMethodCallStartTag()
4459 //
4460 //------------------------------------------------------------------------------
4461
4462 Boolean XmlReader::getEMethodCallStartTag(
4463 XmlParser& parser,
4464 const char*& name)
4465 {
4466 XmlEntry entry;
4467
4468 if (!testStartTag(parser, entry, "EXPMETHODCALL"))
4469 return false;
4470
4471 // Get EXPMETHODCALL.NAME attribute:
4472
|
4473 humberto 1.85
4474 if (!entry.getAttributeValue("NAME", name)) {
4475
4476 // l10n
4477
4478 // throw XmlValidationError(parser.getLine(),
4479 // "Missing EXPMETHODCALL.NAME attribute");
4480
|
4481 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",
4482 "Missing EXPMETHODCALL.NAME attribute");
|
4483 humberto 1.85
4484 throw XmlValidationError(parser.getLine(), mlParms);
4485 }
|
4486 mike 1.25
4487 return true;
4488 }
4489
4490 //------------------------------------------------------------------------------
4491 //
4492 // getEMethodResponseStartTag()
4493 //
4494 //------------------------------------------------------------------------------
4495
4496 Boolean XmlReader::getEMethodResponseStartTag(
4497 XmlParser& parser,
|
4498 kumpf 1.101 const char*& name,
4499 Boolean& isEmptyTag)
|
4500 mike 1.25 {
4501 XmlEntry entry;
4502
|
4503 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "EXPMETHODRESPONSE"))
|
4504 mike 1.25 return false;
4505
|
4506 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
4507
|
4508 mike 1.25 // Get EXPMETHODRESPONSE.NAME attribute:
4509
|
4510 humberto 1.85
4511 if (!entry.getAttributeValue("NAME", name)) {
4512 // l10n
4513
4514 // throw XmlValidationError(
4515 // parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute");
4516
|
4517 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",
4518 "Missing EXPMETHODRESPONSE.NAME attribute");
|
4519 humberto 1.85
4520 throw XmlValidationError(parser.getLine(), mlParms);
4521 }
|
4522 mike 1.25
4523 return true;
4524 }
4525
4526 //------------------------------------------------------------------------------
4527 //
|
4528 kumpf 1.83 // getEParamValueTag()
4529 //
4530 //------------------------------------------------------------------------------
4531
4532 Boolean XmlReader::getEParamValueTag(
4533 XmlParser& parser,
4534 const char*& name)
4535 {
4536 XmlEntry entry;
4537
4538 if (!testStartTag(parser, entry, "EXPPARAMVALUE"))
4539 return false;
4540
4541 // Get EXPPARAMVALUE.NAME attribute:
4542
|
4543 humberto 1.85
4544 if (!entry.getAttributeValue("NAME", name)) {
4545
4546 // l10n
4547
4548 // throw XmlValidationError(parser.getLine(),
4549 // "Missing EXPPARAMVALUE.NAME attribute");
4550
|
4551 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",
4552 "Missing EXPPARAMVALUE.NAME attribute");
|
4553 humberto 1.85
4554 throw XmlValidationError(parser.getLine(), mlParms);
4555 }
4556
4557
|
4558 kumpf 1.83
4559 return true;
4560 }
4561
4562 //------------------------------------------------------------------------------
4563 //
|
4564 mike 1.25 // getMethodCallStartTag()
4565 //
4566 //------------------------------------------------------------------------------
4567
4568 Boolean XmlReader::getMethodCallStartTag(
4569 XmlParser& parser,
4570 const char*& name)
4571 {
4572 XmlEntry entry;
4573
4574 if (!testStartTag(parser, entry, "METHODCALL"))
4575 return false;
4576
4577 // Get METHODCALL.NAME attribute:
4578
|
4579 humberto 1.85
4580 if (!entry.getAttributeValue("NAME", name)) {
4581
4582 // l10n
4583
4584 // throw XmlValidationError(parser.getLine(),
4585 // "Missing METHODCALL.NAME attribute");
4586
|
4587 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",
4588 "Missing METHODCALL.NAME attribute");
|
4589 humberto 1.85
4590 throw XmlValidationError(parser.getLine(), mlParms);
4591 }
4592
|
4593 mike 1.25
4594 return true;
4595 }
4596
4597 //------------------------------------------------------------------------------
4598 //
4599 // getMethodResponseStartTag()
4600 //
4601 //------------------------------------------------------------------------------
4602
4603 Boolean XmlReader::getMethodResponseStartTag(
4604 XmlParser& parser,
|
4605 kumpf 1.101 const char*& name,
4606 Boolean& isEmptyTag)
|
4607 mike 1.25 {
4608 XmlEntry entry;
4609
|
4610 kumpf 1.101 if (!testStartTagOrEmptyTag(parser, entry, "METHODRESPONSE"))
|
4611 mike 1.25 return false;
4612
|
4613 kumpf 1.101 isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
4614
|
4615 mike 1.25 // Get METHODRESPONSE.NAME attribute:
4616
|
4617 humberto 1.85
4618 if (!entry.getAttributeValue("NAME", name)) {
4619
4620 // l10n
4621
4622 // throw XmlValidationError(parser.getLine(),
4623 // "Missing METHODRESPONSE.NAME attribute");
4624
|
4625 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",
4626 "Missing METHODRESPONSE.NAME attribute");
|
4627 humberto 1.85
4628 throw XmlValidationError(parser.getLine(), mlParms);
4629 }
|
4630 mike 1.25
4631 return true;
4632 }
4633
4634 //------------------------------------------------------------------------------
4635 //
|
4636 kumpf 1.26 // getParamValueElement()
4637 //
4638 // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
4639 // <!ATTLIST PARAMVALUE
4640 // %CIMName;
4641 // %ParamType;>
|
4642 mike 1.25 //
4643 //------------------------------------------------------------------------------
4644
|
4645 kumpf 1.26 Boolean XmlReader::getParamValueElement(
|
4646 mike 1.25 XmlParser& parser,
|
4647 kumpf 1.26 CIMParamValue& paramValue)
|
4648 mike 1.25 {
4649 XmlEntry entry;
|
4650 kumpf 1.26 const char* name;
|
4651 marek 1.100 CIMType type=CIMTYPE_BOOLEAN;
|
4652 kumpf 1.26 CIMValue value;
|
4653 mike 1.25
|
4654 kumpf 1.26 if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))
|
4655 mike 1.25 return false;
4656
|
4657 kumpf 1.26 Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
4658
4659 // Get PARAMVALUE.NAME attribute:
|
4660 mike 1.25
|
4661 humberto 1.85 if (!entry.getAttributeValue("NAME", name)) {
4662
4663 // l10n
4664
4665 // throw XmlValidationError(parser.getLine(),
4666 // "Missing PARAMVALUE.NAME attribute");
4667
|
4668 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",
4669 "Missing PARAMVALUE.NAME attribute");
|
4670 humberto 1.85
4671 throw XmlValidationError(parser.getLine(), mlParms);
4672 }
4673
|
4674 kumpf 1.26
4675 // Get PARAMVALUE.PARAMTYPE attribute:
4676
|
4677 kumpf 1.67 Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,
4678 "PARAMVALUE", "PARAMTYPE", false);
|
4679 kumpf 1.26
4680 if (!empty)
4681 {
4682 // Parse VALUE.REFERENCE and VALUE.REFARRAY type
|
4683 kumpf 1.67 if ( (type == CIMTYPE_REFERENCE) || !gotType )
|
4684 kumpf 1.26 {
|
4685 kumpf 1.54 CIMObjectPath reference;
|
4686 kumpf 1.26 if (XmlReader::getValueReferenceElement(parser, reference))
4687 {
4688 value.set(reference);
|
4689 kumpf 1.61 type = CIMTYPE_REFERENCE;
|
4690 kumpf 1.67 gotType = true;
|
4691 kumpf 1.26 }
|
4692 kumpf 1.28 else if (XmlReader::getValueReferenceArrayElement(parser, value))
4693 {
|
4694 kumpf 1.61 type = CIMTYPE_REFERENCE;
|
4695 kumpf 1.67 gotType = true;
|
4696 kumpf 1.28 }
|
4697 kumpf 1.27 // If type==reference but no VALUE.REFERENCE found, use null value
|
4698 kumpf 1.26 }
4699
4700 // Parse non-reference value
|
4701 kumpf 1.61 if ( type != CIMTYPE_REFERENCE )
|
4702 kumpf 1.26 {
|
4703 kumpf 1.67 CIMType effectiveType;
4704 if (!gotType)
|
4705 kumpf 1.26 {
|
4706 kumpf 1.67 // If we don't know what type the value is, read it as a String
|
4707 kumpf 1.61 effectiveType = CIMTYPE_STRING;
|
4708 kumpf 1.26 }
|
4709 kumpf 1.67 else
4710 {
4711 effectiveType = type;
4712 }
|
4713 kumpf 1.26
4714 if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&
4715 !XmlReader::getValueElement(parser, effectiveType, value) )
4716 {
4717 value.clear(); // Isn't necessary; should already be cleared
4718 }
4719 }
4720
4721 expectEndTag(parser, "PARAMVALUE");
4722 }
4723
|
4724 kumpf 1.67 paramValue = CIMParamValue(name, value, gotType);
|
4725 kumpf 1.27
4726 return true;
4727 }
4728
4729 //------------------------------------------------------------------------------
4730 //
4731 // getReturnValueElement()
4732 //
4733 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
4734 // <!ATTLIST RETURNVALUE
4735 // %ParamType;>
4736 //
4737 //------------------------------------------------------------------------------
4738
4739 Boolean XmlReader::getReturnValueElement(
4740 XmlParser& parser,
4741 CIMValue& returnValue)
4742 {
4743 XmlEntry entry;
4744 CIMType type;
4745 CIMValue value;
4746 kumpf 1.27
4747 if (!testStartTag(parser, entry, "RETURNVALUE"))
4748 return false;
4749
4750 // Get RETURNVALUE.PARAMTYPE attribute:
4751 // NOTE: Array type return values are not allowed (2/20/02)
4752
|
4753 kumpf 1.67 Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,
4754 "RETURNVALUE", "PARAMTYPE", false);
|
4755 kumpf 1.27
4756 // Parse VALUE.REFERENCE type
|
4757 kumpf 1.67 if ( (type == CIMTYPE_REFERENCE) || !gotType )
|
4758 kumpf 1.27 {
|
4759 kumpf 1.54 CIMObjectPath reference;
|
4760 kumpf 1.27 if (XmlReader::getValueReferenceElement(parser, reference))
4761 {
4762 returnValue.set(reference);
|
4763 kumpf 1.61 type = CIMTYPE_REFERENCE;
|
4764 kumpf 1.67 gotType = true;
|
4765 kumpf 1.27 }
|
4766 kumpf 1.61 else if (type == CIMTYPE_REFERENCE)
|
4767 kumpf 1.27 {
|
4768 humberto 1.85
4769 // l10n
4770
4771 // throw XmlValidationError(parser.getLine(),
4772 // "expected VALUE.REFERENCE element");
4773
|
4774 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",
4775 "expected VALUE.REFERENCE element");
|
4776 humberto 1.85
4777 throw XmlValidationError(parser.getLine(), mlParms);
|
4778 kumpf 1.27 }
4779 }
4780
4781 // Parse non-reference return value
|
4782 kumpf 1.61 if ( type != CIMTYPE_REFERENCE )
|
4783 kumpf 1.27 {
|
4784 kumpf 1.67 if (!gotType)
|
4785 kumpf 1.27 {
|
4786 kumpf 1.67 // If we don't know what type the value is, read it as a String
|
4787 kumpf 1.61 type = CIMTYPE_STRING;
|
4788 kumpf 1.27 }
4789
4790 if ( !XmlReader::getValueElement(parser, type, returnValue) )
4791 {
|
4792 humberto 1.85
4793 // l10n
4794
4795 // throw XmlValidationError(parser.getLine(),
4796 // "expected VALUE element");
4797
|
4798 humberto 1.87 MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
4799 "expected VALUE element");
|
4800 humberto 1.85
4801 throw XmlValidationError(parser.getLine(), mlParms);
|
4802 kumpf 1.27 }
4803 }
4804
4805 expectEndTag(parser, "RETURNVALUE");
|
4806 mike 1.25
4807 return true;
|
4808 mike 1.23 }
4809
4810 PEGASUS_NAMESPACE_END
|
4811 s.hills 1.93
|
Return to
XmlReader.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common