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