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