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