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