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