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