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