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