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