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