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.12 // TODO: check performance impact
60 out.append('"','>','\n');
|
61 marek 1.1.2.2
62 for (Uint32 i = 0, n = scmoInstance.getKeyBindingCount(); i < n; i++)
63 {
64 const char * kbName;
65 const SCMBUnion * kbValue;
66 CIMType kbType;
67 Uint32 kbNameLen;
68
|
69 r.kieninger 1.1.2.9 SCMO_RC smrc = scmoInstance._getKeyBindingDataAtNodeIndex(
|
70 marek 1.1.2.2 i,
71 &kbName,
72 kbNameLen,
73 kbType,
74 &kbValue);
75
76 out << STRLIT("<KEYBINDING NAME=\"");
77 out.append(kbName,kbNameLen-1);
|
78 marek 1.1.2.12 out.append('"','>','\n');
|
79 marek 1.1.2.2
80 if (kbType == CIMTYPE_REFERENCE)
81 {
|
82 r.kieninger 1.1.2.9 if (SCMO_OK == smrc)
|
83 marek 1.1.2.8 {
|
84 r.kieninger 1.1.2.9 SCMOInstance * ref = kbValue->extRefPtr;
|
85 marek 1.1.2.8 appendValueReferenceElement(out, *ref, true);
86 }
|
87 marek 1.1.2.2 }
88 else
89 {
90 out << STRLIT("<KEYVALUE VALUETYPE=\"");
91 out << xmlWriterKeyTypeStrings(kbType);
|
92 marek 1.1.2.12 out.append('"','>');
|
93 marek 1.1.2.2
|
94 r.kieninger 1.1.2.9 if (SCMO_OK == smrc)
95 {
96 SCMOXmlWriter::appendSCMBUnion(
97 out,
98 *kbValue,
99 kbType,
100 scmoInstance.inst.base);
101 }
|
102 marek 1.1.2.2 out << STRLIT("</KEYVALUE>\n");
103 }
104 out << STRLIT("</KEYBINDING>\n");
105 }
106 out << STRLIT("</INSTANCENAME>\n");
107 }
108
109 //------------------------------------------------------------------------------
110 //
111 // appendInstanceElement()
112 //
113 // <!ELEMENT INSTANCE
114 // (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
115 // <!ATTLIST INSTANCE
116 // %ClassName;>
117 //
118 //------------------------------------------------------------------------------
119 void SCMOXmlWriter::appendInstanceElement(
120 Buffer& out,
121 const SCMOInstance& scmoInstance)
122 {
123 marek 1.1.2.2 // Class opening element:
124
125 out << STRLIT("<INSTANCE CLASSNAME=\"");
126 Uint64 len;
127 const char * className = scmoInstance.getClassName_l(len);
|
128 marek 1.1.2.10 out.append(className,len);
|
129 marek 1.1.2.12 out.append('"',' ','>','\n');
130 //out << STRLIT("\" >\n");
|
131 marek 1.1.2.2
132 // Append Instance Qualifiers:
133 if (scmoInstance.inst.hdr->flags.includeQualifiers)
134 {
135 SCMBClass_Main *classMain=scmoInstance.inst.hdr->theClass->cls.hdr;
136 char* clsbase = scmoInstance.inst.hdr->theClass->cls.base;
137
138 SCMBQualifier *theArray =
139 (SCMBQualifier*)&(clsbase[classMain->qualifierArray.start]);
140 // need to iterate
141 for (Uint32 i=0, n=classMain->numberOfQualifiers;i<n;i++)
142 {
143 SCMOXmlWriter::appendQualifierElement(out,theArray[i],clsbase);
144 }
145 }
146
147 // Append Properties:
|
148 marek 1.1.2.12 // getPropertyCount() returns number of properties, only non-filtered ones
|
149 marek 1.1.2.5 for (Uint32 i=0,k=scmoInstance.getPropertyCount();i<k;i++)
|
150 marek 1.1.2.2 {
|
151 marek 1.1.2.12 // function _getPropertyAt() used by appendPropertyElement
152 // translates the filter position of a property into the real one
153 // for us
154 SCMOXmlWriter::appendPropertyElement(out,scmoInstance,i);
|
155 marek 1.1.2.2 }
156 // Instance closing element:
157 out << STRLIT("</INSTANCE>\n");
158 }
159
160 //------------------------------------------------------------------------------
161 //
162 // appendQualifierElement()
163 //
164 // <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>
165 // <!ATTLIST QUALIFIER
166 // %CIMName;
167 // %CIMType; #REQUIRED
168 // %Propagated;
169 // %QualifierFlavor;>
170 //
171 //------------------------------------------------------------------------------
172
173 void SCMOXmlWriter::appendQualifierElement(
174 Buffer& out,
175 const SCMBQualifier& theQualifier,
176 marek 1.1.2.2 const char* base)
177 {
178 out << STRLIT("<QUALIFIER NAME=\"");
179 if(theQualifier.name == QUALNAME_USERDEFINED)
180 {
181 if (theQualifier.userDefName.start)
182 {
183 out.append(
184 &(base[theQualifier.userDefName.start]),
|
185 thilo.boehm 1.1.2.14 theQualifier.userDefName.size-1);
|
186 marek 1.1.2.2 }
187 }
188 else
189 {
190 out << SCMOClass::qualifierNameStrLit(theQualifier.name);
191 }
|
192 marek 1.1.2.12 out.append('"',' ');
193 //out << STRLIT("\" ");
|
194 marek 1.1.2.2
195 // Append type
196 out << xmlWriterTypeStrings(theQualifier.value.valueType);
197 // append PROPAGATED if set
198 if (theQualifier.propagated)
199 {
200 out << STRLIT(" PROPAGATED=\"true\"");
201 }
202 // append flavor of the qualifier
203 SCMOXmlWriter::appendQualifierFlavorEntity(
204 out,
205 CIMFlavor(theQualifier.flavor));
206
|
207 marek 1.1.2.12 out.append('>','\n');
208 //out << STRLIT(">\n");
|
209 marek 1.1.2.2 // append the value of the qualifier
|
210 marek 1.1.2.4 SCMOXmlWriter::appendValueElement(out, theQualifier.value, base);
|
211 marek 1.1.2.2
212 out << STRLIT("</QUALIFIER>\n");
213 }
214
215 //------------------------------------------------------------------------------
216 //
217 // appendPropertyElement()
218 //
219 // <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
220 // <!ATTLIST PROPERTY
221 // %CIMName;
222 // %CIMType; #REQUIRED
223 // %ClassOrigin;
224 // %Propagated;>
225 //
226 // <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
227 // <!ATTLIST PROPERTY.ARRAY
228 // %CIMName;
229 // %CIMType; #REQUIRED
230 // %ArraySize;
231 // %ClassOrigin;
232 marek 1.1.2.2 // %Propagated;>
233 //
234 // <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>
235 // <!ATTLIST PROPERTY.REFERENCE
236 // %CIMName;
237 // %ReferenceClass;
238 // %ClassOrigin;
239 // %Propagated;>
240 //
241 //------------------------------------------------------------------------------
242 void SCMOXmlWriter::appendPropertyElement(
243 Buffer& out,
244 const SCMOInstance& scmoInstance,
245 Uint32 pos)
246 {
247 CIMType propertyType;
|
248 marek 1.1.2.8 Buffer embeddedQualifierOutput;
|
249 marek 1.1.2.2
250 // 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 marek 1.1.2.11 scmoInstance._getPropertyAt(
|
260 marek 1.1.2.2 pos,
261 &propertyValue,
262 &propertyValueBase,
263 &propertyDef);
264
265 propertyType = propertyValue->valueType;
266
267 if (propertyValue->flags.isArray)
268 {
|
269 marek 1.1.2.8 Uint32 arraySize=propertyValue->valueArraySize;
270
|
271 marek 1.1.2.3 out << STRLIT("<PROPERTY.ARRAY NAME=\"");
|
272 marek 1.1.2.2
|
273 marek 1.1.2.3 out.append(
274 &(clsbase[propertyDef->name.start]),
|
275 thilo.boehm 1.1.2.14 propertyDef->name.size-1);
|
276 marek 1.1.2.3
|
277 marek 1.1.2.12 out.append('"',' ');
278 //out << STRLIT("\" ");
|
279 marek 1.1.2.2 if (propertyType == CIMTYPE_OBJECT)
280 {
281 // If the property array type is CIMObject, then
282 // encode the property in CIM-XML as a string array with the
283 // EmbeddedObject attribute (there is not currently a CIM-XML
284 // "object" datatype)
285 out << STRLIT(" TYPE=\"string\"");
286 // If the Embedded Object is an instance, always add the
287 // EmbeddedObject attribute.
|
288 marek 1.1.2.8 SCMOInstance * instPtr = propertyValue->value.extRefPtr;
289 if ((0 != instPtr) &&
290 (arraySize > 0) &&
291 !(instPtr->inst.hdr->flags.isClassOnly))
|
292 marek 1.1.2.2 {
293 out << STRLIT(" EmbeddedObject=\"object\""
|
294 marek 1.1.2.11 " EMBEDDEDOBJECT=\"object\"");
|
295 marek 1.1.2.2 }
296 }
297 else if (propertyType == CIMTYPE_INSTANCE)
298 {
299 // If the property array type is CIMInstance, then
300 // encode the property in CIM-XML as a string array with the
301 // EmbeddedObject attribute (there is not currently a CIM-XML
302 // "instance" datatype)
303 out << STRLIT(" TYPE=\"string\"");
304 // add the EmbeddedObject attribute
|
305 marek 1.1.2.8 if (arraySize > 0)
|
306 marek 1.1.2.2 {
307 out << STRLIT(" EmbeddedObject=\"instance\""
308 " EMBEDDEDOBJECT=\"instance\"");
309 }
310 }
311 else
|
312 marek 1.1.2.6 {
|
313 marek 1.1.2.2 out.append(' ');
|
314 marek 1.1.2.3 out << xmlWriterTypeStrings(propertyType);
|
315 marek 1.1.2.2 }
|
316 marek 1.1.2.6
|
317 marek 1.1.2.3 if (0 != arraySize)
|
318 marek 1.1.2.2 {
|
319 marek 1.1.2.3 out << STRLIT(" ARRAYSIZE=\"");
320 SCMOXmlWriter::append(out, arraySize);
|
321 marek 1.1.2.2 out.append('"');
322 }
323
|
324 marek 1.1.2.3
325 if (scmoInstance.inst.hdr->flags.includeClassOrigin)
|
326 marek 1.1.2.2 {
|
327 marek 1.1.2.3 if (propertyDef->originClassName.start != 0)
328 {
329 out << STRLIT(" CLASSORIGIN=\"");
330 out.append(
331 &(clsbase[propertyDef->originClassName.start]),
|
332 thilo.boehm 1.1.2.14 propertyDef->originClassName.size-1);
|
333 marek 1.1.2.3 out.append('"');
334 }
|
335 marek 1.1.2.2 }
|
336 marek 1.1.2.3 if (propertyDef->flags.propagated)
|
337 marek 1.1.2.2 {
338 out << STRLIT(" PROPAGATED=\"true\"");
339 }
340
|
341 marek 1.1.2.12 out.append('>','\n');
342 //out << STRLIT(">\n");
|
343 marek 1.1.2.2
|
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 thilo.boehm 1.1.2.14 propertyDef->name.size-1);
|
368 marek 1.1.2.12 out.append('"',' ');
369 //out << STRLIT("\" ");
|
370 marek 1.1.2.2
|
371 marek 1.1.2.5 if (0 != propertyDef->refClassName.start)
|
372 marek 1.1.2.2 {
|
373 marek 1.1.2.5 out << STRLIT(" REFERENCECLASS=\"");
374 out.append(
375 &(clsbase[propertyDef->refClassName.start]),
|
376 thilo.boehm 1.1.2.14 propertyDef->refClassName.size-1);
|
377 marek 1.1.2.2 out.append('"');
378 }
379
|
380 marek 1.1.2.5 if (scmoInstance.inst.hdr->flags.includeClassOrigin)
|
381 marek 1.1.2.2 {
|
382 marek 1.1.2.5 if (propertyDef->originClassName.start != 0)
383 {
384 out << STRLIT(" CLASSORIGIN=\"");
385 out.append(
386 &(clsbase[propertyDef->originClassName.start]),
|
387 thilo.boehm 1.1.2.14 propertyDef->originClassName.size-1);
|
388 marek 1.1.2.5 out.append('"');
389 }
|
390 marek 1.1.2.2 }
|
391 marek 1.1.2.5 if (propertyDef->flags.propagated)
|
392 marek 1.1.2.2 {
393 out << STRLIT(" PROPAGATED=\"true\"");
394 }
|
395 marek 1.1.2.12 out.append('>','\n');
396 //out << STRLIT(">\n");
|
397 marek 1.1.2.5 // Append Instance Qualifiers:
398 if (scmoInstance.inst.hdr->flags.includeQualifiers)
399 {
400 SCMBQualifier * theArray=
401 (SCMBQualifier*)
402 &(clsbase[propertyDef->qualifierArray.start]);
403 // need to iterate
404 for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++)
405 {
406 SCMOXmlWriter::appendQualifierElement(
407 out,
408 theArray[i],
409 clsbase);
410 }
411 }
412 SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
|
413 marek 1.1.2.2 out << STRLIT("</PROPERTY.REFERENCE>\n");
414 }
415 else
416 {
417 out << STRLIT("<PROPERTY NAME=\"");
418
419 out.append(
420 &(clsbase[propertyDef->name.start]),
|
421 thilo.boehm 1.1.2.14 propertyDef->name.size-1);
|
422 marek 1.1.2.2
|
423 marek 1.1.2.12 out.append('"',' ');
424 //out << STRLIT("\" ");
|
425 marek 1.1.2.2
426 if (scmoInstance.inst.hdr->flags.includeClassOrigin)
427 {
428 if (propertyDef->originClassName.start != 0)
429 {
430 out << STRLIT(" CLASSORIGIN=\"");
431 out.append(
432 &(clsbase[propertyDef->originClassName.start]),
|
433 thilo.boehm 1.1.2.14 propertyDef->originClassName.size-1);
|
434 marek 1.1.2.2 out.append('"');
435 }
436 }
437 if (propertyDef->flags.propagated)
438 {
439 out << STRLIT(" PROPAGATED=\"true\"");
440 }
441
442 if (propertyType == CIMTYPE_OBJECT)
443 {
444 // If the property type is CIMObject, then
445 // encode the property in CIM-XML as a string with the
446 // EmbeddedObject attribute (there is not currently a CIM-XML
447 // "object" datatype)
448 out << STRLIT(" TYPE=\"string\"");
449 // If the Embedded Object is an instance, always add the
450 // EmbeddedObject attribute.
|
451 marek 1.1.2.8 SCMOInstance * a = propertyValue->value.extRefPtr;
452 if (a && !(a->inst.hdr->flags.isClassOnly))
|
453 marek 1.1.2.2 {
454 out << STRLIT(" EmbeddedObject=\"object\""
455 " EMBEDDEDOBJECT=\"object\"");
456 }
457 else if (propertyType == CIMTYPE_INSTANCE)
458 {
459 out << STRLIT(" TYPE=\"string\""
460 " EmbeddedObject=\"instance\""
461 " EMBEDDEDOBJECT=\"instance\"");
|
462 marek 1.1.2.8 }
|
463 marek 1.1.2.2 }
464 else
465 {
466 out.append(' ');
467 out << xmlWriterTypeStrings(propertyType);
468 }
|
469 marek 1.1.2.12 out.append('>','\n');
470 //out << STRLIT(">\n");
|
471 marek 1.1.2.2
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 }
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 thilo.boehm 1.1.2.14 theClass->className.size-1);
|
692 marek 1.1.2.7
|
693 marek 1.1.2.12 out.append('"',' ');
|
694 marek 1.1.2.7 if (0 != theClass->superClassName.start)
695 {
696 out << STRLIT(" SUPERCLASS=\"");
697 out.append(
698 &(clsBase[theClass->superClassName.start]),
|
699 thilo.boehm 1.1.2.14 theClass->superClassName.size-1);
|
700 marek 1.1.2.12 out.append('"',' ');
|
701 marek 1.1.2.7 }
|
702 marek 1.1.2.12 out.append('>','\n');
|
703 marek 1.1.2.7
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 thilo.boehm 1.1.2.14 u.stringValue.size-1);
|
894 marek 1.1.2.8 }
|
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 marek 1.1.2.13 _DateTimetoCStr(u.dateTimeValue, buffer);
|
904 marek 1.1.2.2 // 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 thilo.boehm 1.1.2.14 arr->stringValue.size-1);
|
1119 marek 1.1.2.3 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 marek 1.1.2.13 _DateTimetoCStr(arr->dateTimeValue, buffer);
|
1137 marek 1.1.2.3 // 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