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