1 marek 1.1.2.1 //%LICENSE////////////////////////////////////////////////////////////////
2 //
3 // 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 //
10 // 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 //
17 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 marek 1.1.2.1 // 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 //
28 //////////////////////////////////////////////////////////////////////////
29 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
32 #include <Pegasus/Common/Config.h>
33 #include <cstdlib>
34 #include <cstdio>
35 #include <Pegasus/Common/SCMOXmlWriter.h>
36
37 PEGASUS_NAMESPACE_BEGIN
38
|
39 marek 1.1.2.2 void SCMOXmlWriter::appendValueSCMOInstanceElement(
40 Buffer& out,
41 const SCMOInstance& scmoInstance)
42 {
43 out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
44
45 appendInstanceNameElement(out, scmoInstance);
46 appendInstanceElement(out, scmoInstance);
47
48 out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
49 }
50
51 void SCMOXmlWriter::appendInstanceNameElement(
52 Buffer& out,
53 const SCMOInstance& scmoInstance)
54 {
55 out << STRLIT("<INSTANCENAME CLASSNAME=\"");
56 Uint64 len;
57 const char * className = scmoInstance.getClassName_l(len);
58 out.append(className,len-1);
59 out << STRLIT("\">\n");
60 marek 1.1.2.2
61 for (Uint32 i = 0, n = scmoInstance.getKeyBindingCount(); i < n; i++)
62 {
63 const char * kbName;
64 const SCMBUnion * kbValue;
65 CIMType kbType;
66 Uint32 kbNameLen;
67
68 scmoInstance._getKeyBindingDataAtNodeIndex(
69 i,
70 &kbName,
71 kbNameLen,
72 kbType,
73 &kbValue);
74
75 out << STRLIT("<KEYBINDING NAME=\"");
76 out.append(kbName,kbNameLen-1);
77 out << STRLIT("\">\n");
78
79 if (kbType == CIMTYPE_REFERENCE)
80 {
81 marek 1.1.2.2 /*
82 TODO: NEED RESOLvE the value down to a SCMO....
83 CIMObjectPath ref = keyBindings[i].getValue();
84 appendValueReferenceElement(out, ref, true);
85 */
86 }
87 else
88 {
89 out << STRLIT("<KEYVALUE VALUETYPE=\"");
90 out << xmlWriterKeyTypeStrings(kbType);
91 out << STRLIT("\">");
92
93 SCMOXmlWriter::appendSCMBUnion(
94 out,
95 *kbValue,
96 kbType,
97 scmoInstance.inst.base);
98
99 out << STRLIT("</KEYVALUE>\n");
100 }
101 out << STRLIT("</KEYBINDING>\n");
102 marek 1.1.2.2 }
103 out << STRLIT("</INSTANCENAME>\n");
104 }
105
106 //------------------------------------------------------------------------------
107 //
108 // appendInstanceElement()
109 //
110 // <!ELEMENT INSTANCE
111 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
112 // <!ATTLIST INSTANCE
113 // %ClassName;>
114 //
115 //------------------------------------------------------------------------------
116 void SCMOXmlWriter::appendInstanceElement(
117 Buffer& out,
118 const SCMOInstance& scmoInstance)
119 {
120 // Class opening element:
121
122 out << STRLIT("<INSTANCE CLASSNAME=\"");
123 marek 1.1.2.2 Uint64 len;
124 const char * className = scmoInstance.getClassName_l(len);
125 out.append(className,len-1);
126 out << STRLIT("\" >\n");
127
128 // Append Instance Qualifiers:
129 if (scmoInstance.inst.hdr->flags.includeQualifiers)
130 {
131 SCMBClass_Main *classMain=scmoInstance.inst.hdr->theClass->cls.hdr;
132 char* clsbase = scmoInstance.inst.hdr->theClass->cls.base;
133
134 SCMBQualifier *theArray =
135 (SCMBQualifier*)&(clsbase[classMain->qualifierArray.start]);
136 // need to iterate
137 for (Uint32 i=0, n=classMain->numberOfQualifiers;i<n;i++)
138 {
139 SCMOXmlWriter::appendQualifierElement(out,theArray[i],clsbase);
140 }
141 }
142
143 // Append Properties:
144 marek 1.1.2.2 for (Uint32 i=0,k=scmoInstance.inst.hdr->numberProperties;i<k;i++)
145 {
146 if (scmoInstance.inst.hdr->flags.isFiltered &&
147 !scmoInstance._isPropertyInFilter(i))
148 {
149 // Property is filtered, ignore and go to next
150 continue;
151 }
152 else
153 {
154 SCMOXmlWriter::appendPropertyElement(out,scmoInstance,i);
155 }
156 }
157 // Instance closing element:
158 out << STRLIT("</INSTANCE>\n");
159 }
160
161 //------------------------------------------------------------------------------
162 //
163 // appendQualifierElement()
164 //
165 marek 1.1.2.2 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>
166 // <!ATTLIST QUALIFIER
167 // %CIMName;
168 // %CIMType; #REQUIRED
169 // %Propagated;
170 // %QualifierFlavor;>
171 //
172 //------------------------------------------------------------------------------
173
174 void SCMOXmlWriter::appendQualifierElement(
175 Buffer& out,
176 const SCMBQualifier& theQualifier,
177 const char* base)
178 {
179 out << STRLIT("<QUALIFIER NAME=\"");
180 if(theQualifier.name == QUALNAME_USERDEFINED)
181 {
182 if (theQualifier.userDefName.start)
183 {
184 out.append(
185 &(base[theQualifier.userDefName.start]),
186 marek 1.1.2.2 theQualifier.userDefName.length-1);
187 }
188 }
189 else
190 {
191 out << SCMOClass::qualifierNameStrLit(theQualifier.name);
192 }
193
194 out << STRLIT("\" ");
195
196 // Append type
197 out << xmlWriterTypeStrings(theQualifier.value.valueType);
198 // append PROPAGATED if set
199 if (theQualifier.propagated)
200 {
201 out << STRLIT(" PROPAGATED=\"true\"");
202 }
203 // append flavor of the qualifier
204 SCMOXmlWriter::appendQualifierFlavorEntity(
205 out,
206 CIMFlavor(theQualifier.flavor));
207 marek 1.1.2.2
208 out << STRLIT(">\n");
209 // append the value of the qualifier
210
211 // TODO: Implement and call appendValueElement
212 //SCMOXmlWriter::appendValueElement(out, theQualifier.value, clsbase);
213
214 out << STRLIT("</QUALIFIER>\n");
215 }
216
217 //------------------------------------------------------------------------------
218 //
219 // appendPropertyElement()
220 //
221 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
222 // <!ATTLIST PROPERTY
223 // %CIMName;
224 // %CIMType; #REQUIRED
225 // %ClassOrigin;
226 // %Propagated;>
227 //
228 marek 1.1.2.2 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
229 // <!ATTLIST PROPERTY.ARRAY
230 // %CIMName;
231 // %CIMType; #REQUIRED
232 // %ArraySize;
233 // %ClassOrigin;
234 // %Propagated;>
235 //
236 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>
237 // <!ATTLIST PROPERTY.REFERENCE
238 // %CIMName;
239 // %ReferenceClass;
240 // %ClassOrigin;
241 // %Propagated;>
242 //
243 //------------------------------------------------------------------------------
244
245 void SCMOXmlWriter::appendPropertyElement(
246 Buffer& out,
247 const SCMOInstance& scmoInstance,
248 Uint32 pos)
249 marek 1.1.2.2 {
250 // Get most of the property data from the instance
251 const char* propertyName;
252 Uint32 propertyNameLen;
253 CIMType propertyType;
254
255 // This is an absolute pointer at a SCMBValue
256 SCMBValue * propertyValue;
257 const char * propertyValueBase;
258 // This is an absolute pointer at a SCMBValue
259 SCMBClassProperty * propertyDef;
260 // This is the absolute pointer at which the class info for the given
261 // instance starts
262 const char* clsbase = scmoInstance.inst.hdr->theClass->cls.base;
263
264 SCMO_RC rc = scmoInstance.getPropertyAt(
265 pos,
266 &propertyValue,
267 &propertyValueBase,
268 &propertyDef);
269
270 marek 1.1.2.2 propertyType = propertyValue->valueType;
271
272
273 if (propertyValue->flags.isArray)
274 {
|
275 marek 1.1.2.3 out << STRLIT("<PROPERTY.ARRAY NAME=\"");
|
276 marek 1.1.2.2
|
277 marek 1.1.2.3 out.append(
278 &(clsbase[propertyDef->name.start]),
279 propertyDef->name.length-1);
280
281 out << STRLIT("\" ");
|
282 marek 1.1.2.2 if (propertyType == CIMTYPE_OBJECT)
283 {
|
284 marek 1.1.2.3 /*
|
285 marek 1.1.2.2 // If the property array type is CIMObject, then
286 // encode the property in CIM-XML as a string array with the
287 // EmbeddedObject attribute (there is not currently a CIM-XML
288 // "object" datatype)
289
290 Array<CIMObject> a;
291 rep->getValue().get(a);
292 out << STRLIT(" TYPE=\"string\"");
293 // If the Embedded Object is an instance, always add the
294 // EmbeddedObject attribute.
295 if (a.size() > 0 && a[0].isInstance())
296 {
297 out << STRLIT(" EmbeddedObject=\"object\""
298 " EMBEDDEDOBJECT=\"object\"");
299 }
300 #ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY
301 else
302 #endif
303 {
304 // Else the Embedded Object is a class, always add the
305 // EmbeddedObject qualifier. Note that if the macro
306 marek 1.1.2.2 // PEGASUS_SNIA_INTEROP_COMPATIBILITY is defined, then
307 // the EmbeddedObject qualifier will always be added,
308 // whether it's a class or an instance.
309 if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT)
310 == PEG_NOT_FOUND)
311 {
312 // Note that addQualifiers() cannot be called on a const
313 // CIMQualifierRep.In this case we really do want to add
314 // the EmbeddedObject qualifier, so we cast away the
315 // constness.
316 CIMPropertyRep* tmpRep=const_cast<CIMPropertyRep*>(rep);
317 tmpRep->addQualifier(
318 CIMQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT,
319 true));
320 }
321 }
|
322 marek 1.1.2.3 */
|
323 marek 1.1.2.2 }
324 else if (propertyType == CIMTYPE_INSTANCE)
325 {
|
326 marek 1.1.2.3 /*
|
327 marek 1.1.2.2 // If the property array type is CIMInstance, then
328 // encode the property in CIM-XML as a string array with the
329 // EmbeddedObject attribute (there is not currently a CIM-XML
330 // "instance" datatype)
331
332 Array<CIMInstance> a;
333 rep->getValue().get(a);
334 out << STRLIT(" TYPE=\"string\"");
335
336 // add the EmbeddedObject attribute
337 if (a.size() > 0)
338 {
339 out << STRLIT(" EmbeddedObject=\"instance\""
340 " EMBEDDEDOBJECT=\"instance\"");
341
342 // Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY
343 // is defined, then the EmbeddedInstance qualifier will be
344 // added
345 # ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY
346 if (rep->findQualifier(
347 PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE ==
348 marek 1.1.2.2 PEG_NOT_FOUND)
349 {
350 // Note that addQualifiers() cannot be called on a const
351 // CIMQualifierRep.In this case we really do want to add
352 // the EmbeddedInstance qualifier, so we cast away the
353 // constness.
354
355 // For now, we assume that all the embedded instances in
356 // the array are of the same type
357 CIMPropertyRep* tmpRep=const_cast<CIMPropertyRep*>(rep);
358 tmpRep->addQualifier(CIMQualifier(
359 PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE,
360 a[0].getClassName().getString()));
361 }
362 # endif
363 }
|
364 marek 1.1.2.3 */
|
365 marek 1.1.2.2 }
366 else
|
367 marek 1.1.2.3 {
|
368 marek 1.1.2.2 out.append(' ');
|
369 marek 1.1.2.3 out << xmlWriterTypeStrings(propertyType);
|
370 marek 1.1.2.2 }
|
371 marek 1.1.2.3
372 Uint32 arraySize=propertyValue->valueArraySize;
|
373 marek 1.1.2.2
|
374 marek 1.1.2.3 if (0 != arraySize)
|
375 marek 1.1.2.2 {
|
376 marek 1.1.2.3 out << STRLIT(" ARRAYSIZE=\"");
377 SCMOXmlWriter::append(out, arraySize);
|
378 marek 1.1.2.2 out.append('"');
379 }
380
|
381 marek 1.1.2.3
382 if (scmoInstance.inst.hdr->flags.includeClassOrigin)
|
383 marek 1.1.2.2 {
|
384 marek 1.1.2.3 if (propertyDef->originClassName.start != 0)
385 {
386 out << STRLIT(" CLASSORIGIN=\"");
387 out.append(
388 &(clsbase[propertyDef->originClassName.start]),
389 propertyDef->originClassName.length-1);
390 out.append('"');
391 }
|
392 marek 1.1.2.2 }
|
393 marek 1.1.2.3 if (propertyDef->flags.propagated)
|
394 marek 1.1.2.2 {
395 out << STRLIT(" PROPAGATED=\"true\"");
396 }
397
398 out << STRLIT(">\n");
399
|
400 marek 1.1.2.3 // Append Instance Qualifiers:
401 if (scmoInstance.inst.hdr->flags.includeQualifiers)
402 {
403 SCMBQualifier * theArray=
404 (SCMBQualifier*)
405 &(clsbase[propertyDef->qualifierArray.start]);
406 // need to iterate
407 for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++)
408 {
409 SCMOXmlWriter::appendQualifierElement(
410 out,
411 theArray[i],
412 clsbase);
413 }
414 }
|
415 marek 1.1.2.2
|
416 marek 1.1.2.3 SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
|
417 marek 1.1.2.2
418 out << STRLIT("</PROPERTY.ARRAY>\n");
419 }
420 else if (propertyType == CIMTYPE_REFERENCE)
421 {
422 /*
423 out << STRLIT("<PROPERTY.REFERENCE"
424 " NAME=\"") << rep->getName() << STRLIT("\" ");
425
426 if (!rep->getReferenceClassName().isNull())
427 {
428 out << STRLIT(" REFERENCECLASS=\"")
429 << rep->getReferenceClassName();
430 out.append('"');
431 }
432
433 if (!rep->getClassOrigin().isNull())
434 {
435 out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();
436 out.append('"');
437 }
438 marek 1.1.2.2
439 if (rep->getPropagated())
440 {
441 out << STRLIT(" PROPAGATED=\"true\"");
442 }
443
444 out << STRLIT(">\n");
445
446 for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)
447 XmlWriter::appendQualifierElement(out, rep->getQualifier(i));
448
449 XmlWriter::appendValueElement(out, rep->getValue());
450
451 out << STRLIT("</PROPERTY.REFERENCE>\n");
452 */
453 }
454 else
455 {
456 out << STRLIT("<PROPERTY NAME=\"");
457
458 out.append(
459 marek 1.1.2.2 &(clsbase[propertyDef->name.start]),
460 propertyDef->name.length-1);
461
462 out << STRLIT("\" ");
463
464 if (scmoInstance.inst.hdr->flags.includeClassOrigin)
465 {
466 if (propertyDef->originClassName.start != 0)
467 {
468 out << STRLIT(" CLASSORIGIN=\"");
469 out.append(
470 &(clsbase[propertyDef->originClassName.start]),
471 propertyDef->originClassName.length-1);
472 out.append('"');
473 }
474 }
475 if (propertyDef->flags.propagated)
476 {
477 out << STRLIT(" PROPAGATED=\"true\"");
478 }
479
480 marek 1.1.2.2 if (propertyType == CIMTYPE_OBJECT)
481 {
482 /*
483 // If the property type is CIMObject, then
484 // encode the property in CIM-XML as a string with the
485 // EmbeddedObject attribute (there is not currently a CIM-XML
486 // "object" datatype)
487
488 CIMObject a;
489 rep->getValue().get(a);
490 out << STRLIT(" TYPE=\"string\"");
491
492 // If the Embedded Object is an instance, always add the
493 // EmbeddedObject attribute.
494 if (a.isInstance())
495 {
496 out << STRLIT(" EmbeddedObject=\"object\""
497 " EMBEDDEDOBJECT=\"object\"");
498 }
499 // Else the Embedded Object is a class, always add the
500 // EmbeddedObject qualifier.
501 marek 1.1.2.2 #ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY
502 else
503 #endif
504 {
505 // Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY
506 // is defined, then the EmbeddedObject qualifier will always
507 // be added, whether it's a class or an instance.
508 if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT)
509 == PEG_NOT_FOUND)
510 {
511 // Note that addQualifiers() cannot be called on a const
512 // CIMQualifierRep. In this case we really do want to
513 // add the EmbeddedObject qualifier, so we cast away the
514 // constness.
515 CIMPropertyRep* tmpRep=const_cast<CIMPropertyRep*>(rep);
516 tmpRep->addQualifier(
517 CIMQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT,
518 true));
519 }
520 }
521 */
522 marek 1.1.2.2 }
523 else if (propertyType == CIMTYPE_INSTANCE)
524 {
525 /*
526 CIMInstance a;
527 rep->getValue().get(a);
528 out << STRLIT(" TYPE=\"string\""
529 " EmbeddedObject=\"instance\""
530 " EMBEDDEDOBJECT=\"instance\"");
531
532 # ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY
533 if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT)
534 == PEG_NOT_FOUND)
535 {
536 // Note that addQualifiers() cannot be called on a const
537 // CIMQualifierRep. In this case we really do want to add
538 // the EmbeddedInstance qualifier, so we cast away the
539 // constness.
540 CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);
541 tmpRep->addQualifier(CIMQualifier(
542 PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE,
543 marek 1.1.2.2 a.getClassName().getString()));
544 }
545 # endif
546 */
547 }
548 else
549 {
550 out.append(' ');
551 out << xmlWriterTypeStrings(propertyType);
552 }
553 out << STRLIT(">\n");
554
555 // Append Instance Qualifiers:
556 if (scmoInstance.inst.hdr->flags.includeQualifiers)
557 {
558 SCMBQualifier * theArray=
559 (SCMBQualifier*)
560 &(clsbase[propertyDef->qualifierArray.start]);
561 // need to iterate
562 for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++)
563 {
564 marek 1.1.2.2 SCMOXmlWriter::appendQualifierElement(
565 out,
566 theArray[i],
567 clsbase);
568 }
569 }
|
570 marek 1.1.2.3 SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
|
571 marek 1.1.2.2 out << STRLIT("</PROPERTY>\n");
572 }
573 }
574 //------------------------------------------------------------------------------
575 //
576 // appendValueElement()
577 //
578 // <!ELEMENT VALUE (#PCDATA)>
579 // <!ELEMENT VALUE.ARRAY (VALUE*)>
580 // <!ELEMENT VALUE.REFERENCE
581 // (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
582 // INSTANCENAME)>
583 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
584 //
585 //------------------------------------------------------------------------------
586
587 void SCMOXmlWriter::appendValueElement(
588 Buffer& out,
589 SCMBValue & value,
590 const char * base)
591 {
592 marek 1.1.2.2 if (value.flags.isNull)
593 {
594 return;
595 }
596 if (value.flags.isArray)
597 {
|
598 marek 1.1.2.3 appendSCMBUnionArray(
599 out,
600 value.value,
601 value.valueType,
602 value.valueArraySize,
603 base);
|
604 marek 1.1.2.2 }
605 else if (value.valueType == CIMTYPE_REFERENCE)
606 {
607 /*
608 // Has to be separate because it uses VALUE.REFERENCE tag
609 CIMObjectPath v;
610 value.get(v);
611 _xmlWritter_appendValue(out, v);
612 */
613 }
614 else
615 {
616 out << STRLIT("<VALUE>");
617
618 // Call function to write a SCMBUnion + type field
619 appendSCMBUnion(out,value.value, value.valueType,base);
620
621 out << STRLIT("</VALUE>\n");
622 }
623 }
624
625 marek 1.1.2.2 void SCMOXmlWriter::appendSCMBUnion(
626 Buffer& out,
627 const SCMBUnion & u,
628 const CIMType & valueType,
629 const char * base)
630 {
631 switch (valueType)
632 {
633 case CIMTYPE_BOOLEAN:
634 {
635 SCMOXmlWriter::append(out, u.simple.val.bin);
636 break;
637 }
638
639 case CIMTYPE_UINT8:
640 {
641 SCMOXmlWriter::append(out, u.simple.val.u8);
642 break;
643 }
644
645 case CIMTYPE_SINT8:
646 marek 1.1.2.2 {
647 SCMOXmlWriter::append(out, u.simple.val.s8);
648 break;
649 }
650
651 case CIMTYPE_UINT16:
652 {
653 SCMOXmlWriter::append(out, u.simple.val.u16);
654 break;
655 }
656
657 case CIMTYPE_SINT16:
658 {
659 SCMOXmlWriter::append(out, u.simple.val.s16);
660 break;
661 }
662
663 case CIMTYPE_UINT32:
664 {
665 SCMOXmlWriter::append(out, u.simple.val.u32);
666 break;
667 marek 1.1.2.2 }
668
669 case CIMTYPE_SINT32:
670 {
671 SCMOXmlWriter::append(out, u.simple.val.s32);
672 break;
673 }
674
675 case CIMTYPE_UINT64:
676 {
677 SCMOXmlWriter::append(out, u.simple.val.u64);
678 break;
679 }
680
681 case CIMTYPE_SINT64:
682 {
683 SCMOXmlWriter::append(out, u.simple.val.s64);
684 break;
685 }
686
687 case CIMTYPE_REAL32:
688 marek 1.1.2.2 {
689 SCMOXmlWriter::append(out, u.simple.val.r32);
690 break;
691 }
692
693 case CIMTYPE_REAL64:
694 {
695 SCMOXmlWriter::append(out, u.simple.val.r64);
696 break;
697 }
698
699 case CIMTYPE_CHAR16:
700 {
701 SCMOXmlWriter::appendSpecial(
702 out,
703 u.simple.val.c16);
704 break;
705 }
706
707 case CIMTYPE_STRING:
708 {
709 marek 1.1.2.2 SCMOXmlWriter::appendSpecial(
710 out,
711 &(base[u.stringValue.start]),
712 u.stringValue.length-1);
713 break;
714 }
715
716 case CIMTYPE_DATETIME:
717 {
718 // an SCMBDateTime is a CIMDateTimeRep
719 // this should help us to reuse existing optimized Datetime
720 char buffer[26];
721 _DateTimetoCStr(&(u.dateTimeValue), buffer);
722 // datetime value is formatted with a \0 at end, ignore
723 out.append(buffer,sizeof(buffer)-1);
724 break;
725 }
726 /*
727 case CIMTYPE_OBJECT:
728 {
729 CIMObject v;
730 marek 1.1.2.2 value.get(v);
731 _xmlWritter_appendValue(out, v);
732 break;
733 }
734 case CIMTYPE_INSTANCE:
735 {
736 CIMInstance v;
737 value.get(v);
738 _xmlWritter_appendValue(out, v);
739 break;
740 }
741 default:
742 PEGASUS_ASSERT(false);
743 */
744 }
745 }
746
|
747 marek 1.1.2.3 void SCMOXmlWriter::appendSCMBUnionArray(
748 Buffer& out,
749 const SCMBUnion & u,
750 const CIMType & valueType,
751 Uint32 numElements,
752 const char * base)
753 {
754 SCMBUnion* arr = (SCMBUnion*) &(base[u.arrayValue.start]);
755 switch (valueType)
756 {
757 case CIMTYPE_BOOLEAN:
758 {
759 out << STRLIT("<VALUE.ARRAY>\n");
760 while (numElements--)
761 {
762 out << STRLIT("<VALUE>");
763 SCMOXmlWriter::append(out, arr->simple.val.bin);
764 arr++;
765 out << STRLIT("</VALUE>\n");
766 }
767 out << STRLIT("</VALUE.ARRAY>\n");
768 marek 1.1.2.3 break;
769 }
770 case CIMTYPE_UINT8:
771 {
772 out << STRLIT("<VALUE.ARRAY>\n");
773 while (numElements--)
774 {
775 out << STRLIT("<VALUE>");
776 SCMOXmlWriter::append(out, arr->simple.val.u8);
777 arr++;
778 out << STRLIT("</VALUE>\n");
779 }
780 out << STRLIT("</VALUE.ARRAY>\n");
781 break;
782 }
783
784 case CIMTYPE_SINT8:
785 {
786 out << STRLIT("<VALUE.ARRAY>\n");
787 while (numElements--)
788 {
789 marek 1.1.2.3 out << STRLIT("<VALUE>");
790 SCMOXmlWriter::append(out, arr->simple.val.s8);
791 arr++;
792 out << STRLIT("</VALUE>\n");
793 }
794 out << STRLIT("</VALUE.ARRAY>\n");
795 break;
796 }
797
798 case CIMTYPE_UINT16:
799 {
800 out << STRLIT("<VALUE.ARRAY>\n");
801 while (numElements--)
802 {
803 out << STRLIT("<VALUE>");
804 SCMOXmlWriter::append(out, arr->simple.val.u16);
805 arr++;
806 out << STRLIT("</VALUE>\n");
807 }
808 out << STRLIT("</VALUE.ARRAY>\n");
809 break;
810 marek 1.1.2.3 }
811
812 case CIMTYPE_SINT16:
813 {
814 out << STRLIT("<VALUE.ARRAY>\n");
815 while (numElements--)
816 {
817 out << STRLIT("<VALUE>");
818 SCMOXmlWriter::append(out, arr->simple.val.s16);
819 arr++;
820 out << STRLIT("</VALUE>\n");
821 }
822 out << STRLIT("</VALUE.ARRAY>\n");
823 break;
824 }
825
826 case CIMTYPE_UINT32:
827 {
828 out << STRLIT("<VALUE.ARRAY>\n");
829 while (numElements--)
830 {
831 marek 1.1.2.3 out << STRLIT("<VALUE>");
832 SCMOXmlWriter::append(out, arr->simple.val.u32);
833 arr++;
834 out << STRLIT("</VALUE>\n");
835 }
836 out << STRLIT("</VALUE.ARRAY>\n");
837 break;
838 }
839
840 case CIMTYPE_SINT32:
841 {
842 out << STRLIT("<VALUE.ARRAY>\n");
843 while (numElements--)
844 {
845 out << STRLIT("<VALUE>");
846 SCMOXmlWriter::append(out, arr->simple.val.s32);
847 arr++;
848 out << STRLIT("</VALUE>\n");
849 }
850 out << STRLIT("</VALUE.ARRAY>\n");
851 break;
852 marek 1.1.2.3 }
853
854 case CIMTYPE_UINT64:
855 {
856 out << STRLIT("<VALUE.ARRAY>\n");
857 while (numElements--)
858 {
859 out << STRLIT("<VALUE>");
860 SCMOXmlWriter::append(out, arr->simple.val.u64);
861 arr++;
862 out << STRLIT("</VALUE>\n");
863 }
864 out << STRLIT("</VALUE.ARRAY>\n");
865 break;
866 }
867
868 case CIMTYPE_SINT64:
869 {
870 out << STRLIT("<VALUE.ARRAY>\n");
871 while (numElements--)
872 {
873 marek 1.1.2.3 out << STRLIT("<VALUE>");
874 SCMOXmlWriter::append(out, arr->simple.val.s64);
875 arr++;
876 out << STRLIT("</VALUE>\n");
877 }
878 out << STRLIT("</VALUE.ARRAY>\n");
879 break;
880 }
881
882 case CIMTYPE_REAL32:
883 {
884 out << STRLIT("<VALUE.ARRAY>\n");
885 while (numElements--)
886 {
887 out << STRLIT("<VALUE>");
888 SCMOXmlWriter::append(out, arr->simple.val.r32);
889 arr++;
890 out << STRLIT("</VALUE>\n");
891 }
892 out << STRLIT("</VALUE.ARRAY>\n");
893 break;
894 marek 1.1.2.3 }
895
896 case CIMTYPE_REAL64:
897 {
898 out << STRLIT("<VALUE.ARRAY>\n");
899 while (numElements--)
900 {
901 out << STRLIT("<VALUE>");
902 SCMOXmlWriter::append(out, arr->simple.val.r64);
903 arr++;
904 out << STRLIT("</VALUE>\n");
905 }
906 out << STRLIT("</VALUE.ARRAY>\n");
907 break;
908 }
909
910 case CIMTYPE_CHAR16:
911 {
912 out << STRLIT("<VALUE.ARRAY>\n");
913 while (numElements--)
914 {
915 marek 1.1.2.3 out << STRLIT("<VALUE>");
916 SCMOXmlWriter::append(out, arr->simple.val.bin);
917 SCMOXmlWriter::appendSpecial(out, arr->simple.val.c16);
918 arr++;
919 out << STRLIT("</VALUE>\n");
920 }
921 out << STRLIT("</VALUE.ARRAY>\n");
922 break;
923 }
924
925 case CIMTYPE_STRING:
926 {
927 out << STRLIT("<VALUE.ARRAY>\n");
928 while (numElements--)
929 {
930 out << STRLIT("<VALUE>");
931 SCMOXmlWriter::appendSpecial(
932 out,
933 &(base[arr->stringValue.start]),
934 arr->stringValue.length-1);
935 arr++;
936 marek 1.1.2.3 out << STRLIT("</VALUE>\n");
937 }
938 out << STRLIT("</VALUE.ARRAY>\n");
939
940 break;
941 }
942
943 case CIMTYPE_DATETIME:
944 {
945 out << STRLIT("<VALUE.ARRAY>\n");
946 char buffer[26];
947 while (numElements--)
948 {
949 out << STRLIT("<VALUE>");
950 // an SCMBDateTime is a CIMDateTimeRep
951 // this should help us to reuse existing optimized Datetime
952 _DateTimetoCStr(&(arr->dateTimeValue), buffer);
953 // datetime value is formatted with a \0 at end, ignore
954 out.append(buffer,sizeof(buffer)-1);
955 arr++;
956 out << STRLIT("</VALUE>\n");
957 marek 1.1.2.3 }
958 out << STRLIT("</VALUE.ARRAY>\n");
959 break;
960 }
961 /*
962 case CIMTYPE_OBJECT:
963 {
964 CIMObject v;
965 value.get(v);
966 _xmlWritter_appendValue(out, v);
967 break;
968 }
969 case CIMTYPE_INSTANCE:
970 {
971 CIMInstance v;
972 value.get(v);
973 _xmlWritter_appendValue(out, v);
974 break;
975 }
976 default:
977 PEGASUS_ASSERT(false);
978 marek 1.1.2.3 */
979 }
980
981 }
982
983
|
984 marek 1.1.2.2
|
985 marek 1.1.2.1 PEGASUS_NAMESPACE_END
|
Return to
SCMOXmlWriter.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common