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