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 karl 1.4.2.10 appendValueReferenceElement(out, *ref);
|
228 thilo.boehm 1.2 }
229 }
230 else
231 {
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 thilo.boehm 1.2 }
250
251 //------------------------------------------------------------------------------
252 //
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 karl 1.4.2.10 appendValueReferenceElement(out, *ref);
|
677 thilo.boehm 1.2 }
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 // INSTANCENAME)>
697 //
698 thilo.boehm 1.2 //------------------------------------------------------------------------------
699 void SCMOXmlWriter::appendValueReferenceElement(
700 Buffer& out,
|
701 karl 1.4.2.10 const SCMOInstance& ref)
|
702 thilo.boehm 1.2 {
|
703 karl 1.4.2.10 out << STRLIT("<VALUE.REFERENCE>\n");
704
705 appendClassOrInstancePathElement(out, ref);
706
707 out << STRLIT("</VALUE.REFERENCE>\n");
708 }
|
709 thilo.boehm 1.2
|
710 karl 1.4.2.10 // Append either a class or instance Path Element
711 void SCMOXmlWriter::appendClassOrInstancePathElement(
712 Buffer& out,
713 const SCMOInstance& ref)
714 {
|
715 thilo.boehm 1.2 // See if it is a class or instance reference (instance references have
716 // key-bindings; class references do not).
717
718 // differentiate between instance and class using the SCMO flag
719 if (ref.inst.hdr->flags.isClassOnly)
720 {
721 // class
722 if (0 != ref.inst.hdr->hostName.start)
723 {
724 appendClassPathElement(out, ref);
725 }
726 else if (0 != ref.inst.hdr->instNameSpace.start)
727 {
728 appendLocalClassPathElement(out, ref);
729 }
730 else
731 {
732 Uint32 classNameLength=0;
733 const char* className = ref.getClassName_l(classNameLength);
734 appendClassNameElement(out, className, classNameLength);
735 }
736 thilo.boehm 1.2 }
737 else
738 {
739 // instance
740 if (0 != ref.inst.hdr->hostName.start)
741 {
742 appendInstancePathElement(out, ref);
743 }
744 else if (0 != ref.inst.hdr->instNameSpace.start)
745 {
746 appendLocalInstancePathElement(out, ref);
747 }
748 else
749 {
750 appendInstanceNameElement(out, ref);
751 }
752 }
753 }
754
755 // appendLocalInstancePathElement()
756 // <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)>
757 thilo.boehm 1.2 void SCMOXmlWriter::appendLocalInstancePathElement(
758 Buffer& out,
759 const SCMOInstance& instancePath)
760 {
761 out << STRLIT("<LOCALINSTANCEPATH>\n");
762 Uint32 nsLength=0;
763 const char* ns=instancePath.getNameSpace_l(nsLength);
764 appendLocalNameSpacePathElement(out, ns, nsLength);
765 appendInstanceNameElement(out, instancePath);
766 out << STRLIT("</LOCALINSTANCEPATH>\n");
767 }
768
769 // appendInstancePathElement()
770 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
771 void SCMOXmlWriter::appendInstancePathElement(
772 Buffer& out,
773 const SCMOInstance& instancePath)
774 {
775 out << STRLIT("<INSTANCEPATH>\n");
776
777 Uint32 hostnameLength=0;
778 thilo.boehm 1.2 const char* hostname=instancePath.getHostName_l(hostnameLength);
779 Uint32 nsLength=0;
780 const char* ns=instancePath.getNameSpace_l(nsLength);
781 appendNameSpacePathElement(out,hostname,hostnameLength,ns,nsLength);
782
783 appendInstanceNameElement(out, instancePath);
784 out << STRLIT("</INSTANCEPATH>\n");
785 }
|
786 karl 1.4.2.4
|
787 karl 1.4.2.2 void SCMOXmlWriter::appendValueObjectWithPathElement(
788 Buffer& out,
789 const Array<SCMOInstance> & objectWithPath,
790 const CIMPropertyList& propertyList)
791 {
|
792 karl 1.4.2.7 if (propertyList.isNull())
793 {
794 Array<Uint32> emptyNodes;
795 for (Uint32 i = 0, n = objectWithPath.size(); i < n; i++)
796 {
|
797 karl 1.4.2.2 SCMOXmlWriter::appendValueObjectWithPathElement(
798 out,
799 objectWithPath[i],
800 false,
801 emptyNodes);
|
802 karl 1.4.2.7 }
|
803 karl 1.4.2.2 }
804 else
805 {
806 Array<propertyFilterNodesArray_t> propFilterNodesArrays;
|
807 karl 1.4.2.7 for (Uint32 i = 0, n = objectWithPath.size(); i < n; i++)
|
808 karl 1.4.2.2 {
|
809 karl 1.4.2.7 // This searches for an already created array of nodes,
810 // if not found, creates it inside propFilterNodesArrays
811 const Array<Uint32> & nodes=
812 SCMOXmlWriter::getFilteredNodesArray(
813 propFilterNodesArrays,
814 objectWithPath[i],
|
815 karl 1.4.2.2 propertyList);
816 SCMOXmlWriter::appendValueObjectWithPathElement(
817 out,
818 objectWithPath[i],
819 true,
|
820 karl 1.4.2.7 nodes);
|
821 karl 1.4.2.2
822 }
823 }
824 }
|
825 thilo.boehm 1.2
|
826 karl 1.4.2.3 //EXP_PULL_BEGIN
|
827 karl 1.4.2.1 //------------------------------------------------------------------------------
828 //
829 // appendValueInstanceWithPathElement()
830 //
831 // <!ELEMENT VALUE.INSTANCEWITHPATH (INSTANCEPATH,INSTANCE)>
832 //
833 //------------------------------------------------------------------------------
834 // EXP_PULL_TBD checkout the INSTANCEPATH vs NAMEDINSTANCE differences
835 // Can we create something more common
836 void SCMOXmlWriter::appendValueInstanceWithPathElement(
837 Buffer& out,
|
838 karl 1.4.2.2 const SCMOInstance& namedInstance,
|
839 karl 1.4.2.9 bool filtered,
|
840 karl 1.4.2.2 const Array<Uint32> & nodes)
|
841 karl 1.4.2.1 {
842 out << STRLIT("<VALUE.INSTANCEWITHPATH>\n");
843
844 appendInstancePathElement(out, namedInstance);
|
845 karl 1.4.2.2 appendInstanceElement(out, namedInstance, filtered, nodes);
|
846 karl 1.4.2.1
847 out << STRLIT("</VALUE.INSTANCEWITHPATH>\n");
848 }
|
849 karl 1.4.2.3 //EXP_PULL_END
|
850 karl 1.4.2.1
|
851 thilo.boehm 1.2 // appendValueObjectWithPathElement()
852 // <!ELEMENT VALUE.OBJECTWITHPATH
853 // ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
854 void SCMOXmlWriter::appendValueObjectWithPathElement(
855 Buffer& out,
|
856 karl 1.4.2.2 const SCMOInstance& objectWithPath,
|
857 karl 1.4.2.7 bool filtered,
858 const Array<Uint32> & nodes)
|
859 thilo.boehm 1.2 {
860 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
861
|
862 karl 1.4.2.10 appendClassOrInstancePathElement(out, objectWithPath);
|
863 karl 1.4.2.2 appendObjectElement(out, objectWithPath,filtered,nodes);
|
864 thilo.boehm 1.2
865 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
866 }
867
868 // appendObjectElement()
869 // May refer to a CLASS or an INSTANCE
870 void SCMOXmlWriter::appendObjectElement(
871 Buffer& out,
|
872 karl 1.4.2.2 const SCMOInstance& object,
873 bool filtered,
874 const Array<Uint32> & nodes)
|
875 thilo.boehm 1.2 {
876 if (object.inst.hdr->flags.isClassOnly)
877 {
878 appendClassElement(out, object);
879 }
880 else
881 {
|
882 karl 1.4.2.2 appendInstanceElement(out, object,filtered,nodes);
|
883 thilo.boehm 1.2 }
884 }
885
886 //------------------------------------------------------------------------------
887 //
888 // appendClassElement()
889 //
890 // <!ELEMENT CLASS
891 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
892 // <!ATTLIST CLASS
893 // %CIMName;
894 // %SuperClass;>
895 //
896 //------------------------------------------------------------------------------
897
898 void SCMOXmlWriter::appendClassElement(
899 Buffer& out,
900 const SCMOInstance& cimClass)
901 {
902
903 SCMBClass_Main* ptrClass = cimClass.inst.hdr->theClass.ptr->cls.hdr;
904 thilo.boehm 1.2 const char* clsBase = cimClass.inst.hdr->theClass.ptr->cls.base;
905
906 // Class opening element:
907 out << STRLIT("<CLASS NAME=\"");
908 out.append(
909 &(clsBase[ptrClass->className.start]),
|
910 r.kieninger 1.3 (ptrClass->className.size-1));
|
911 thilo.boehm 1.2
912 out.append('"',' ');
913 if (0 != ptrClass->superClassName.start)
914 {
915 out << STRLIT(" SUPERCLASS=\"");
916 out.append(
917 &(clsBase[ptrClass->superClassName.start]),
|
918 r.kieninger 1.3 (ptrClass->superClassName.size-1));
|
919 thilo.boehm 1.2 out.append('"',' ');
920 }
921 out.append('>','\n');
922
923 // Append class qualifiers
924 SCMBQualifier *theArray =
925 (SCMBQualifier*)&(clsBase[ptrClass->qualifierArray.start]);
926 for (Uint32 i=0, n=ptrClass->numberOfQualifiers;i<n;i++)
927 {
928 SCMOXmlWriter::appendQualifierElement(out,theArray[i],clsBase);
929 }
930
931 // Append Property definitions:
932 for (Uint32 i=0,k=cimClass.getPropertyCount();i<k;i++)
933 {
934 SCMOXmlWriter::appendPropertyElement(out,cimClass,i);
935 }
936
937 // ATTN: No method definitions with SCMO today, so do nothing with them
938 // Actually this code does not serve a purpose, but is kept here
939 // for completeness.
940 thilo.boehm 1.2
941 // Class closing element:
942 out << STRLIT("</CLASS>\n");
943 }
944
945 // appendLocalClassPathElement()
946 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>
947 void SCMOXmlWriter::appendLocalClassPathElement(
948 Buffer& out,
949 const SCMOInstance& classPath)
950 {
951 out << STRLIT("<LOCALCLASSPATH>\n");
952 Uint32 hostnameLength=0;
953 const char* hostname=classPath.getHostName_l(hostnameLength);
954 Uint32 nsLength=0;
955 const char* ns=classPath.getNameSpace_l(nsLength);
956
957 appendNameSpacePathElement(out,hostname,hostnameLength,ns,nsLength);
958
959 Uint32 classNameLength=0;
960 const char* className = classPath.getClassName_l(classNameLength);
961 thilo.boehm 1.2 appendClassNameElement(out, className, classNameLength);
962 out << STRLIT("</LOCALCLASSPATH>\n");
963 }
964
965 // appendClassPathElement()
966 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
967 void SCMOXmlWriter::appendClassPathElement(
968 Buffer& out,
969 const SCMOInstance& classPath)
970 {
971 out << STRLIT("<CLASSPATH>\n");
972
973 Uint32 hostnameLength=0;
974 const char* hostname=classPath.getHostName_l(hostnameLength);
975 Uint32 nsLength=0;
976 const char* ns=classPath.getNameSpace_l(nsLength);
977
978 appendNameSpacePathElement(out,hostname,hostnameLength,ns,nsLength);
979
980 Uint32 classNameLength=0;
981 const char* className = classPath.getClassName_l(classNameLength);
982 thilo.boehm 1.2
983 appendClassNameElement(out, className, classNameLength);
984 out << STRLIT("</CLASSPATH>\n");
985 }
986
987 void SCMOXmlWriter::appendSCMBUnion(
988 Buffer& out,
989 const SCMBUnion & u,
990 const CIMType & valueType,
991 const char * base)
992 {
993 switch (valueType)
994 {
995 case CIMTYPE_BOOLEAN:
996 {
997 if (u.simple.hasValue)
998 {
999 SCMOXmlWriter::append(out, u.simple.val.bin);
1000 }
1001 break;
1002 }
1003 thilo.boehm 1.2
1004 case CIMTYPE_UINT8:
1005 {
1006 if (u.simple.hasValue)
1007 {
1008 SCMOXmlWriter::append(out, u.simple.val.u8);
1009 }
1010 break;
1011 }
1012
1013 case CIMTYPE_SINT8:
1014 {
1015 if (u.simple.hasValue)
1016 {
1017 SCMOXmlWriter::append(out, u.simple.val.s8);
1018 }
1019 break;
1020 }
1021
1022 case CIMTYPE_UINT16:
1023 {
1024 thilo.boehm 1.2 if (u.simple.hasValue)
1025 {
1026 SCMOXmlWriter::append(out, u.simple.val.u16);
1027 }
1028 break;
1029 }
1030
1031 case CIMTYPE_SINT16:
1032 {
1033 if (u.simple.hasValue)
1034 {
1035 SCMOXmlWriter::append(out, u.simple.val.s16);
1036 }
1037 break;
1038 }
1039
1040 case CIMTYPE_UINT32:
1041 {
1042 if (u.simple.hasValue)
1043 {
1044 SCMOXmlWriter::append(out, u.simple.val.u32);
1045 thilo.boehm 1.2 }
1046 break;
1047 }
1048
1049 case CIMTYPE_SINT32:
1050 {
1051 if (u.simple.hasValue)
1052 {
1053 SCMOXmlWriter::append(out, u.simple.val.s32);
1054 }
1055 break;
1056 }
1057
1058 case CIMTYPE_UINT64:
1059 {
1060 if (u.simple.hasValue)
1061 {
1062 SCMOXmlWriter::append(out, u.simple.val.u64);
1063 }
1064 break;
1065 }
1066 thilo.boehm 1.2
1067 case CIMTYPE_SINT64:
1068 {
1069 if (u.simple.hasValue)
1070 {
1071 SCMOXmlWriter::append(out, u.simple.val.s64);
1072 }
1073 break;
1074 }
1075
1076 case CIMTYPE_REAL32:
1077 {
1078 if (u.simple.hasValue)
1079 {
1080 SCMOXmlWriter::append(out, u.simple.val.r32);
1081 }
1082 break;
1083 }
1084
1085 case CIMTYPE_REAL64:
1086 {
1087 thilo.boehm 1.2 if (u.simple.hasValue)
1088 {
1089 SCMOXmlWriter::append(out, u.simple.val.r64);
1090 }
1091 break;
1092 }
1093
1094 case CIMTYPE_CHAR16:
1095 {
1096 if (u.simple.hasValue)
1097 {
1098 SCMOXmlWriter::appendSpecial(
1099 out,
1100 Char16(u.simple.val.c16));
1101 }
1102 break;
1103 }
1104
1105 case CIMTYPE_STRING:
1106 {
1107 if (u.stringValue.start)
1108 thilo.boehm 1.2 {
1109 SCMOXmlWriter::appendSpecial(
1110 out,
1111 &(base[u.stringValue.start]),
|
1112 r.kieninger 1.3 (u.stringValue.size-1));
|
1113 thilo.boehm 1.2 }
1114 break;
1115 }
1116
1117 case CIMTYPE_DATETIME:
1118 {
1119 // an SCMBDateTime is a CIMDateTimeRep
1120 // this should help us to reuse existing optimized Datetime
1121 char buffer[26];
1122 _DateTimetoCStr(u.dateTimeValue, buffer);
1123 // datetime value is formatted with a \0 at end, ignore
1124 out.append(buffer,sizeof(buffer)-1);
1125 break;
1126 }
1127 // Object and Instance are both written the same way, namely as
1128 // object element which then is encoded using appendSpecial
1129 case CIMTYPE_OBJECT:
1130 case CIMTYPE_INSTANCE:
1131 {
1132 Buffer toEncodeObject(4000);
1133 SCMOInstance * obj = u.extRefPtr;
1134 thilo.boehm 1.2 if (obj)
1135 {
1136 appendObjectElement(toEncodeObject, *obj);
1137 SCMOXmlWriter::appendSpecial(
1138 out,
1139 toEncodeObject.getData(),
1140 toEncodeObject.size());
1141 }
1142 break;
1143 }
1144 default:
1145 // CIMTYPE_REFERENCE has been handled upfront, do nothing here
1146 break;
1147 }
1148 }
1149
1150 void SCMOXmlWriter::appendSCMBUnionArray(
1151 Buffer& out,
1152 const SCMBUnion & u,
1153 const CIMType & valueType,
1154 Uint32 numElements,
1155 thilo.boehm 1.2 const char * base)
1156 {
1157 SCMBUnion* arr = (SCMBUnion*) &(base[u.arrayValue.start]);
1158 switch (valueType)
1159 {
1160 case CIMTYPE_BOOLEAN:
1161 {
1162 out << STRLIT("<VALUE.ARRAY>\n");
1163 while (numElements--)
1164 {
1165 out << STRLIT("<VALUE>");
1166 SCMOXmlWriter::append(out, arr->simple.val.bin);
1167 arr++;
1168 out << STRLIT("</VALUE>\n");
1169 }
1170 out << STRLIT("</VALUE.ARRAY>\n");
1171 break;
1172 }
1173 case CIMTYPE_UINT8:
1174 {
1175 out << STRLIT("<VALUE.ARRAY>\n");
1176 thilo.boehm 1.2 while (numElements--)
1177 {
1178 out << STRLIT("<VALUE>");
1179 SCMOXmlWriter::append(out, arr->simple.val.u8);
1180 arr++;
1181 out << STRLIT("</VALUE>\n");
1182 }
1183 out << STRLIT("</VALUE.ARRAY>\n");
1184 break;
1185 }
1186
1187 case CIMTYPE_SINT8:
1188 {
1189 out << STRLIT("<VALUE.ARRAY>\n");
1190 while (numElements--)
1191 {
1192 out << STRLIT("<VALUE>");
1193 SCMOXmlWriter::append(out, arr->simple.val.s8);
1194 arr++;
1195 out << STRLIT("</VALUE>\n");
1196 }
1197 thilo.boehm 1.2 out << STRLIT("</VALUE.ARRAY>\n");
1198 break;
1199 }
1200
1201 case CIMTYPE_UINT16:
1202 {
1203 out << STRLIT("<VALUE.ARRAY>\n");
1204 while (numElements--)
1205 {
1206 out << STRLIT("<VALUE>");
1207 SCMOXmlWriter::append(out, arr->simple.val.u16);
1208 arr++;
1209 out << STRLIT("</VALUE>\n");
1210 }
1211 out << STRLIT("</VALUE.ARRAY>\n");
1212 break;
1213 }
1214
1215 case CIMTYPE_SINT16:
1216 {
1217 out << STRLIT("<VALUE.ARRAY>\n");
1218 thilo.boehm 1.2 while (numElements--)
1219 {
1220 out << STRLIT("<VALUE>");
1221 SCMOXmlWriter::append(out, arr->simple.val.s16);
1222 arr++;
1223 out << STRLIT("</VALUE>\n");
1224 }
1225 out << STRLIT("</VALUE.ARRAY>\n");
1226 break;
1227 }
1228
1229 case CIMTYPE_UINT32:
1230 {
1231 out << STRLIT("<VALUE.ARRAY>\n");
1232 while (numElements--)
1233 {
1234 out << STRLIT("<VALUE>");
1235 SCMOXmlWriter::append(out, arr->simple.val.u32);
1236 arr++;
1237 out << STRLIT("</VALUE>\n");
1238 }
1239 thilo.boehm 1.2 out << STRLIT("</VALUE.ARRAY>\n");
1240 break;
1241 }
1242
1243 case CIMTYPE_SINT32:
1244 {
1245 out << STRLIT("<VALUE.ARRAY>\n");
1246 while (numElements--)
1247 {
1248 out << STRLIT("<VALUE>");
1249 SCMOXmlWriter::append(out, arr->simple.val.s32);
1250 arr++;
1251 out << STRLIT("</VALUE>\n");
1252 }
1253 out << STRLIT("</VALUE.ARRAY>\n");
1254 break;
1255 }
1256
1257 case CIMTYPE_UINT64:
1258 {
1259 out << STRLIT("<VALUE.ARRAY>\n");
1260 thilo.boehm 1.2 while (numElements--)
1261 {
1262 out << STRLIT("<VALUE>");
1263 SCMOXmlWriter::append(out, arr->simple.val.u64);
1264 arr++;
1265 out << STRLIT("</VALUE>\n");
1266 }
1267 out << STRLIT("</VALUE.ARRAY>\n");
1268 break;
1269 }
1270
1271 case CIMTYPE_SINT64:
1272 {
1273 out << STRLIT("<VALUE.ARRAY>\n");
1274 while (numElements--)
1275 {
1276 out << STRLIT("<VALUE>");
1277 SCMOXmlWriter::append(out, arr->simple.val.s64);
1278 arr++;
1279 out << STRLIT("</VALUE>\n");
1280 }
1281 thilo.boehm 1.2 out << STRLIT("</VALUE.ARRAY>\n");
1282 break;
1283 }
1284
1285 case CIMTYPE_REAL32:
1286 {
1287 out << STRLIT("<VALUE.ARRAY>\n");
1288 while (numElements--)
1289 {
1290 out << STRLIT("<VALUE>");
1291 SCMOXmlWriter::append(out, arr->simple.val.r32);
1292 arr++;
1293 out << STRLIT("</VALUE>\n");
1294 }
1295 out << STRLIT("</VALUE.ARRAY>\n");
1296 break;
1297 }
1298
1299 case CIMTYPE_REAL64:
1300 {
1301 out << STRLIT("<VALUE.ARRAY>\n");
1302 thilo.boehm 1.2 while (numElements--)
1303 {
1304 out << STRLIT("<VALUE>");
1305 SCMOXmlWriter::append(out, arr->simple.val.r64);
1306 arr++;
1307 out << STRLIT("</VALUE>\n");
1308 }
1309 out << STRLIT("</VALUE.ARRAY>\n");
1310 break;
1311 }
1312
1313 case CIMTYPE_CHAR16:
1314 {
1315 out << STRLIT("<VALUE.ARRAY>\n");
1316 while (numElements--)
1317 {
1318 out << STRLIT("<VALUE>");
1319 SCMOXmlWriter::appendSpecial(out, Char16(arr->simple.val.c16));
1320 arr++;
1321 out << STRLIT("</VALUE>\n");
1322 }
1323 thilo.boehm 1.2 out << STRLIT("</VALUE.ARRAY>\n");
1324 break;
1325 }
1326
1327 case CIMTYPE_STRING:
1328 {
1329 out << STRLIT("<VALUE.ARRAY>\n");
1330 while (numElements--)
1331 {
1332 out << STRLIT("<VALUE>");
1333 if (0!=arr->stringValue.start)
1334 {
1335 SCMOXmlWriter::appendSpecial(
1336 out,
1337 &(base[arr->stringValue.start]),
|
1338 r.kieninger 1.3 (arr->stringValue.size-1));
|
1339 thilo.boehm 1.2 }
1340 arr++;
1341 out << STRLIT("</VALUE>\n");
1342 }
1343 out << STRLIT("</VALUE.ARRAY>\n");
1344
1345 break;
1346 }
1347
1348 case CIMTYPE_DATETIME:
1349 {
1350 out << STRLIT("<VALUE.ARRAY>\n");
1351 char buffer[26];
1352 while (numElements--)
1353 {
1354 out << STRLIT("<VALUE>");
1355 // an SCMBDateTime is a CIMDateTimeRep
1356 // this should help us to reuse existing optimized Datetime
1357 _DateTimetoCStr(arr->dateTimeValue, buffer);
1358 // datetime value is formatted with a \0 at end, ignore
1359 out.append(buffer,sizeof(buffer)-1);
1360 thilo.boehm 1.2 arr++;
1361 out << STRLIT("</VALUE>\n");
1362 }
1363 out << STRLIT("</VALUE.ARRAY>\n");
1364 break;
1365 }
1366 case CIMTYPE_REFERENCE:
1367 {
1368 out << STRLIT("<VALUE.REFARRAY>\n");
1369 while (numElements--)
1370 {
1371 SCMOInstance * ref = arr->extRefPtr;
1372 if (ref)
1373 {
|
1374 karl 1.4.2.10 appendValueReferenceElement(out, *ref);
|
1375 thilo.boehm 1.2 }
1376 arr++;
1377 }
1378 out << STRLIT("</VALUE.REFARRAY>\n");
|
1379 karl 1.4.2.2 break;
|
1380 thilo.boehm 1.2 }
1381 case CIMTYPE_OBJECT:
1382 case CIMTYPE_INSTANCE:
1383 {
1384 out << STRLIT("<VALUE.ARRAY>\n");
1385 Buffer toEncodeObject(4000);
1386 while (numElements--)
1387 {
1388 toEncodeObject.clear();
1389 out << STRLIT("<VALUE>");
1390 SCMOInstance * obj = arr->extRefPtr;
1391 if (obj)
1392 {
1393 appendObjectElement(toEncodeObject, *obj);
1394 SCMOXmlWriter::appendSpecial(
1395 out,
1396 toEncodeObject.getData(),
1397 toEncodeObject.size());
1398 }
1399 arr++;
1400 out << STRLIT("</VALUE>\n");
1401 thilo.boehm 1.2 }
1402 out << STRLIT("</VALUE.ARRAY>\n");
1403 break;
1404 }
1405 default:
1406 PEGASUS_DEBUG_ASSERT(false);
1407 }
1408
1409 }
1410
1411
1412
1413 PEGASUS_NAMESPACE_END
|
Return to
SCMOXmlWriter.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common