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