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