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