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