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