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