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