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