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