pegasus/src/Pegasus/Common/SCMOXmlWriter.cpp - annotate

Return to SCMOXmlWriter.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

1 marek 1.1.2.1 //%LICENSE//////////////////////////////////////////////////////////////// 2 // 3 // Licensed to The Open Group (TOG) under one or more contributor license 4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with 5 // this work for additional information regarding copyright ownership. 6 // Each contributor licenses this file to you under the OpenPegasus Open 7 // Source License; you may not use this file except in compliance with the 8 // License. 9 // 10 // Permission is hereby granted, free of charge, to any person obtaining a 11 // copy of this software and associated documentation files (the "Software"), 12 // to deal in the Software without restriction, including without limitation 13 // the rights to use, copy, modify, merge, publish, distribute, sublicense, 14 // and/or sell copies of the Software, and to permit persons to whom the 15 // Software is furnished to do so, subject to the following conditions: 16 // 17 // The above copyright notice and this permission notice shall be included 18 // in all copies or substantial portions of the Software. 19 // 20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 21 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 22 marek 1.1.2.1 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 27 // 28 ////////////////////////////////////////////////////////////////////////// 29 // 30 //%///////////////////////////////////////////////////////////////////////////// 31 32 #include <Pegasus/Common/Config.h> 33 #include <cstdlib> 34 #include <cstdio> 35 #include <Pegasus/Common/SCMOXmlWriter.h> 36 37 PEGASUS_NAMESPACE_BEGIN 38
39 marek 1.1.2.2 void SCMOXmlWriter::appendValueSCMOInstanceElement( 40 Buffer& out, 41 const SCMOInstance& scmoInstance) 42 { 43 out << STRLIT("<VALUE.NAMEDINSTANCE>\n"); 44 45 appendInstanceNameElement(out, scmoInstance); 46 appendInstanceElement(out, scmoInstance); 47 48 out << STRLIT("</VALUE.NAMEDINSTANCE>\n"); 49 } 50 51 void SCMOXmlWriter::appendInstanceNameElement( 52 Buffer& out, 53 const SCMOInstance& scmoInstance) 54 { 55 out << STRLIT("<INSTANCENAME CLASSNAME=\""); 56 Uint64 len; 57 const char * className = scmoInstance.getClassName_l(len); 58 out.append(className,len-1); 59 out << STRLIT("\">\n"); 60 marek 1.1.2.2 61 for (Uint32 i = 0, n = scmoInstance.getKeyBindingCount(); i < n; i++) 62 { 63 const char * kbName; 64 const SCMBUnion * kbValue; 65 CIMType kbType; 66 Uint32 kbNameLen; 67 68 scmoInstance._getKeyBindingDataAtNodeIndex( 69 i, 70 &kbName, 71 kbNameLen, 72 kbType, 73 &kbValue); 74 75 out << STRLIT("<KEYBINDING NAME=\""); 76 out.append(kbName,kbNameLen-1); 77 out << STRLIT("\">\n"); 78 79 if (kbType == CIMTYPE_REFERENCE) 80 {
81 marek 1.1.2.6 SCMOInstance * ref = kbValue->extRefPtr;
82 marek 1.1.2.8 if (ref) 83 { 84 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 SCMOXmlWriter::appendSCMBUnion( 94 out, 95 kbValue, 96 kbType, 97 scmoInstance.inst.base); 98 99 out << STRLIT("</KEYVALUE>\n"); 100 } 101 out << STRLIT("</KEYBINDING>\n"); 102 } 103 out << STRLIT("</INSTANCENAME>\n"); 104 } 105 106 //------------------------------------------------------------------------------ 107 marek 1.1.2.2 // 108 // appendInstanceElement() 109 // 110 // <!ELEMENT INSTANCE 111 // (QUALIFIER,(PROPERTY\|PROPERTY.ARRAY\|PROPERTY.REFERENCE))> 112 // <!ATTLIST INSTANCE 113 // %ClassName;> 114 // 115 //------------------------------------------------------------------------------ 116 void SCMOXmlWriter::appendInstanceElement( 117 Buffer& out, 118 const SCMOInstance& scmoInstance) 119 { 120 // Class opening element: 121 122 out << STRLIT("<INSTANCE CLASSNAME=\""); 123 Uint64 len; 124 const char className = scmoInstance.getClassName_l(len); 125 out.append(className,len-1); 126 out << STRLIT("\" >\n"); 127 128 marek 1.1.2.2 // Append Instance Qualifiers: 129 if (scmoInstance.inst.hdr->flags.includeQualifiers) 130 { 131 SCMBClass_Main classMain=scmoInstance.inst.hdr->theClass->cls.hdr; 132 char clsbase = scmoInstance.inst.hdr->theClass->cls.base; 133 134 SCMBQualifier theArray = 135 (SCMBQualifier)&(clsbase[classMain->qualifierArray.start]); 136 // need to iterate 137 for (Uint32 i=0, n=classMain->numberOfQualifiers;i<n;i++) 138 { 139 SCMOXmlWriter::appendQualifierElement(out,theArray[i],clsbase); 140 } 141 } 142 143 // Append Properties:
144 marek 1.1.2.5 for (Uint32 i=0,k=scmoInstance.getPropertyCount();i<k;i++)
145 marek 1.1.2.2 { 146 if (scmoInstance.inst.hdr->flags.isFiltered && 147 !scmoInstance._isPropertyInFilter(i)) 148 { 149 // Property is filtered, ignore and go to next 150 continue; 151 } 152 else 153 { 154 SCMOXmlWriter::appendPropertyElement(out,scmoInstance,i); 155 } 156 } 157 // Instance closing element: 158 out << STRLIT("</INSTANCE>\n"); 159 } 160 161 //------------------------------------------------------------------------------ 162 // 163 // appendQualifierElement() 164 // 165 // <!ELEMENT QUALIFIER (VALUE\|VALUE.ARRAY)> 166 marek 1.1.2.2 // <!ATTLIST QUALIFIER 167 // %CIMName; 168 // %CIMType; #REQUIRED 169 // %Propagated; 170 // %QualifierFlavor;> 171 // 172 //------------------------------------------------------------------------------ 173 174 void SCMOXmlWriter::appendQualifierElement( 175 Buffer& out, 176 const SCMBQualifier& theQualifier, 177 const char* base) 178 { 179 out << STRLIT("<QUALIFIER NAME=\""); 180 if(theQualifier.name == QUALNAME_USERDEFINED) 181 { 182 if (theQualifier.userDefName.start) 183 { 184 out.append( 185 &(base[theQualifier.userDefName.start]), 186 theQualifier.userDefName.length-1); 187 marek 1.1.2.2 } 188 } 189 else 190 { 191 out << SCMOClass::qualifierNameStrLit(theQualifier.name); 192 } 193 194 out << STRLIT("\" "); 195 196 // Append type 197 out << xmlWriterTypeStrings(theQualifier.value.valueType); 198 // append PROPAGATED if set 199 if (theQualifier.propagated) 200 { 201 out << STRLIT(" PROPAGATED=\"true\""); 202 } 203 // append flavor of the qualifier 204 SCMOXmlWriter::appendQualifierFlavorEntity( 205 out, 206 CIMFlavor(theQualifier.flavor)); 207 208 marek 1.1.2.2 out << STRLIT(">\n"); 209 // 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 SCMO_RC rc = scmoInstance.getPropertyAt( 260 pos, 261 &propertyValue, 262 &propertyValueBase, 263 &propertyDef); 264 265 propertyType = propertyValue->valueType; 266 267 268 if (propertyValue->flags.isArray) 269 {
270 marek 1.1.2.8 Uint32 arraySize=propertyValue->valueArraySize; 271
272 marek 1.1.2.3 out << STRLIT("<PROPERTY.ARRAY NAME=\"");
273 marek 1.1.2.2
274 marek 1.1.2.3 out.append( 275 &(clsbase[propertyDef->name.start]), 276 propertyDef->name.length-1); 277 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 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 " EMBEDDEDOBJECT=\"object\""); 296 } 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 marek 1.1.2.2
360 marek 1.1.2.3 SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
361 marek 1.1.2.2 362 out << STRLIT("</PROPERTY.ARRAY>\n"); 363 } 364 else if (propertyType == CIMTYPE_REFERENCE) 365 {
366 marek 1.1.2.6 out << STRLIT("<PROPERTY.REFERENCE NAME=\"");
367 marek 1.1.2.5 out.append( 368 &(clsbase[propertyDef->name.start]), 369 propertyDef->name.length-1); 370 out << STRLIT("\" ");
371 marek 1.1.2.2
372 marek 1.1.2.5 if (0 != propertyDef->refClassName.start)
373 marek 1.1.2.2 {
374 marek 1.1.2.5 out << STRLIT(" REFERENCECLASS=\""); 375 out.append( 376 &(clsbase[propertyDef->refClassName.start]), 377 propertyDef->refClassName.length-1);
378 marek 1.1.2.2 out.append('"'); 379 } 380
381 marek 1.1.2.5 if (scmoInstance.inst.hdr->flags.includeClassOrigin)
382 marek 1.1.2.2 {
383 marek 1.1.2.5 if (propertyDef->originClassName.start != 0) 384 { 385 out << STRLIT(" CLASSORIGIN=\""); 386 out.append( 387 &(clsbase[propertyDef->originClassName.start]), 388 propertyDef->originClassName.length-1); 389 out.append('"'); 390 }
391 marek 1.1.2.2 }
392 marek 1.1.2.5 if (propertyDef->flags.propagated)
393 marek 1.1.2.2 { 394 out << STRLIT(" PROPAGATED=\"true\""); 395 } 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 propertyDef->name.length-1); 422 423 out << STRLIT("\" "); 424 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 propertyDef->originClassName.length-1); 433 out.append('"'); 434 marek 1.1.2.2 } 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 out << STRLIT(">\n"); 469 470 // Append Instance Qualifiers: 471 if (scmoInstance.inst.hdr->flags.includeQualifiers) 472 { 473 SCMBQualifier * theArray= 474 (SCMBQualifier*) 475 &(clsbase[propertyDef->qualifierArray.start]); 476 // need to iterate 477 for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++) 478 { 479 SCMOXmlWriter::appendQualifierElement( 480 out, 481 theArray[i], 482 clsbase); 483 marek 1.1.2.2 } 484 }
485 marek 1.1.2.3 SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
486 marek 1.1.2.2 out << STRLIT("</PROPERTY>\n"); 487 } 488 } 489 //------------------------------------------------------------------------------ 490 // 491 // appendValueElement() 492 // 493 // <!ELEMENT VALUE (#PCDATA)> 494 // <!ELEMENT VALUE.ARRAY (VALUE)> 495 // <!ELEMENT VALUE.REFERENCE 496 // (CLASSPATH\|LOCALCLASSPATH\|CLASSNAME\|INSTANCEPATH\|LOCALINSTANCEPATH\| 497 // INSTANCENAME)> 498 // <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE)> 499 // 500 //------------------------------------------------------------------------------ 501 502 void SCMOXmlWriter::appendValueElement( 503 Buffer& out,
504 marek 1.1.2.4 const SCMBValue & value,
505 marek 1.1.2.2 const char * base) 506 { 507 if (value.flags.isNull) 508 { 509 return; 510 } 511 if (value.flags.isArray) 512 {
513 marek 1.1.2.3 appendSCMBUnionArray( 514 out, 515 value.value, 516 value.valueType, 517 value.valueArraySize, 518 base);
519 marek 1.1.2.2 } 520 else if (value.valueType == CIMTYPE_REFERENCE) 521 {
522 marek 1.1.2.6 SCMOInstance * ref = value.value.extRefPtr;
523 marek 1.1.2.8 if (ref) 524 { 525 appendValueReferenceElement(out, *ref, true); 526 }
527 marek 1.1.2.2 } 528 else 529 { 530 out << STRLIT("<VALUE>"); 531 532 // Call function to write a SCMBUnion + type field 533 appendSCMBUnion(out,value.value, value.valueType,base); 534 535 out << STRLIT("</VALUE>\n"); 536 } 537 } 538
539 marek 1.1.2.5 //------------------------------------------------------------------------------ 540 // 541 // appendValueReferenceElement() 542 // 543 // <!ELEMENT VALUE.REFERENCE 544 // (CLASSPATH\|LOCALCLASSPATH\|CLASSNAME\|INSTANCEPATH\|LOCALINSTANCEPATH\| 545 // INSTANCENAME)> 546 // 547 //------------------------------------------------------------------------------ 548 void SCMOXmlWriter::appendValueReferenceElement( 549 Buffer& out, 550 const SCMOInstance& ref, 551 Boolean putValueWrapper) 552 { 553 if (putValueWrapper)
554 marek 1.1.2.6 {
555 marek 1.1.2.5 out << STRLIT("<VALUE.REFERENCE>\n");
556 marek 1.1.2.6 }
557 marek 1.1.2.5 558 // See if it is a class or instance reference (instance references have 559 // key-bindings; class references do not). 560 561 // differentiate between instance and class using the SCMO flag 562 if (ref.inst.hdr->flags.isClassOnly) 563 { 564 // class 565 if (0 != ref.inst.hdr->hostName.start) 566 { 567 appendClassPathElement(out, ref); 568 }
569 marek 1.1.2.6 else if (0 != ref.inst.hdr->instNameSpace.start)
570 marek 1.1.2.5 {
571 marek 1.1.2.6 appendLocalClassPathElement(out, ref);
572 marek 1.1.2.5 } 573 else 574 {
575 marek 1.1.2.6 Uint64 classNameLength=0; 576 const char* className = ref.getClassName_l(classNameLength); 577 appendClassNameElement(out, className, classNameLength-1);
578 marek 1.1.2.5 } 579 } 580 else 581 { 582 // instance 583 if (0 != ref.inst.hdr->hostName.start) 584 {
585 marek 1.1.2.6 appendInstancePathElement(out, ref);
586 marek 1.1.2.5 }
587 marek 1.1.2.6 else if (0 != ref.inst.hdr->instNameSpace.start)
588 marek 1.1.2.5 {
589 marek 1.1.2.6 appendLocalInstancePathElement(out, ref);
590 marek 1.1.2.5 } 591 else 592 {
593 marek 1.1.2.6 appendInstanceNameElement(out, ref);
594 marek 1.1.2.5 } 595 } 596 if (putValueWrapper)
597 marek 1.1.2.6 {
598 marek 1.1.2.5 out << STRLIT("</VALUE.REFERENCE>\n");
599 marek 1.1.2.6 } 600 } 601 602 // appendLocalInstancePathElement() 603 // <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)> 604 void SCMOXmlWriter::appendLocalInstancePathElement( 605 Buffer& out, 606 const SCMOInstance& instancePath) 607 { 608 out << STRLIT("<LOCALINSTANCEPATH>\n"); 609 Uint64 nsLength=0; 610 const char* ns=instancePath.getNameSpace_l(nsLength); 611 appendLocalNameSpacePathElement(out, ns, nsLength-1); 612 appendInstanceNameElement(out, instancePath); 613 out << STRLIT("</LOCALINSTANCEPATH>\n"); 614 } 615 616 // appendInstancePathElement() 617 // <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)> 618 void SCMOXmlWriter::appendInstancePathElement( 619 Buffer& out, 620 marek 1.1.2.6 const SCMOInstance& instancePath) 621 { 622 out << STRLIT("<INSTANCEPATH>\n"); 623 624 Uint64 hostnameLength=0; 625 const char* hostname=instancePath.getHostName_l(hostnameLength); 626 Uint64 nsLength=0; 627 const char* ns=instancePath.getNameSpace_l(nsLength); 628 appendNameSpacePathElement(out,hostname,hostnameLength-1,ns,nsLength-1); 629 630 appendInstanceNameElement(out, instancePath); 631 out << STRLIT("</INSTANCEPATH>\n"); 632 } 633
634 marek 1.1.2.7 // appendValueObjectWithPathElement() 635 // <!ELEMENT VALUE.OBJECTWITHPATH 636 // ((CLASSPATH,CLASS)\|(INSTANCEPATH,INSTANCE))> 637 void SCMOXmlWriter::appendValueObjectWithPathElement( 638 Buffer& out, 639 const SCMOInstance& objectWithPath) 640 { 641 out << STRLIT("<VALUE.OBJECTWITHPATH>\n"); 642 643 appendValueReferenceElement(out, objectWithPath, false); 644 appendObjectElement(out, objectWithPath); 645 646 out << STRLIT("</VALUE.OBJECTWITHPATH>\n"); 647 } 648 649 // appendObjectElement() 650 // May refer to a CLASS or an INSTANCE 651 void SCMOXmlWriter::appendObjectElement( 652 Buffer& out, 653 const SCMOInstance& object) 654 { 655 marek 1.1.2.7 if (object.inst.hdr->flags.isClassOnly) 656 { 657 appendClassElement(out, object); 658 } 659 else 660 { 661 appendInstanceElement(out, object); 662 } 663 } 664 665 //------------------------------------------------------------------------------ 666 // 667 // appendClassElement() 668 // 669 // <!ELEMENT CLASS 670 // (QUALIFIER,(PROPERTY\|PROPERTY.ARRAY\|PROPERTY.REFERENCE),METHOD)> 671 // <!ATTLIST CLASS 672 // %CIMName; 673 // %SuperClass;> 674 // 675 //------------------------------------------------------------------------------ 676 marek 1.1.2.7 677 void SCMOXmlWriter::appendClassElement( 678 Buffer& out, 679 const SCMOInstance& cimClass) 680 { 681 682 SCMBClass_Main theClass = cimClass.inst.hdr->theClass->cls.hdr; 683 const char* clsBase = cimClass.inst.hdr->theClass->cls.base; 684 685 // Class opening element: 686 out << STRLIT("<CLASS NAME=\""); 687 out.append( 688 &(clsBase[theClass->className.start]), 689 theClass->className.length-1); 690 691 out << STRLIT("\" "); 692 if (0 != theClass->superClassName.start) 693 { 694 out << STRLIT(" SUPERCLASS=\""); 695 out.append( 696 &(clsBase[theClass->superClassName.start]), 697 marek 1.1.2.7 theClass->superClassName.length-1); 698 out << STRLIT("\" "); 699 } 700 out << STRLIT(">\n"); 701 702 // Append class qualifiers 703 SCMBQualifier theArray = 704 (SCMBQualifier)&(clsBase[theClass->qualifierArray.start]); 705 for (Uint32 i=0, n=theClass->numberOfQualifiers;i<n;i++) 706 { 707 SCMOXmlWriter::appendQualifierElement(out,theArray[i],clsBase); 708 } 709 710 // Append Property definitions: 711 for (Uint32 i=0,k=cimClass.getPropertyCount();i<k;i++) 712 { 713 SCMOXmlWriter::appendPropertyElement(out,cimClass,i); 714 } 715
716 marek 1.1.2.8 // ATTN: No method definitions with SCMO today, so do nothing with them 717 // Actually this code does not serve a purpose, but is kept here 718 // for completeness.
719 marek 1.1.2.7 720 // Class closing element: 721 out << STRLIT("</CLASS>\n"); 722 } 723
724 marek 1.1.2.6 // appendLocalClassPathElement() 725 // <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)> 726 void SCMOXmlWriter::appendLocalClassPathElement( 727 Buffer& out, 728 const SCMOInstance& classPath) 729 { 730 out << STRLIT("<LOCALCLASSPATH>\n"); 731 Uint64 hostnameLength=0; 732 const char* hostname=classPath.getHostName_l(hostnameLength); 733 Uint64 nsLength=0; 734 const char* ns=classPath.getNameSpace_l(nsLength); 735 736 appendNameSpacePathElement(out,hostname,hostnameLength-1,ns,nsLength-1); 737 738 Uint64 classNameLength=0; 739 const char* className = classPath.getClassName_l(classNameLength); 740 appendClassNameElement(out, className, classNameLength-1); 741 out << STRLIT("</LOCALCLASSPATH>\n");
742 marek 1.1.2.5 } 743 744 // appendClassPathElement() 745 // <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)> 746 void SCMOXmlWriter::appendClassPathElement( 747 Buffer& out, 748 const SCMOInstance& classPath) 749 { 750 out << STRLIT("<CLASSPATH>\n"); 751 752 Uint64 hostnameLength=0; 753 const char* hostname=classPath.getHostName_l(hostnameLength); 754 Uint64 nsLength=0; 755 const char* ns=classPath.getNameSpace_l(nsLength); 756 757 appendNameSpacePathElement(out,hostname,hostnameLength,ns,nsLength); 758 759 Uint64 classNameLength=0; 760 const char* className = classPath.getClassName_l(classNameLength); 761 762 appendClassNameElement(out, className, classNameLength-1); 763 marek 1.1.2.5 out << STRLIT("</CLASSPATH>\n"); 764 } 765
766 marek 1.1.2.2 void SCMOXmlWriter::appendSCMBUnion( 767 Buffer& out, 768 const SCMBUnion & u, 769 const CIMType & valueType, 770 const char * base) 771 { 772 switch (valueType) 773 { 774 case CIMTYPE_BOOLEAN: 775 {
776 marek 1.1.2.8 if (u.simple.hasValue) 777 { 778 SCMOXmlWriter::append(out, u.simple.val.bin); 779 }
780 marek 1.1.2.2 break; 781 } 782 783 case CIMTYPE_UINT8: 784 {
785 marek 1.1.2.8 if (u.simple.hasValue) 786 { 787 SCMOXmlWriter::append(out, u.simple.val.u8); 788 }
789 marek 1.1.2.2 break; 790 } 791 792 case CIMTYPE_SINT8: 793 {
794 marek 1.1.2.8 if (u.simple.hasValue) 795 { 796 SCMOXmlWriter::append(out, u.simple.val.s8); 797 }
798 marek 1.1.2.2 break; 799 } 800 801 case CIMTYPE_UINT16: 802 {
803 marek 1.1.2.8 if (u.simple.hasValue) 804 { 805 SCMOXmlWriter::append(out, u.simple.val.u16); 806 }
807 marek 1.1.2.2 break; 808 } 809 810 case CIMTYPE_SINT16: 811 {
812 marek 1.1.2.8 if (u.simple.hasValue) 813 { 814 SCMOXmlWriter::append(out, u.simple.val.s16); 815 }
816 marek 1.1.2.2 break; 817 } 818 819 case CIMTYPE_UINT32: 820 {
821 marek 1.1.2.8 if (u.simple.hasValue) 822 { 823 SCMOXmlWriter::append(out, u.simple.val.u32); 824 }
825 marek 1.1.2.2 break; 826 } 827 828 case CIMTYPE_SINT32: 829 {
830 marek 1.1.2.8 if (u.simple.hasValue) 831 { 832 SCMOXmlWriter::append(out, u.simple.val.s32); 833 }
834 marek 1.1.2.2 break; 835 } 836 837 case CIMTYPE_UINT64: 838 {
839 marek 1.1.2.8 if (u.simple.hasValue) 840 { 841 SCMOXmlWriter::append(out, u.simple.val.u64); 842 }
843 marek 1.1.2.2 break; 844 } 845 846 case CIMTYPE_SINT64: 847 {
848 marek 1.1.2.8 if (u.simple.hasValue) 849 { 850 SCMOXmlWriter::append(out, u.simple.val.s64); 851 }
852 marek 1.1.2.2 break; 853 } 854 855 case CIMTYPE_REAL32: 856 {
857 marek 1.1.2.8 if (u.simple.hasValue) 858 { 859 SCMOXmlWriter::append(out, u.simple.val.r32); 860 }
861 marek 1.1.2.2 break; 862 } 863 864 case CIMTYPE_REAL64: 865 {
866 marek 1.1.2.8 if (u.simple.hasValue) 867 { 868 SCMOXmlWriter::append(out, u.simple.val.r64); 869 }
870 marek 1.1.2.2 break; 871 } 872 873 case CIMTYPE_CHAR16: 874 {
875 marek 1.1.2.8 if (u.simple.hasValue) 876 { 877 SCMOXmlWriter::appendSpecial( 878 out, 879 u.simple.val.c16); 880 }
881 marek 1.1.2.2 break; 882 } 883 884 case CIMTYPE_STRING: 885 {
886 marek 1.1.2.8 if (u.stringValue.start) 887 { 888 SCMOXmlWriter::appendSpecial( 889 out, 890 &(base[u.stringValue.start]), 891 u.stringValue.length-1); 892 }
893 marek 1.1.2.2 break; 894 } 895 896 case CIMTYPE_DATETIME: 897 { 898 // an SCMBDateTime is a CIMDateTimeRep 899 // this should help us to reuse existing optimized Datetime 900 char buffer[26]; 901 _DateTimetoCStr(&(u.dateTimeValue), buffer); 902 // datetime value is formatted with a \0 at end, ignore 903 out.append(buffer,sizeof(buffer)-1); 904 break; 905 }
906 marek 1.1.2.8 // Object and Instance are both written the same way, namely as 907 // object element which then is encoded using appendSpecial
908 marek 1.1.2.2 case CIMTYPE_OBJECT: 909 case CIMTYPE_INSTANCE: 910 {
911 marek 1.1.2.8 Buffer toEncodeObject(4000); 912 SCMOInstance * obj = u.extRefPtr; 913 if (obj) 914 { 915 appendObjectElement(toEncodeObject, *obj); 916 SCMOXmlWriter::appendSpecial( 917 out, 918 toEncodeObject.getData(), 919 toEncodeObject.size()); 920 }
921 marek 1.1.2.2 break; 922 } 923 default:
924 marek 1.1.2.8 // CIMTYPE_REFERENCE has been handled upfront, do nothing here 925 break;
926 marek 1.1.2.2 } 927 } 928
929 marek 1.1.2.3 void SCMOXmlWriter::appendSCMBUnionArray( 930 Buffer& out, 931 const SCMBUnion & u, 932 const CIMType & valueType, 933 Uint32 numElements, 934 const char * base) 935 { 936 SCMBUnion* arr = (SCMBUnion*) &(base[u.arrayValue.start]); 937 switch (valueType) 938 { 939 case CIMTYPE_BOOLEAN: 940 { 941 out << STRLIT("<VALUE.ARRAY>\n"); 942 while (numElements--) 943 { 944 out << STRLIT("<VALUE>"); 945 SCMOXmlWriter::append(out, arr->simple.val.bin); 946 arr++; 947 out << STRLIT("</VALUE>\n"); 948 } 949 out << STRLIT("</VALUE.ARRAY>\n"); 950 marek 1.1.2.3 break; 951 } 952 case CIMTYPE_UINT8: 953 { 954 out << STRLIT("<VALUE.ARRAY>\n"); 955 while (numElements--) 956 { 957 out << STRLIT("<VALUE>"); 958 SCMOXmlWriter::append(out, arr->simple.val.u8); 959 arr++; 960 out << STRLIT("</VALUE>\n"); 961 } 962 out << STRLIT("</VALUE.ARRAY>\n"); 963 break; 964 }
965 marek 1.1.2.6
966 marek 1.1.2.3 case CIMTYPE_SINT8: 967 { 968 out << STRLIT("<VALUE.ARRAY>\n"); 969 while (numElements--) 970 { 971 out << STRLIT("<VALUE>"); 972 SCMOXmlWriter::append(out, arr->simple.val.s8); 973 arr++; 974 out << STRLIT("</VALUE>\n"); 975 } 976 out << STRLIT("</VALUE.ARRAY>\n"); 977 break; 978 }
979 marek 1.1.2.6
980 marek 1.1.2.3 case CIMTYPE_UINT16: 981 { 982 out << STRLIT("<VALUE.ARRAY>\n"); 983 while (numElements--) 984 { 985 out << STRLIT("<VALUE>"); 986 SCMOXmlWriter::append(out, arr->simple.val.u16); 987 arr++; 988 out << STRLIT("</VALUE>\n"); 989 } 990 out << STRLIT("</VALUE.ARRAY>\n"); 991 break; 992 }
993 marek 1.1.2.6
994 marek 1.1.2.3 case CIMTYPE_SINT16: 995 { 996 out << STRLIT("<VALUE.ARRAY>\n"); 997 while (numElements--) 998 { 999 out << STRLIT("<VALUE>"); 1000 SCMOXmlWriter::append(out, arr->simple.val.s16); 1001 arr++; 1002 out << STRLIT("</VALUE>\n"); 1003 } 1004 out << STRLIT("</VALUE.ARRAY>\n"); 1005 break; 1006 }
1007 marek 1.1.2.6
1008 marek 1.1.2.3 case CIMTYPE_UINT32: 1009 { 1010 out << STRLIT("<VALUE.ARRAY>\n"); 1011 while (numElements--) 1012 { 1013 out << STRLIT("<VALUE>"); 1014 SCMOXmlWriter::append(out, arr->simple.val.u32); 1015 arr++; 1016 out << STRLIT("</VALUE>\n"); 1017 } 1018 out << STRLIT("</VALUE.ARRAY>\n"); 1019 break; 1020 }
1021 marek 1.1.2.6
1022 marek 1.1.2.3 case CIMTYPE_SINT32: 1023 { 1024 out << STRLIT("<VALUE.ARRAY>\n"); 1025 while (numElements--) 1026 { 1027 out << STRLIT("<VALUE>"); 1028 SCMOXmlWriter::append(out, arr->simple.val.s32); 1029 arr++; 1030 out << STRLIT("</VALUE>\n"); 1031 } 1032 out << STRLIT("</VALUE.ARRAY>\n"); 1033 break; 1034 }
1035 marek 1.1.2.6
1036 marek 1.1.2.3 case CIMTYPE_UINT64: 1037 { 1038 out << STRLIT("<VALUE.ARRAY>\n"); 1039 while (numElements--) 1040 { 1041 out << STRLIT("<VALUE>"); 1042 SCMOXmlWriter::append(out, arr->simple.val.u64); 1043 arr++; 1044 out << STRLIT("</VALUE>\n"); 1045 } 1046 out << STRLIT("</VALUE.ARRAY>\n"); 1047 break; 1048 }
1049 marek 1.1.2.6
1050 marek 1.1.2.3 case CIMTYPE_SINT64: 1051 { 1052 out << STRLIT("<VALUE.ARRAY>\n"); 1053 while (numElements--) 1054 { 1055 out << STRLIT("<VALUE>"); 1056 SCMOXmlWriter::append(out, arr->simple.val.s64); 1057 arr++; 1058 out << STRLIT("</VALUE>\n"); 1059 } 1060 out << STRLIT("</VALUE.ARRAY>\n"); 1061 break; 1062 }
1063 marek 1.1.2.6
1064 marek 1.1.2.3 case CIMTYPE_REAL32: 1065 { 1066 out << STRLIT("<VALUE.ARRAY>\n"); 1067 while (numElements--) 1068 { 1069 out << STRLIT("<VALUE>"); 1070 SCMOXmlWriter::append(out, arr->simple.val.r32); 1071 arr++; 1072 out << STRLIT("</VALUE>\n"); 1073 } 1074 out << STRLIT("</VALUE.ARRAY>\n"); 1075 break; 1076 }
1077 marek 1.1.2.6
1078 marek 1.1.2.3 case CIMTYPE_REAL64: 1079 { 1080 out << STRLIT("<VALUE.ARRAY>\n"); 1081 while (numElements--) 1082 { 1083 out << STRLIT("<VALUE>"); 1084 SCMOXmlWriter::append(out, arr->simple.val.r64); 1085 arr++; 1086 out << STRLIT("</VALUE>\n"); 1087 } 1088 out << STRLIT("</VALUE.ARRAY>\n"); 1089 break; 1090 }
1091 marek 1.1.2.6
1092 marek 1.1.2.3 case CIMTYPE_CHAR16: 1093 { 1094 out << STRLIT("<VALUE.ARRAY>\n"); 1095 while (numElements--) 1096 { 1097 out << STRLIT("<VALUE>"); 1098 SCMOXmlWriter::append(out, arr->simple.val.bin); 1099 SCMOXmlWriter::appendSpecial(out, arr->simple.val.c16); 1100 arr++; 1101 out << STRLIT("</VALUE>\n"); 1102 } 1103 out << STRLIT("</VALUE.ARRAY>\n"); 1104 break; 1105 }
1106 marek 1.1.2.6
1107 marek 1.1.2.3 case CIMTYPE_STRING: 1108 { 1109 out << STRLIT("<VALUE.ARRAY>\n"); 1110 while (numElements--) 1111 { 1112 out << STRLIT("<VALUE>"); 1113 SCMOXmlWriter::appendSpecial( 1114 out, 1115 &(base[arr->stringValue.start]), 1116 arr->stringValue.length-1); 1117 arr++; 1118 out << STRLIT("</VALUE>\n"); 1119 } 1120 out << STRLIT("</VALUE.ARRAY>\n");
1121 marek 1.1.2.6
1122 marek 1.1.2.3 break; 1123 }
1124 marek 1.1.2.6
1125 marek 1.1.2.3 case CIMTYPE_DATETIME: 1126 { 1127 out << STRLIT("<VALUE.ARRAY>\n"); 1128 char buffer[26]; 1129 while (numElements--) 1130 { 1131 out << STRLIT("<VALUE>"); 1132 // an SCMBDateTime is a CIMDateTimeRep 1133 // this should help us to reuse existing optimized Datetime 1134 _DateTimetoCStr(&(arr->dateTimeValue), buffer); 1135 // datetime value is formatted with a \0 at end, ignore 1136 out.append(buffer,sizeof(buffer)-1); 1137 arr++; 1138 out << STRLIT("</VALUE>\n"); 1139 }
1140 marek 1.1.2.6 out << STRLIT("</VALUE.ARRAY>\n");
1141 marek 1.1.2.3 break;
1142 marek 1.1.2.6 }
1143 marek 1.1.2.8 case CIMTYPE_REFERENCE:
1144 marek 1.1.2.3 {
1145 marek 1.1.2.8 out << STRLIT("<VALUE.REFARRAY>\n"); 1146 while (numElements--) 1147 { 1148 SCMOInstance * ref = arr->extRefPtr; 1149 if (ref) 1150 { 1151 appendValueReferenceElement(out, *ref, true); 1152 } 1153 arr++; 1154 } 1155 out << STRLIT("</VALUE.REFARRAY>\n");
1156 marek 1.1.2.3 }
1157 marek 1.1.2.8 case CIMTYPE_OBJECT:
1158 marek 1.1.2.3 case CIMTYPE_INSTANCE: 1159 {
1160 marek 1.1.2.8 out << STRLIT("<VALUE.ARRAY>\n"); 1161 Buffer toEncodeObject(4000); 1162 while (numElements--) 1163 { 1164 toEncodeObject.clear(); 1165 out << STRLIT("<VALUE>"); 1166 SCMOInstance * obj = arr->extRefPtr; 1167 if (obj) 1168 { 1169 appendObjectElement(toEncodeObject, *obj); 1170 SCMOXmlWriter::appendSpecial( 1171 out, 1172 toEncodeObject.getData(), 1173 toEncodeObject.size()); 1174 } 1175 arr++; 1176 out << STRLIT("</VALUE>\n"); 1177 } 1178 out << STRLIT("</VALUE.ARRAY>\n");
1179 marek 1.1.2.3 break; 1180 } 1181 default:
1182 marek 1.1.2.8 PEGASUS_DEBUG_ASSERT(false);
1183 marek 1.1.2.3 } 1184 1185 } 1186 1187
1188 marek 1.1.2.2
1189 marek 1.1.2.1 PEGASUS_NAMESPACE_END

No CVS admin address has been configured