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