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