1 thilo.boehm 1.2 //%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 thilo.boehm 1.2 // 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 karl 1.4.2.5 // This code implements part of PEP#348 - The CMPI infrastructure using SCMO
31 // (Single Chunk Memory Objects).
32 // The design document can be found on the OpenPegasus website openpegasus.org
33 // at https://collaboration.opengroup.org/pegasus/pp/documents/21210/PEP_348.pdf
34 //
|
35 thilo.boehm 1.2 //%/////////////////////////////////////////////////////////////////////////////
36
37 #include <Pegasus/Common/Config.h>
38 #include <cstdlib>
39 #include <cstdio>
40 #include <Pegasus/Common/SCMOXmlWriter.h>
|
41 karl 1.4.2.2 #include "Tracer.h"
|
42 thilo.boehm 1.2
43 PEGASUS_NAMESPACE_BEGIN
|
44 karl 1.4.2.7 void SCMOXmlWriter::buildPropertyFilterNodesArray(
45 Array<Uint32> & nodes,
46 const SCMOClass * classPtr,
47 const CIMPropertyList & propertyList)
48 {
49 for (Uint32 i=0,k=propertyList.size(); i<k; i++)
50 {
51 Uint32 node = 0;
52 const CIMName & name = propertyList[i];
53 SCMO_RC rc =
54 classPtr->_getProperyNodeIndex(
55 node,
56 (const char *)name.getString().getCString());
57 if(rc == SCMO_OK)
58 {
59 nodes.append(node);
60 }
61 }
|
62 karl 1.4.2.2 }
63
64 const Array<Uint32> & SCMOXmlWriter::getFilteredNodesArray(
65 Array<propertyFilterNodesArray_t> & propFilterNodesArrays,
66 const SCMOInstance& scmoInstance,
67 const CIMPropertyList & propertyList)
68 {
69 //First see if the class ptr is already stored in the propFilterNodesArrays
70 const SCMOClass * classPtr = scmoInstance.inst.hdr->theClass.ptr;
71 SCMBClass_Main * classPtrMemBlock = classPtr->cls.hdr;
72 for (int i=0, k=propFilterNodesArrays.size(); i < k; i++)
73 {
74 if (classPtrMemBlock == propFilterNodesArrays[i].classPtrMemBlock)
75 {
76 return propFilterNodesArrays[i].nodes;
77 }
78 }
79
80 // Could not find the class pointer of this SCMOInstance in the
81 // property filter nodes array
82 // --> need to create the new entry and return that
83 karl 1.4.2.2 propertyFilterNodesArray_t newEntry;
84 newEntry.classPtrMemBlock = classPtrMemBlock;
85 SCMOXmlWriter::buildPropertyFilterNodesArray(
86 newEntry.nodes,
87 classPtr,
88 propertyList);
89 propFilterNodesArrays.append(newEntry);
90
91 // return the new nodes entry, but as a reference into the array
92 return propFilterNodesArrays[propFilterNodesArrays.size()-1].nodes;
93 }
94
95 void SCMOXmlWriter::appendValueSCMOInstanceElements(
96 Buffer& out,
97 const Array<SCMOInstance> & _scmoInstances,
98 const CIMPropertyList & propertyList)
99 {
100 if (propertyList.isNull())
101 {
102 Array<Uint32> emptyNodes;
103 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
104 karl 1.4.2.2 {
105 SCMOXmlWriter::appendValueSCMOInstanceElement(
106 out,
107 _scmoInstances[i],
108 false,
109 emptyNodes);
110 }
111 }
112 else
113 {
114 Array<propertyFilterNodesArray_t> propFilterNodesArrays;
115
116 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
117 {
118 // This searches for an already created array of nodes,
119 // if not found, creates it inside propFilterNodesArrays
120 const Array<Uint32> & nodes=
121 SCMOXmlWriter::getFilteredNodesArray(
122 propFilterNodesArrays,
123 _scmoInstances[i],
124 propertyList);
125 karl 1.4.2.2
126 SCMOXmlWriter::appendValueSCMOInstanceElement(
127 out,
128 _scmoInstances[i],
129 true,
130 nodes);
131 }
132 }
133 }
|
134 karl 1.4.2.3
135 // EXP_PULL_BEGIN
|
136 karl 1.4.2.2 void SCMOXmlWriter::appendValueSCMOInstanceWithPathElements(
137 Buffer& out,
138 const Array<SCMOInstance> & _scmoInstances,
139 const CIMPropertyList & propertyList)
140 {
141 if (propertyList.isNull())
142 {
143 Array<Uint32> emptyNodes;
144 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
145 {
|
146 karl 1.4.2.6 SCMOXmlWriter::appendValueInstanceWithPathElement(
|
147 karl 1.4.2.2 out,
148 _scmoInstances[i],
149 false,
150 emptyNodes);
151 }
152 }
153 else
154 {
155 Array<propertyFilterNodesArray_t> propFilterNodesArrays;
156
157 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
158 {
159 // This searches for an already created array of nodes,
160 // if not found, creates it inside propFilterNodesArrays
161 const Array<Uint32> & nodes=
162 SCMOXmlWriter::getFilteredNodesArray(
163 propFilterNodesArrays,
164 _scmoInstances[i],
165 propertyList);
166
|
167 karl 1.4.2.6 SCMOXmlWriter::appendValueInstanceWithPathElement(
|
168 karl 1.4.2.2 out,
169 _scmoInstances[i],
170 true,
171 nodes);
172 }
173 }
174 }
|
175 karl 1.4.2.3 //EXP_PULL_END
|
176 thilo.boehm 1.2
|
177 karl 1.4.2.1 // KS_TODO - Show the XML statement for this function
|
178 thilo.boehm 1.2 void SCMOXmlWriter::appendValueSCMOInstanceElement(
179 Buffer& out,
|
180 karl 1.4.2.2 const SCMOInstance& scmoInstance,
|
181 karl 1.4.2.7 bool filtered,
182 const Array<Uint32> & nodes)
183
|
184 thilo.boehm 1.2 {
185 out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
186
187 appendInstanceNameElement(out, scmoInstance);
|
188 karl 1.4.2.2 appendInstanceElement(out, scmoInstance,filtered,nodes);
|
189 thilo.boehm 1.2
190 out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
191 }
192
|
193 karl 1.4.2.1
|
194 thilo.boehm 1.2 void SCMOXmlWriter::appendInstanceNameElement(
195 Buffer& out,
196 const SCMOInstance& scmoInstance)
197 {
198 out << STRLIT("<INSTANCENAME CLASSNAME=\"");
199 Uint32 len;
200 const char * className = scmoInstance.getClassName_l(len);
201 out.append(className,len);
202 // TODO: check performance impact
203 out.append('"','>','\n');
204
205 for (Uint32 i = 0, n = scmoInstance.getKeyBindingCount(); i < n; i++)
206 {
207 const char * kbName;
208 const SCMBUnion * kbValue;
209 CIMType kbType;
210 Uint32 kbNameLen;
211
212 SCMO_RC smrc = scmoInstance._getKeyBindingDataAtNodeIndex(
213 i,
214 &kbName,
215 thilo.boehm 1.2 kbNameLen,
216 kbType,
217 &kbValue);
218
219 out << STRLIT("<KEYBINDING NAME=\"");
220 out.append(kbName,kbNameLen-1);
221 out.append('"','>','\n');
222
223 if (kbType == CIMTYPE_REFERENCE)
224 {
225 if (SCMO_OK == smrc)
226 {
227 SCMOInstance * ref = kbValue->extRefPtr;
228 appendValueReferenceElement(out, *ref, true);
229 }
230 }
231 else
232 {
233 out << STRLIT("<KEYVALUE VALUETYPE=\"");
234 out << xmlWriterKeyTypeStrings(kbType);
235 out.append('"','>');
236 thilo.boehm 1.2
237 if (SCMO_OK == smrc)
238 {
239 SCMOXmlWriter::appendSCMBUnion(
240 out,
241 *kbValue,
242 kbType,
243 scmoInstance.inst.base);
244 }
245 out << STRLIT("</KEYVALUE>\n");
246 }
247 out << STRLIT("</KEYBINDING>\n");
248 }
249 out << STRLIT("</INSTANCENAME>\n");
250 }
251
252 //------------------------------------------------------------------------------
253 //
254 // appendInstanceElement()
255 //
256 // <!ELEMENT INSTANCE
257 thilo.boehm 1.2 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
258 // <!ATTLIST INSTANCE
259 // %ClassName;>
260 //
261 //------------------------------------------------------------------------------
262 void SCMOXmlWriter::appendInstanceElement(
263 Buffer& out,
|
264 karl 1.4.2.2 const SCMOInstance& scmoInstance,
|
265 karl 1.4.2.7 bool filtered,
266 const Array<Uint32> & nodes)
|
267 thilo.boehm 1.2 {
268 // Class opening element:
269
270 out << STRLIT("<INSTANCE CLASSNAME=\"");
271 Uint32 len;
272 const char * className = scmoInstance.getClassName_l(len);
273 out.append(className,len);
274 out.append('"',' ','>','\n');
275 //out << STRLIT("\" >\n");
276
277 // Append Instance Qualifiers:
278 if (scmoInstance.inst.hdr->flags.includeQualifiers)
279 {
280 SCMBClass_Main *classMain=scmoInstance.inst.hdr->theClass.ptr->cls.hdr;
281 char* clsbase = scmoInstance.inst.hdr->theClass.ptr->cls.base;
282
283 SCMBQualifier *theArray =
284 (SCMBQualifier*)&(clsbase[classMain->qualifierArray.start]);
285 // need to iterate
286 for (Uint32 i=0, n=classMain->numberOfQualifiers;i<n;i++)
287 {
288 thilo.boehm 1.2 SCMOXmlWriter::appendQualifierElement(out,theArray[i],clsbase);
289 }
290 }
291
292 // Append Properties:
|
293 karl 1.4.2.2 if(!filtered)
|
294 thilo.boehm 1.2 {
|
295 karl 1.4.2.2 for (Uint32 i=0,k=scmoInstance.inst.hdr->numberProperties;i<k;i++)
296 {
297 SCMOXmlWriter::appendPropertyElement(out,scmoInstance,i);
|
298 karl 1.4.2.7 }
|
299 karl 1.4.2.2 }
300 else
301 {
302 for (Uint32 i=0,k=nodes.size();i<k;i++)
303 {
304 SCMOXmlWriter::appendPropertyElement(out,scmoInstance,nodes[i]);
305 }
|
306 thilo.boehm 1.2 }
307 // Instance closing element:
308 out << STRLIT("</INSTANCE>\n");
309 }
310
311 //------------------------------------------------------------------------------
312 //
313 // appendQualifierElement()
314 //
315 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>
316 // <!ATTLIST QUALIFIER
317 // %CIMName;
318 // %CIMType; #REQUIRED
319 // %Propagated;
320 // %QualifierFlavor;>
321 //
322 //------------------------------------------------------------------------------
323
324 void SCMOXmlWriter::appendQualifierElement(
325 Buffer& out,
326 const SCMBQualifier& theQualifier,
327 thilo.boehm 1.2 const char* base)
328 {
329 out << STRLIT("<QUALIFIER NAME=\"");
330 if(theQualifier.name == QUALNAME_USERDEFINED)
331 {
332 if (theQualifier.userDefName.start)
333 {
334 out.append(
335 &(base[theQualifier.userDefName.start]),
336 theQualifier.userDefName.size-1);
337 }
338 }
339 else
340 {
341 out << SCMOClass::qualifierNameStrLit(theQualifier.name);
342 }
343 out.append('"',' ');
344 //out << STRLIT("\" ");
345
346 // Append type
347 out << xmlWriterTypeStrings(theQualifier.value.valueType);
348 thilo.boehm 1.2 // append PROPAGATED if set
349 if (theQualifier.propagated)
350 {
351 out << STRLIT(" PROPAGATED=\"true\"");
352 }
353 // append flavor of the qualifier
354 SCMOXmlWriter::appendQualifierFlavorEntity(
355 out,
356 CIMFlavor(theQualifier.flavor));
357
358 out.append('>','\n');
359 //out << STRLIT(">\n");
360 // append the value of the qualifier
361 SCMOXmlWriter::appendValueElement(out, theQualifier.value, base);
362
363 out << STRLIT("</QUALIFIER>\n");
364 }
365
366 //------------------------------------------------------------------------------
367 //
368 // appendPropertyElement()
369 thilo.boehm 1.2 //
370 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
371 // <!ATTLIST PROPERTY
372 // %CIMName;
373 // %CIMType; #REQUIRED
374 // %ClassOrigin;
375 // %Propagated;>
376 //
377 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
378 // <!ATTLIST PROPERTY.ARRAY
379 // %CIMName;
380 // %CIMType; #REQUIRED
381 // %ArraySize;
382 // %ClassOrigin;
383 // %Propagated;>
384 //
385 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>
386 // <!ATTLIST PROPERTY.REFERENCE
387 // %CIMName;
388 // %ReferenceClass;
389 // %ClassOrigin;
390 thilo.boehm 1.2 // %Propagated;>
391 //
392 //------------------------------------------------------------------------------
393 void SCMOXmlWriter::appendPropertyElement(
394 Buffer& out,
395 const SCMOInstance& scmoInstance,
396 Uint32 pos)
397 {
398 CIMType propertyType;
399
400 // This is an absolute pointer at a SCMBValue
401 SCMBValue * propertyValue;
402 const char * propertyValueBase;
403 // This is an absolute pointer at a SCMBValue
404 SCMBClassProperty * propertyDef;
405 // This is the absolute pointer at which the class info for the given
406 // instance starts
407 const char* clsbase = scmoInstance.inst.hdr->theClass.ptr->cls.base;
408
409 scmoInstance._getPropertyAt(
410 pos,
411 thilo.boehm 1.2 &propertyValue,
412 &propertyValueBase,
413 &propertyDef);
414
415 propertyType = propertyValue->valueType;
416
417 if (propertyValue->flags.isArray)
418 {
419 Uint32 arraySize=propertyValue->valueArraySize;
420
421 out << STRLIT("<PROPERTY.ARRAY NAME=\"");
422
423 out.append(
424 &(clsbase[propertyDef->name.start]),
|
425 r.kieninger 1.3 (propertyDef->name.size-1));
|
426 thilo.boehm 1.2
427 out.append('"',' ');
428 //out << STRLIT("\" ");
429 if (propertyType == CIMTYPE_OBJECT)
430 {
431 // If the property array type is CIMObject, then
432 // encode the property in CIM-XML as a string array with the
433 // EmbeddedObject attribute (there is not currently a CIM-XML
434 // "object" datatype)
435 out << STRLIT(" TYPE=\"string\"");
436 // If the Embedded Object is an instance, always add the
437 // EmbeddedObject attribute.
438 SCMOInstance * instPtr = propertyValue->value.extRefPtr;
439 if ((0 != instPtr) &&
440 (arraySize > 0) &&
441 !(instPtr->inst.hdr->flags.isClassOnly))
442 {
443 out << STRLIT(" EmbeddedObject=\"object\""
444 " EMBEDDEDOBJECT=\"object\"");
445 }
446 }
447 thilo.boehm 1.2 else if (propertyType == CIMTYPE_INSTANCE)
448 {
449 // If the property array type is CIMInstance, then
450 // encode the property in CIM-XML as a string array with the
451 // EmbeddedObject attribute (there is not currently a CIM-XML
452 // "instance" datatype)
453 out << STRLIT(" TYPE=\"string\"");
454 // add the EmbeddedObject attribute
455 if (arraySize > 0)
456 {
457 out << STRLIT(" EmbeddedObject=\"instance\""
458 " EMBEDDEDOBJECT=\"instance\"");
459 }
460 }
461 else
462 {
463 out.append(' ');
464 out << xmlWriterTypeStrings(propertyType);
465 }
466
467 if (0 != arraySize)
468 thilo.boehm 1.2 {
469 out << STRLIT(" ARRAYSIZE=\"");
470 SCMOXmlWriter::append(out, arraySize);
471 out.append('"');
472 }
473
474
475 if (scmoInstance.inst.hdr->flags.includeClassOrigin)
476 {
477 if (propertyDef->originClassName.start != 0)
478 {
479 out << STRLIT(" CLASSORIGIN=\"");
480 out.append(
481 &(clsbase[propertyDef->originClassName.start]),
|
482 r.kieninger 1.3 (propertyDef->originClassName.size-1));
|
483 thilo.boehm 1.2 out.append('"');
484 }
485 }
486 if (propertyDef->flags.propagated)
487 {
488 out << STRLIT(" PROPAGATED=\"true\"");
489 }
490
491 out.append('>','\n');
492 //out << STRLIT(">\n");
493
494 // Append Instance Qualifiers:
495 if (scmoInstance.inst.hdr->flags.includeQualifiers)
496 {
497 SCMBQualifier * theArray=
498 (SCMBQualifier*)
499 &(clsbase[propertyDef->qualifierArray.start]);
500 // need to iterate
501 for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++)
502 {
503 SCMOXmlWriter::appendQualifierElement(
504 thilo.boehm 1.2 out,
505 theArray[i],
506 clsbase);
507 }
508 }
509 SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
510 out << STRLIT("</PROPERTY.ARRAY>\n");
511 }
512 else if (propertyType == CIMTYPE_REFERENCE)
513 {
514 out << STRLIT("<PROPERTY.REFERENCE NAME=\"");
515 out.append(
516 &(clsbase[propertyDef->name.start]),
|
517 r.kieninger 1.3 (propertyDef->name.size-1));
|
518 thilo.boehm 1.2 out.append('"',' ');
519 //out << STRLIT("\" ");
520
521 if (0 != propertyDef->refClassName.start)
522 {
523 out << STRLIT(" REFERENCECLASS=\"");
524 out.append(
525 &(clsbase[propertyDef->refClassName.start]),
|
526 r.kieninger 1.3 (propertyDef->refClassName.size-1));
|
527 thilo.boehm 1.2 out.append('"');
528 }
529
530 if (scmoInstance.inst.hdr->flags.includeClassOrigin)
531 {
532 if (propertyDef->originClassName.start != 0)
533 {
534 out << STRLIT(" CLASSORIGIN=\"");
535 out.append(
536 &(clsbase[propertyDef->originClassName.start]),
|
537 r.kieninger 1.3 (propertyDef->originClassName.size-1));
|
538 thilo.boehm 1.2 out.append('"');
539 }
540 }
541 if (propertyDef->flags.propagated)
542 {
543 out << STRLIT(" PROPAGATED=\"true\"");
544 }
545 out.append('>','\n');
546 //out << STRLIT(">\n");
547 // Append Instance Qualifiers:
548 if (scmoInstance.inst.hdr->flags.includeQualifiers)
549 {
550 SCMBQualifier * theArray=
551 (SCMBQualifier*)
552 &(clsbase[propertyDef->qualifierArray.start]);
553 // need to iterate
554 for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++)
555 {
556 SCMOXmlWriter::appendQualifierElement(
557 out,
558 theArray[i],
559 thilo.boehm 1.2 clsbase);
560 }
561 }
562 SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
563 out << STRLIT("</PROPERTY.REFERENCE>\n");
564 }
565 else
566 {
567 out << STRLIT("<PROPERTY NAME=\"");
568
569 out.append(
570 &(clsbase[propertyDef->name.start]),
|
571 r.kieninger 1.3 (propertyDef->name.size-1));
|
572 thilo.boehm 1.2
573 out.append('"',' ');
574 //out << STRLIT("\" ");
575
576 if (scmoInstance.inst.hdr->flags.includeClassOrigin)
577 {
578 if (propertyDef->originClassName.start != 0)
579 {
580 out << STRLIT(" CLASSORIGIN=\"");
581 out.append(
582 &(clsbase[propertyDef->originClassName.start]),
|
583 r.kieninger 1.3 (propertyDef->originClassName.size-1));
|
584 thilo.boehm 1.2 out.append('"');
585 }
586 }
587 if (propertyDef->flags.propagated)
588 {
589 out << STRLIT(" PROPAGATED=\"true\"");
590 }
591
592 if (propertyType == CIMTYPE_OBJECT)
593 {
594 // If the property type is CIMObject, then
595 // encode the property in CIM-XML as a string with the
596 // EmbeddedObject attribute (there is not currently a CIM-XML
597 // "object" datatype)
598 out << STRLIT(" TYPE=\"string\"");
599 // If the Embedded Object is an instance, always add the
600 // EmbeddedObject attribute.
601 SCMOInstance * a = propertyValue->value.extRefPtr;
602 if (a && !(a->inst.hdr->flags.isClassOnly))
603 {
604 out << STRLIT(" EmbeddedObject=\"object\""
605 thilo.boehm 1.2 " EMBEDDEDOBJECT=\"object\"");
606 }
|
607 marek 1.4 }
608 else if (propertyType == CIMTYPE_INSTANCE)
609 {
610 out << STRLIT(" TYPE=\"string\""
611 " EmbeddedObject=\"instance\""
612 " EMBEDDEDOBJECT=\"instance\"");
|
613 thilo.boehm 1.2 }
614 else
615 {
616 out.append(' ');
617 out << xmlWriterTypeStrings(propertyType);
618 }
619 out.append('>','\n');
620 //out << STRLIT(">\n");
621
622 // Append Instance Qualifiers:
623 if (scmoInstance.inst.hdr->flags.includeQualifiers)
624 {
625 SCMBQualifier * theArray=
626 (SCMBQualifier*)
627 &(clsbase[propertyDef->qualifierArray.start]);
628 // need to iterate
629 for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++)
630 {
631 SCMOXmlWriter::appendQualifierElement(
632 out,
633 theArray[i],
634 thilo.boehm 1.2 clsbase);
635 }
636 }
637 SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
638 out << STRLIT("</PROPERTY>\n");
639 }
640 }
641 //------------------------------------------------------------------------------
642 //
643 // appendValueElement()
644 //
645 // <!ELEMENT VALUE (#PCDATA)>
646 // <!ELEMENT VALUE.ARRAY (VALUE*)>
647 // <!ELEMENT VALUE.REFERENCE
648 // (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
649 // INSTANCENAME)>
650 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
651 //
652 //------------------------------------------------------------------------------
653
654 void SCMOXmlWriter::appendValueElement(
655 thilo.boehm 1.2 Buffer& out,
656 const SCMBValue & value,
657 const char * base)
658 {
659 if (value.flags.isNull)
660 {
661 return;
662 }
663 if (value.flags.isArray)
664 {
665 appendSCMBUnionArray(
666 out,
667 value.value,
668 value.valueType,
669 value.valueArraySize,
670 base);
671 }
672 else if (value.valueType == CIMTYPE_REFERENCE)
673 {
674 SCMOInstance * ref = value.value.extRefPtr;
675 if (ref)
676 thilo.boehm 1.2 {
677 appendValueReferenceElement(out, *ref, true);
678 }
679 }
680 else
681 {
682 out << STRLIT("<VALUE>");
683
684 // Call function to write a SCMBUnion + type field
685 appendSCMBUnion(out,value.value, value.valueType,base);
686
687 out << STRLIT("</VALUE>\n");
688 }
689 }
690
691 //------------------------------------------------------------------------------
692 //
693 // appendValueReferenceElement()
694 //
695 // <!ELEMENT VALUE.REFERENCE
696 // (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
697 thilo.boehm 1.2 // INSTANCENAME)>
698 //
699 //------------------------------------------------------------------------------
700 void SCMOXmlWriter::appendValueReferenceElement(
701 Buffer& out,
702 const SCMOInstance& ref,
703 Boolean putValueWrapper)
704 {
705 if (putValueWrapper)
706 {
707 out << STRLIT("<VALUE.REFERENCE>\n");
708 }
709
710 // See if it is a class or instance reference (instance references have
711 // key-bindings; class references do not).
712
713 // differentiate between instance and class using the SCMO flag
714 if (ref.inst.hdr->flags.isClassOnly)
715 {
716 // class
717 if (0 != ref.inst.hdr->hostName.start)
718 thilo.boehm 1.2 {
719 appendClassPathElement(out, ref);
720 }
721 else if (0 != ref.inst.hdr->instNameSpace.start)
722 {
723 appendLocalClassPathElement(out, ref);
724 }
725 else
726 {
727 Uint32 classNameLength=0;
728 const char* className = ref.getClassName_l(classNameLength);
729 appendClassNameElement(out, className, classNameLength);
730 }
731 }
732 else
733 {
734 // instance
735 if (0 != ref.inst.hdr->hostName.start)
736 {
737 appendInstancePathElement(out, ref);
738 }
739 thilo.boehm 1.2 else if (0 != ref.inst.hdr->instNameSpace.start)
740 {
741 appendLocalInstancePathElement(out, ref);
742 }
743 else
744 {
745 appendInstanceNameElement(out, ref);
746 }
747 }
748 if (putValueWrapper)
749 {
750 out << STRLIT("</VALUE.REFERENCE>\n");
751 }
752 }
753
754 // appendLocalInstancePathElement()
755 // <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)>
756 void SCMOXmlWriter::appendLocalInstancePathElement(
757 Buffer& out,
758 const SCMOInstance& instancePath)
759 {
760 thilo.boehm 1.2 out << STRLIT("<LOCALINSTANCEPATH>\n");
761 Uint32 nsLength=0;
762 const char* ns=instancePath.getNameSpace_l(nsLength);
763 appendLocalNameSpacePathElement(out, ns, nsLength);
764 appendInstanceNameElement(out, instancePath);
765 out << STRLIT("</LOCALINSTANCEPATH>\n");
766 }
767
768 // appendInstancePathElement()
769 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
770 void SCMOXmlWriter::appendInstancePathElement(
771 Buffer& out,
772 const SCMOInstance& instancePath)
773 {
774 out << STRLIT("<INSTANCEPATH>\n");
775
776 Uint32 hostnameLength=0;
777 const char* hostname=instancePath.getHostName_l(hostnameLength);
778 Uint32 nsLength=0;
779 const char* ns=instancePath.getNameSpace_l(nsLength);
780 appendNameSpacePathElement(out,hostname,hostnameLength,ns,nsLength);
781 thilo.boehm 1.2
782 appendInstanceNameElement(out, instancePath);
783 out << STRLIT("</INSTANCEPATH>\n");
784 }
|
785 karl 1.4.2.4
|
786 karl 1.4.2.2 void SCMOXmlWriter::appendValueObjectWithPathElement(
787 Buffer& out,
788 const Array<SCMOInstance> & objectWithPath,
789 const CIMPropertyList& propertyList)
790 {
|
791 karl 1.4.2.7 if (propertyList.isNull())
792 {
793 Array<Uint32> emptyNodes;
794 for (Uint32 i = 0, n = objectWithPath.size(); i < n; i++)
795 {
|
796 karl 1.4.2.2 SCMOXmlWriter::appendValueObjectWithPathElement(
797 out,
798 objectWithPath[i],
799 false,
800 emptyNodes);
|
801 karl 1.4.2.7 }
|
802 karl 1.4.2.2 }
803 else
804 {
805 Array<propertyFilterNodesArray_t> propFilterNodesArrays;
|
806 karl 1.4.2.7 for (Uint32 i = 0, n = objectWithPath.size(); i < n; i++)
|
807 karl 1.4.2.2 {
|
808 karl 1.4.2.7 // This searches for an already created array of nodes,
809 // if not found, creates it inside propFilterNodesArrays
810 const Array<Uint32> & nodes=
811 SCMOXmlWriter::getFilteredNodesArray(
812 propFilterNodesArrays,
813 objectWithPath[i],
|
814 karl 1.4.2.2 propertyList);
815 SCMOXmlWriter::appendValueObjectWithPathElement(
816 out,
817 objectWithPath[i],
818 true,
|
819 karl 1.4.2.7 nodes);
|
820 karl 1.4.2.2
821 }
822 }
823 }
|
824 thilo.boehm 1.2
|
825 karl 1.4.2.3 //EXP_PULL_BEGIN
|
826 karl 1.4.2.1 //------------------------------------------------------------------------------
827 //
828 // appendValueInstanceWithPathElement()
829 //
830 // <!ELEMENT VALUE.INSTANCEWITHPATH (INSTANCEPATH,INSTANCE)>
831 //
832 //------------------------------------------------------------------------------
833 // EXP_PULL_TBD checkout the INSTANCEPATH vs NAMEDINSTANCE differences
834 // Can we create something more common
835 void SCMOXmlWriter::appendValueInstanceWithPathElement(
836 Buffer& out,
|
837 karl 1.4.2.2 const SCMOInstance& namedInstance,
838 bool filtered,
839 const Array<Uint32> & nodes)
|
840 karl 1.4.2.1 {
841 out << STRLIT("<VALUE.INSTANCEWITHPATH>\n");
842
843 appendInstancePathElement(out, namedInstance);
|
844 karl 1.4.2.2 appendInstanceElement(out, namedInstance, filtered, nodes);
|
845 karl 1.4.2.1
846 out << STRLIT("</VALUE.INSTANCEWITHPATH>\n");
847 }
|
848 karl 1.4.2.3 //EXP_PULL_END
|
849 karl 1.4.2.1
|
850 thilo.boehm 1.2 // appendValueObjectWithPathElement()
851 // <!ELEMENT VALUE.OBJECTWITHPATH
852 // ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
853 void SCMOXmlWriter::appendValueObjectWithPathElement(
854 Buffer& out,
|
855 karl 1.4.2.2 const SCMOInstance& objectWithPath,
|
856 karl 1.4.2.7 bool filtered,
857 const Array<Uint32> & nodes)
|
858 thilo.boehm 1.2 {
859 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
860
861 appendValueReferenceElement(out, objectWithPath, false);
|
862 karl 1.4.2.2 appendObjectElement(out, objectWithPath,filtered,nodes);
|
863 thilo.boehm 1.2
864 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
865 }
866
867 // appendObjectElement()
868 // May refer to a CLASS or an INSTANCE
869 void SCMOXmlWriter::appendObjectElement(
870 Buffer& out,
|
871 karl 1.4.2.2 const SCMOInstance& object,
872 bool filtered,
873 const Array<Uint32> & nodes)
|
874 thilo.boehm 1.2 {
875 if (object.inst.hdr->flags.isClassOnly)
876 {
877 appendClassElement(out, object);
878 }
879 else
880 {
|
881 karl 1.4.2.2 appendInstanceElement(out, object,filtered,nodes);
|
882 thilo.boehm 1.2 }
883 }
884
885 //------------------------------------------------------------------------------
886 //
887 // appendClassElement()
888 //
889 // <!ELEMENT CLASS
890 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
891 // <!ATTLIST CLASS
892 // %CIMName;
893 // %SuperClass;>
894 //
895 //------------------------------------------------------------------------------
896
897 void SCMOXmlWriter::appendClassElement(
898 Buffer& out,
899 const SCMOInstance& cimClass)
900 {
901
902 SCMBClass_Main* ptrClass = cimClass.inst.hdr->theClass.ptr->cls.hdr;
903 thilo.boehm 1.2 const char* clsBase = cimClass.inst.hdr->theClass.ptr->cls.base;
904
905 // Class opening element:
906 out << STRLIT("<CLASS NAME=\"");
907 out.append(
908 &(clsBase[ptrClass->className.start]),
|
909 r.kieninger 1.3 (ptrClass->className.size-1));
|
910 thilo.boehm 1.2
911 out.append('"',' ');
912 if (0 != ptrClass->superClassName.start)
913 {
914 out << STRLIT(" SUPERCLASS=\"");
915 out.append(
916 &(clsBase[ptrClass->superClassName.start]),
|
917 r.kieninger 1.3 (ptrClass->superClassName.size-1));
|
918 thilo.boehm 1.2 out.append('"',' ');
919 }
920 out.append('>','\n');
921
922 // Append class qualifiers
923 SCMBQualifier *theArray =
924 (SCMBQualifier*)&(clsBase[ptrClass->qualifierArray.start]);
925 for (Uint32 i=0, n=ptrClass->numberOfQualifiers;i<n;i++)
926 {
927 SCMOXmlWriter::appendQualifierElement(out,theArray[i],clsBase);
928 }
929
930 // Append Property definitions:
931 for (Uint32 i=0,k=cimClass.getPropertyCount();i<k;i++)
932 {
933 SCMOXmlWriter::appendPropertyElement(out,cimClass,i);
934 }
935
936 // ATTN: No method definitions with SCMO today, so do nothing with them
937 // Actually this code does not serve a purpose, but is kept here
938 // for completeness.
939 thilo.boehm 1.2
940 // Class closing element:
941 out << STRLIT("</CLASS>\n");
942 }
943
944 // appendLocalClassPathElement()
945 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>
946 void SCMOXmlWriter::appendLocalClassPathElement(
947 Buffer& out,
948 const SCMOInstance& classPath)
949 {
950 out << STRLIT("<LOCALCLASSPATH>\n");
951 Uint32 hostnameLength=0;
952 const char* hostname=classPath.getHostName_l(hostnameLength);
953 Uint32 nsLength=0;
954 const char* ns=classPath.getNameSpace_l(nsLength);
955
956 appendNameSpacePathElement(out,hostname,hostnameLength,ns,nsLength);
957
958 Uint32 classNameLength=0;
959 const char* className = classPath.getClassName_l(classNameLength);
960 thilo.boehm 1.2 appendClassNameElement(out, className, classNameLength);
961 out << STRLIT("</LOCALCLASSPATH>\n");
962 }
963
964 // appendClassPathElement()
965 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
966 void SCMOXmlWriter::appendClassPathElement(
967 Buffer& out,
968 const SCMOInstance& classPath)
969 {
970 out << STRLIT("<CLASSPATH>\n");
971
972 Uint32 hostnameLength=0;
973 const char* hostname=classPath.getHostName_l(hostnameLength);
974 Uint32 nsLength=0;
975 const char* ns=classPath.getNameSpace_l(nsLength);
976
977 appendNameSpacePathElement(out,hostname,hostnameLength,ns,nsLength);
978
979 Uint32 classNameLength=0;
980 const char* className = classPath.getClassName_l(classNameLength);
981 thilo.boehm 1.2
982 appendClassNameElement(out, className, classNameLength);
983 out << STRLIT("</CLASSPATH>\n");
984 }
985
986 void SCMOXmlWriter::appendSCMBUnion(
987 Buffer& out,
988 const SCMBUnion & u,
989 const CIMType & valueType,
990 const char * base)
991 {
992 switch (valueType)
993 {
994 case CIMTYPE_BOOLEAN:
995 {
996 if (u.simple.hasValue)
997 {
998 SCMOXmlWriter::append(out, u.simple.val.bin);
999 }
1000 break;
1001 }
1002 thilo.boehm 1.2
1003 case CIMTYPE_UINT8:
1004 {
1005 if (u.simple.hasValue)
1006 {
1007 SCMOXmlWriter::append(out, u.simple.val.u8);
1008 }
1009 break;
1010 }
1011
1012 case CIMTYPE_SINT8:
1013 {
1014 if (u.simple.hasValue)
1015 {
1016 SCMOXmlWriter::append(out, u.simple.val.s8);
1017 }
1018 break;
1019 }
1020
1021 case CIMTYPE_UINT16:
1022 {
1023 thilo.boehm 1.2 if (u.simple.hasValue)
1024 {
1025 SCMOXmlWriter::append(out, u.simple.val.u16);
1026 }
1027 break;
1028 }
1029
1030 case CIMTYPE_SINT16:
1031 {
1032 if (u.simple.hasValue)
1033 {
1034 SCMOXmlWriter::append(out, u.simple.val.s16);
1035 }
1036 break;
1037 }
1038
1039 case CIMTYPE_UINT32:
1040 {
1041 if (u.simple.hasValue)
1042 {
1043 SCMOXmlWriter::append(out, u.simple.val.u32);
1044 thilo.boehm 1.2 }
1045 break;
1046 }
1047
1048 case CIMTYPE_SINT32:
1049 {
1050 if (u.simple.hasValue)
1051 {
1052 SCMOXmlWriter::append(out, u.simple.val.s32);
1053 }
1054 break;
1055 }
1056
1057 case CIMTYPE_UINT64:
1058 {
1059 if (u.simple.hasValue)
1060 {
1061 SCMOXmlWriter::append(out, u.simple.val.u64);
1062 }
1063 break;
1064 }
1065 thilo.boehm 1.2
1066 case CIMTYPE_SINT64:
1067 {
1068 if (u.simple.hasValue)
1069 {
1070 SCMOXmlWriter::append(out, u.simple.val.s64);
1071 }
1072 break;
1073 }
1074
1075 case CIMTYPE_REAL32:
1076 {
1077 if (u.simple.hasValue)
1078 {
1079 SCMOXmlWriter::append(out, u.simple.val.r32);
1080 }
1081 break;
1082 }
1083
1084 case CIMTYPE_REAL64:
1085 {
1086 thilo.boehm 1.2 if (u.simple.hasValue)
1087 {
1088 SCMOXmlWriter::append(out, u.simple.val.r64);
1089 }
1090 break;
1091 }
1092
1093 case CIMTYPE_CHAR16:
1094 {
1095 if (u.simple.hasValue)
1096 {
1097 SCMOXmlWriter::appendSpecial(
1098 out,
1099 Char16(u.simple.val.c16));
1100 }
1101 break;
1102 }
1103
1104 case CIMTYPE_STRING:
1105 {
1106 if (u.stringValue.start)
1107 thilo.boehm 1.2 {
1108 SCMOXmlWriter::appendSpecial(
1109 out,
1110 &(base[u.stringValue.start]),
|
1111 r.kieninger 1.3 (u.stringValue.size-1));
|
1112 thilo.boehm 1.2 }
1113 break;
1114 }
1115
1116 case CIMTYPE_DATETIME:
1117 {
1118 // an SCMBDateTime is a CIMDateTimeRep
1119 // this should help us to reuse existing optimized Datetime
1120 char buffer[26];
1121 _DateTimetoCStr(u.dateTimeValue, buffer);
1122 // datetime value is formatted with a \0 at end, ignore
1123 out.append(buffer,sizeof(buffer)-1);
1124 break;
1125 }
1126 // Object and Instance are both written the same way, namely as
1127 // object element which then is encoded using appendSpecial
1128 case CIMTYPE_OBJECT:
1129 case CIMTYPE_INSTANCE:
1130 {
1131 Buffer toEncodeObject(4000);
1132 SCMOInstance * obj = u.extRefPtr;
1133 thilo.boehm 1.2 if (obj)
1134 {
1135 appendObjectElement(toEncodeObject, *obj);
1136 SCMOXmlWriter::appendSpecial(
1137 out,
1138 toEncodeObject.getData(),
1139 toEncodeObject.size());
1140 }
1141 break;
1142 }
1143 default:
1144 // CIMTYPE_REFERENCE has been handled upfront, do nothing here
1145 break;
1146 }
1147 }
1148
1149 void SCMOXmlWriter::appendSCMBUnionArray(
1150 Buffer& out,
1151 const SCMBUnion & u,
1152 const CIMType & valueType,
1153 Uint32 numElements,
1154 thilo.boehm 1.2 const char * base)
1155 {
1156 SCMBUnion* arr = (SCMBUnion*) &(base[u.arrayValue.start]);
1157 switch (valueType)
1158 {
1159 case CIMTYPE_BOOLEAN:
1160 {
1161 out << STRLIT("<VALUE.ARRAY>\n");
1162 while (numElements--)
1163 {
1164 out << STRLIT("<VALUE>");
1165 SCMOXmlWriter::append(out, arr->simple.val.bin);
1166 arr++;
1167 out << STRLIT("</VALUE>\n");
1168 }
1169 out << STRLIT("</VALUE.ARRAY>\n");
1170 break;
1171 }
1172 case CIMTYPE_UINT8:
1173 {
1174 out << STRLIT("<VALUE.ARRAY>\n");
1175 thilo.boehm 1.2 while (numElements--)
1176 {
1177 out << STRLIT("<VALUE>");
1178 SCMOXmlWriter::append(out, arr->simple.val.u8);
1179 arr++;
1180 out << STRLIT("</VALUE>\n");
1181 }
1182 out << STRLIT("</VALUE.ARRAY>\n");
1183 break;
1184 }
1185
1186 case CIMTYPE_SINT8:
1187 {
1188 out << STRLIT("<VALUE.ARRAY>\n");
1189 while (numElements--)
1190 {
1191 out << STRLIT("<VALUE>");
1192 SCMOXmlWriter::append(out, arr->simple.val.s8);
1193 arr++;
1194 out << STRLIT("</VALUE>\n");
1195 }
1196 thilo.boehm 1.2 out << STRLIT("</VALUE.ARRAY>\n");
1197 break;
1198 }
1199
1200 case CIMTYPE_UINT16:
1201 {
1202 out << STRLIT("<VALUE.ARRAY>\n");
1203 while (numElements--)
1204 {
1205 out << STRLIT("<VALUE>");
1206 SCMOXmlWriter::append(out, arr->simple.val.u16);
1207 arr++;
1208 out << STRLIT("</VALUE>\n");
1209 }
1210 out << STRLIT("</VALUE.ARRAY>\n");
1211 break;
1212 }
1213
1214 case CIMTYPE_SINT16:
1215 {
1216 out << STRLIT("<VALUE.ARRAY>\n");
1217 thilo.boehm 1.2 while (numElements--)
1218 {
1219 out << STRLIT("<VALUE>");
1220 SCMOXmlWriter::append(out, arr->simple.val.s16);
1221 arr++;
1222 out << STRLIT("</VALUE>\n");
1223 }
1224 out << STRLIT("</VALUE.ARRAY>\n");
1225 break;
1226 }
1227
1228 case CIMTYPE_UINT32:
1229 {
1230 out << STRLIT("<VALUE.ARRAY>\n");
1231 while (numElements--)
1232 {
1233 out << STRLIT("<VALUE>");
1234 SCMOXmlWriter::append(out, arr->simple.val.u32);
1235 arr++;
1236 out << STRLIT("</VALUE>\n");
1237 }
1238 thilo.boehm 1.2 out << STRLIT("</VALUE.ARRAY>\n");
1239 break;
1240 }
1241
1242 case CIMTYPE_SINT32:
1243 {
1244 out << STRLIT("<VALUE.ARRAY>\n");
1245 while (numElements--)
1246 {
1247 out << STRLIT("<VALUE>");
1248 SCMOXmlWriter::append(out, arr->simple.val.s32);
1249 arr++;
1250 out << STRLIT("</VALUE>\n");
1251 }
1252 out << STRLIT("</VALUE.ARRAY>\n");
1253 break;
1254 }
1255
1256 case CIMTYPE_UINT64:
1257 {
1258 out << STRLIT("<VALUE.ARRAY>\n");
1259 thilo.boehm 1.2 while (numElements--)
1260 {
1261 out << STRLIT("<VALUE>");
1262 SCMOXmlWriter::append(out, arr->simple.val.u64);
1263 arr++;
1264 out << STRLIT("</VALUE>\n");
1265 }
1266 out << STRLIT("</VALUE.ARRAY>\n");
1267 break;
1268 }
1269
1270 case CIMTYPE_SINT64:
1271 {
1272 out << STRLIT("<VALUE.ARRAY>\n");
1273 while (numElements--)
1274 {
1275 out << STRLIT("<VALUE>");
1276 SCMOXmlWriter::append(out, arr->simple.val.s64);
1277 arr++;
1278 out << STRLIT("</VALUE>\n");
1279 }
1280 thilo.boehm 1.2 out << STRLIT("</VALUE.ARRAY>\n");
1281 break;
1282 }
1283
1284 case CIMTYPE_REAL32:
1285 {
1286 out << STRLIT("<VALUE.ARRAY>\n");
1287 while (numElements--)
1288 {
1289 out << STRLIT("<VALUE>");
1290 SCMOXmlWriter::append(out, arr->simple.val.r32);
1291 arr++;
1292 out << STRLIT("</VALUE>\n");
1293 }
1294 out << STRLIT("</VALUE.ARRAY>\n");
1295 break;
1296 }
1297
1298 case CIMTYPE_REAL64:
1299 {
1300 out << STRLIT("<VALUE.ARRAY>\n");
1301 thilo.boehm 1.2 while (numElements--)
1302 {
1303 out << STRLIT("<VALUE>");
1304 SCMOXmlWriter::append(out, arr->simple.val.r64);
1305 arr++;
1306 out << STRLIT("</VALUE>\n");
1307 }
1308 out << STRLIT("</VALUE.ARRAY>\n");
1309 break;
1310 }
1311
1312 case CIMTYPE_CHAR16:
1313 {
1314 out << STRLIT("<VALUE.ARRAY>\n");
1315 while (numElements--)
1316 {
1317 out << STRLIT("<VALUE>");
1318 SCMOXmlWriter::appendSpecial(out, Char16(arr->simple.val.c16));
1319 arr++;
1320 out << STRLIT("</VALUE>\n");
1321 }
1322 thilo.boehm 1.2 out << STRLIT("</VALUE.ARRAY>\n");
1323 break;
1324 }
1325
1326 case CIMTYPE_STRING:
1327 {
1328 out << STRLIT("<VALUE.ARRAY>\n");
1329 while (numElements--)
1330 {
1331 out << STRLIT("<VALUE>");
1332 if (0!=arr->stringValue.start)
1333 {
1334 SCMOXmlWriter::appendSpecial(
1335 out,
1336 &(base[arr->stringValue.start]),
|
1337 r.kieninger 1.3 (arr->stringValue.size-1));
|
1338 thilo.boehm 1.2 }
1339 arr++;
1340 out << STRLIT("</VALUE>\n");
1341 }
1342 out << STRLIT("</VALUE.ARRAY>\n");
1343
1344 break;
1345 }
1346
1347 case CIMTYPE_DATETIME:
1348 {
1349 out << STRLIT("<VALUE.ARRAY>\n");
1350 char buffer[26];
1351 while (numElements--)
1352 {
1353 out << STRLIT("<VALUE>");
1354 // an SCMBDateTime is a CIMDateTimeRep
1355 // this should help us to reuse existing optimized Datetime
1356 _DateTimetoCStr(arr->dateTimeValue, buffer);
1357 // datetime value is formatted with a \0 at end, ignore
1358 out.append(buffer,sizeof(buffer)-1);
1359 thilo.boehm 1.2 arr++;
1360 out << STRLIT("</VALUE>\n");
1361 }
1362 out << STRLIT("</VALUE.ARRAY>\n");
1363 break;
1364 }
1365 case CIMTYPE_REFERENCE:
1366 {
1367 out << STRLIT("<VALUE.REFARRAY>\n");
1368 while (numElements--)
1369 {
1370 SCMOInstance * ref = arr->extRefPtr;
1371 if (ref)
1372 {
1373 appendValueReferenceElement(out, *ref, true);
1374 }
1375 arr++;
1376 }
1377 out << STRLIT("</VALUE.REFARRAY>\n");
|
1378 karl 1.4.2.2 break;
|
1379 thilo.boehm 1.2 }
1380 case CIMTYPE_OBJECT:
1381 case CIMTYPE_INSTANCE:
1382 {
1383 out << STRLIT("<VALUE.ARRAY>\n");
1384 Buffer toEncodeObject(4000);
1385 while (numElements--)
1386 {
1387 toEncodeObject.clear();
1388 out << STRLIT("<VALUE>");
1389 SCMOInstance * obj = arr->extRefPtr;
1390 if (obj)
1391 {
1392 appendObjectElement(toEncodeObject, *obj);
1393 SCMOXmlWriter::appendSpecial(
1394 out,
1395 toEncodeObject.getData(),
1396 toEncodeObject.size());
1397 }
1398 arr++;
1399 out << STRLIT("</VALUE>\n");
1400 thilo.boehm 1.2 }
1401 out << STRLIT("</VALUE.ARRAY>\n");
1402 break;
1403 }
1404 default:
1405 PEGASUS_DEBUG_ASSERT(false);
1406 }
1407
1408 }
1409
1410
1411
1412 PEGASUS_NAMESPACE_END
|
Return to
SCMOXmlWriter.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common