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