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