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