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