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