(file) Return to SCMOXmlWriter.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/SCMOXmlWriter.h between version 1.1.2.3 and 1.1.2.9

version 1.1.2.3, 2009/09/18 09:11:11 version 1.1.2.9, 2009/10/14 10:12:39
Line 48 
Line 48 
  
     static void appendValueSCMOInstanceElement(     static void appendValueSCMOInstanceElement(
         Buffer& out,         Buffer& out,
         const SCMOInstance& scmoInstance)          const SCMOInstance& scmoInstance);
     {  
         out << STRLIT("<VALUE.NAMEDINSTANCE>\n");  
   
         appendInstanceNameElement(out, scmoInstance);  
         appendInstanceElement(out, scmoInstance);  
   
         out << STRLIT("</VALUE.NAMEDINSTANCE>\n");  
     }  
  
     static void appendInstanceNameElement(     static void appendInstanceNameElement(
         Buffer& out,         Buffer& out,
         const SCMOInstance& scmoInstance)          const SCMOInstance& scmoInstance);
     {  
         out << STRLIT("<INSTANCENAME CLASSNAME=\"");  
         Uint64 len;  
         const char * className = scmoInstance.getClassName_l(len);  
         out.append(className,len-1);  
         out << STRLIT("\">\n");  
   
         for (Uint32 i = 0, n = scmoInstance.getKeyBindingCount(); i < n; i++)  
         {  
             const char * kbName;  
             const SCMBUnion * kbValue;  
             CIMType kbType;  
             Uint32 kbNameLen;  
   
             scmoInstance._getKeyBindingDataAtNodeIndex(  
                 i,  
                 &kbName,  
                 kbNameLen,  
                 kbType,  
                 &kbValue);  
   
             /* TODO: NEED to handle new _getKeyBindingDataAtNodeIndex()  
             out << STRLIT("<KEYBINDING NAME=\"");  
             out.append(kbName,kbNameLen-1);  
             out << STRLIT("\">\n");  
   
             if (kbType == CIMKeyBinding::REFERENCE)  
             {  
                 TODO: NEED RESOLvE the value down to a SCMO....  
                 CIMObjectPath ref = keyBindings[i].getValue();  
                 appendValueReferenceElement(out, ref, true);  
             }  
             else  
             {  
                 out << STRLIT("<KEYVALUE VALUETYPE=\"");  
                 out << keyBindingTypeToString(kbType);  
                 out << STRLIT("\">");  
   
                 // fixed the special character problem - Markus  
   
                 appendSpecial(out, kbValue, kbValueLen-1);  
                 out << STRLIT("</KEYVALUE>\n");  
             }  
             out << STRLIT("</KEYBINDING>\n");  
             */  
         }  
         out << STRLIT("</INSTANCENAME>\n");  
     }  
  
 //------------------------------------------------------------------------------  
 //  
 // appendInstanceElement()  
 //  
 //     <!ELEMENT INSTANCE  
 //         (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>  
 //     <!ATTLIST INSTANCE  
 //         %ClassName;>  
 //  
 //------------------------------------------------------------------------------  
     static void appendInstanceElement(     static void appendInstanceElement(
         Buffer& out,         Buffer& out,
         const SCMOInstance& scmoInstance)          const SCMOInstance& scmoInstance);
     {  
         // Class opening element:  
   
         out << STRLIT("<INSTANCE CLASSNAME=\"");  
         Uint64 len;  
         const char * className = scmoInstance.getClassName_l(len);  
         out.append(className,len-1);  
         out << STRLIT("\" >\n");  
   
         // Append Instance Qualifiers:  
         if (scmoInstance.inst.hdr->flags.includeQualifiers)  
         {  
             SCMBClass_Main *classMain=scmoInstance.inst.hdr->theClass->cls.hdr;  
             char* clsbase = scmoInstance.inst.hdr->theClass->cls.base;  
  
             SCMBQualifier *theArray =      static void appendQualifierElement(
                 (SCMBQualifier*)&(clsbase[classMain->qualifierArray.start]);          Buffer& out,
             // need to iterate          const SCMBQualifier& theQualifier,
             for (Uint32 i=0, n=classMain->numberOfQualifiers;i<n;i++)          const char* base);
             {  
                 SCMOXmlWriter::appendQualifierElement(out,theArray[i],clsbase);  
             }  
         }  
  
         // Append Properties:      static void appendPropertyElement(
         for (Uint32 i=0,k=scmoInstance.inst.hdr->numberProperties;i<k;i++)          Buffer& out,
         {          const SCMOInstance& scmoInstance,
             if (scmoInstance.inst.hdr->flags.isFiltered &&          Uint32 pos);
                 !scmoInstance._isPropertyInFilter(i))  
             {  
                 // Property is filtered, ignore and go to next  
                 continue;  
             }  
             else  
             {  
                 SCMOXmlWriter::appendPropertyElement(out,scmoInstance,i);  
             }  
         }  
         // Instance closing element:  
         out << STRLIT("</INSTANCE>\n");  
     }  
  
       static void appendValueElement(
           Buffer& out,
           const SCMBValue & value,
           const char * base);
  
       static void appendValueReferenceElement(
           Buffer& out,
           const SCMOInstance& ref,
           Boolean putValueWrapper);
  
 //------------------------------------------------------------------------------      static void appendLocalInstancePathElement(
 //          Buffer& out,
 // appendQualifierElement()          const SCMOInstance& instancePath);
 //  
 //     <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>  
 //     <!ATTLIST QUALIFIER  
 //              %CIMName;  
 //              %CIMType;               #REQUIRED  
 //              %Propagated;  
 //              %QualifierFlavor;>  
 //  
 //------------------------------------------------------------------------------  
  
     static void appendQualifierElement(      static void appendInstancePathElement(
         Buffer& out,         Buffer& out,
         const SCMBQualifier& theQualifier,          const SCMOInstance& instancePath);
         const char* base)  
     {  
         out << STRLIT("<QUALIFIER NAME=\"");  
         if(theQualifier.name == QUALNAME_USERDEFINED)  
         {  
             if (theQualifier.userDefName.start)  
             {  
                 out.append(  
                     &(base[theQualifier.userDefName.start]),  
                     theQualifier.userDefName.length-1);  
             }  
         }  
         else  
         {  
             out << SCMOClass::qualifierNameStrLit(theQualifier.name);  
         }  
  
         out << STRLIT("\" ");      static void appendLocalClassPathElement(
           Buffer& out,
           const SCMOInstance& classPath);
  
         // Append type      static void appendClassPathElement(
         out << xmlWriterTypeStrings(theQualifier.value.valueType);          Buffer& out,
         // append PROPAGATED if set          const SCMOInstance& classPath);
         if (theQualifier.propagated)  
         {  
             out << STRLIT(" PROPAGATED=\"true\"");  
         }  
         // append flavor of the qualifier  
         SCMOXmlWriter::appendQualifierFlavorEntity(  
             out,  
             CIMFlavor(theQualifier.flavor));  
  
         out << STRLIT(">\n");      static void appendSCMBUnion(
         // append the value of the qualifier          Buffer& out,
           const SCMBUnion & u,
           const CIMType & valueType,
           const char * base);
  
         // TODO: Implement and call appendValueElement      static void appendSCMBUnionArray(
         //SCMOXmlWriter::appendValueElement(out, theQualifier.value, clsbase);          Buffer& out,
           const SCMBUnion & u,
           const CIMType & valueType,
           Uint32 numElements,
           const char * base);
  
         out << STRLIT("</QUALIFIER>\n");  private:
     }      SCMOXmlWriter();
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendPropertyElement()  // appendLocalNameSpacePathElement()
 //  
 //     <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>  
 //     <!ATTLIST PROPERTY  
 //              %CIMName;  
 //              %CIMType;           #REQUIRED  
 //              %ClassOrigin;  
 //              %Propagated;>  
 //  
 //     <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>  
 //     <!ATTLIST PROPERTY.ARRAY  
 //              %CIMName;  
 //              %CIMType;           #REQUIRED  
 //              %ArraySize;  
 //              %ClassOrigin;  
 //              %Propagated;>  
 // //
 //     <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>  //     <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
 //     <!ATTLIST PROPERTY.REFERENCE  
 //              %CIMName;  
 //              %ReferenceClass;  
 //              %ClassOrigin;  
 //              %Propagated;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
       static void appendLocalNameSpacePathElement(
     static void appendPropertyElement(  
         Buffer& out,         Buffer& out,
         const SCMOInstance& scmoInstance,          const char * nameSpace,
         Uint32 pos)          Uint64 nameSpaceLength)
     {  
         // Get most of the property data from the instance  
         const char* propertyName;  
         Uint32 propertyNameLen;  
         CIMType propertyType;  
   
         // This is an absolute pointer at a SCMBValue  
         SCMBValue * propertyValue;  
         const char * propertyValueBase;  
         // This is an absolute pointer at a SCMBValue  
         SCMBClassProperty * propertyDef;  
         // This is the absolute pointer at which the class info for the given  
         // instance starts  
         const char* clsbase = scmoInstance.inst.hdr->theClass->cls.base;  
   
         SCMO_RC rc = scmoInstance.getPropertyAt(  
             pos,  
             &propertyValue,  
             &propertyValueBase,  
             &propertyDef);  
   
         propertyType = propertyValue->valueType;  
   
   
         if (propertyValue->flags.isArray)  
         {  
 /*  
             out << STRLIT("<PROPERTY.ARRAY NAME=\"")  
                 << rep->getName()  
                 << STRLIT("\" ");  
   
             if (propertyType == CIMTYPE_OBJECT)  
             {  
                 // If the property array type is CIMObject, then  
                 //    encode the property in CIM-XML as a string array with the  
                 //    EmbeddedObject attribute (there is not currently a CIM-XML  
                 //    "object" datatype)  
   
                 Array<CIMObject> a;  
                 rep->getValue().get(a);  
                 out << STRLIT(" TYPE=\"string\"");  
                 // If the Embedded Object is an instance, always add the  
                 // EmbeddedObject attribute.  
                 if (a.size() > 0 && a[0].isInstance())  
                 {  
                     out << STRLIT(" EmbeddedObject=\"object\""  
                                   " EMBEDDEDOBJECT=\"object\"");  
                 }  
 #ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY  
                 else  
 #endif  
                 {  
                     // Else the Embedded Object is a class, always add the  
                     // EmbeddedObject qualifier.  Note that if the macro  
                     // PEGASUS_SNIA_INTEROP_COMPATIBILITY is defined, then  
                     // the EmbeddedObject qualifier will always be added,  
                     // whether it's a class or an instance.  
                     if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT)  
                        == PEG_NOT_FOUND)  
                     {  
                         // Note that addQualifiers() cannot be called on a const  
                         // CIMQualifierRep.In this case we really do want to add  
                         // the EmbeddedObject qualifier, so we cast away the  
                         // constness.  
                         CIMPropertyRep* tmpRep=const_cast<CIMPropertyRep*>(rep);  
                         tmpRep->addQualifier(  
                             CIMQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT,  
                                          true));  
                     }  
                 }  
             }  
             else if (propertyType == CIMTYPE_INSTANCE)  
             {  
                 // If the property array type is CIMInstance, then  
                 //   encode the property in CIM-XML as a string array with the  
                 //   EmbeddedObject attribute (there is not currently a CIM-XML  
                 //   "instance" datatype)  
   
                 Array<CIMInstance> a;  
                 rep->getValue().get(a);  
                 out << STRLIT(" TYPE=\"string\"");  
   
                 // add the EmbeddedObject attribute  
                 if (a.size() > 0)  
                 {                 {
                     out << STRLIT(" EmbeddedObject=\"instance\""          // add one byte for the closing \0
                                   " EMBEDDEDOBJECT=\"instance\"");          nameSpaceLength++;
           out << STRLIT("<LOCALNAMESPACEPATH>\n");
  
                     // Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY          char fixed[64];
                     // is defined, then the EmbeddedInstance qualifier will be          char* nameSpaceCopy;
                     // added          if (nameSpaceLength > 64)
 # ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY  
                     if (rep->findQualifier(  
                             PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE ==  
                             PEG_NOT_FOUND)  
                     {                     {
                         // Note that addQualifiers() cannot be called on a const              nameSpaceCopy=(char*)malloc(nameSpaceLength);
                         // CIMQualifierRep.In this case we really do want to add  
                         // the EmbeddedInstance qualifier, so we cast away the  
                         // constness.  
   
                         // For now, we assume that all the embedded instances in  
                         // the array are of the same type  
                         CIMPropertyRep* tmpRep=const_cast<CIMPropertyRep*>(rep);  
                         tmpRep->addQualifier(CIMQualifier(  
                             PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE,  
                             a[0].getClassName().getString()));  
                     }  
 # endif  
                 }  
             }             }
             else             else
             {             {
                 out.append(' ');              nameSpaceCopy = &(fixed[0]);
                 out << xmlWriterTypeStrings(rep->getValue().getType());  
             }  
   
             if (rep->getArraySize())  
             {  
                 char buffer[32];  
                 sprintf(buffer, "%u", rep->getArraySize());  
                 out << STRLIT(" ARRAYSIZE=\"") << buffer;  
                 out.append('"');  
             }  
   
             if (!rep->getClassOrigin().isNull())  
             {  
                 out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();  
                 out.append('"');  
             }  
   
             if (rep->getPropagated())  
             {  
                 out << STRLIT(" PROPAGATED=\"true\"");  
             }  
   
             out << STRLIT(">\n");  
   
             for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)  
                 XmlWriter::appendQualifierElement(out, rep->getQualifier(i));  
   
             XmlWriter::appendValueElement(out, rep->getValue());  
   
             out << STRLIT("</PROPERTY.ARRAY>\n");  
 */  
         }  
         else if (propertyType == CIMTYPE_REFERENCE)  
         {  
 /*  
             out << STRLIT("<PROPERTY.REFERENCE"  
                           " NAME=\"") << rep->getName() << STRLIT("\" ");  
   
             if (!rep->getReferenceClassName().isNull())  
             {  
                 out << STRLIT(" REFERENCECLASS=\"")  
                     << rep->getReferenceClassName();  
                 out.append('"');  
             }  
   
             if (!rep->getClassOrigin().isNull())  
             {  
                 out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();  
                 out.append('"');  
             }  
   
             if (rep->getPropagated())  
             {  
                 out << STRLIT(" PROPAGATED=\"true\"");  
             }  
   
             out << STRLIT(">\n");  
   
             for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)  
                 XmlWriter::appendQualifierElement(out, rep->getQualifier(i));  
   
             XmlWriter::appendValueElement(out, rep->getValue());  
   
             out << STRLIT("</PROPERTY.REFERENCE>\n");  
 */  
         }  
         else  
         {  
             // TODO: Optimize the property name using length as input  
             out << STRLIT("<PROPERTY NAME=\"");  
   
             out.append(  
                 &(clsbase[propertyDef->name.start]),  
                 propertyDef->name.length-1);  
   
             out << STRLIT("\" ");  
   
             if (scmoInstance.inst.hdr->flags.includeClassOrigin)  
             {  
                 if (propertyDef->originClassName.start != 0)  
                 {  
                     out << STRLIT(" CLASSORIGIN=\"");  
                     out.append(  
                         &(clsbase[propertyDef->originClassName.start]),  
                         propertyDef->originClassName.length-1);  
                     out.append('"');  
                 }  
             }  
             if (propertyDef->flags.propagated)  
             {  
                 out << STRLIT(" PROPAGATED=\"true\"");  
             }             }
           memcpy(nameSpaceCopy, nameSpace, nameSpaceLength);
  
             if (propertyType == CIMTYPE_OBJECT)  #if !defined(PEGASUS_COMPILER_MSVC) && !defined(PEGASUS_OS_ZOS)
             {          char *last;
 /*          for (const char* p = strtok_r(nameSpaceCopy, "/", &last); p;
                 // If the property type is CIMObject, then              p = strtok_r(NULL, "/", &last))
                 //   encode the property in CIM-XML as a string with the  #else
                 //   EmbeddedObject attribute (there is not currently a CIM-XML          for (const char* p = strtok(nameSpaceCopy, "/"); p;
                 //   "object" datatype)              p = strtok(NULL, "/"))
   
                 CIMObject a;  
                 rep->getValue().get(a);  
                 out << STRLIT(" TYPE=\"string\"");  
   
                 // If the Embedded Object is an instance, always add the  
                 // EmbeddedObject attribute.  
                 if (a.isInstance())  
                 {  
                     out << STRLIT(" EmbeddedObject=\"object\""  
                                   " EMBEDDEDOBJECT=\"object\"");  
                 }  
                 // Else the Embedded Object is a class, always add the  
                 // EmbeddedObject qualifier.  
 #ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY  
                 else  
 #endif #endif
                 {                 {
                     // Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY              out << STRLIT("<NAMESPACE NAME=\"") << p << STRLIT("\"/>\n");
                     // is defined, then the EmbeddedObject qualifier will always  
                     // be added, whether it's a class or an instance.  
                     if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT)  
                         == PEG_NOT_FOUND)  
                     {  
                         // Note that addQualifiers() cannot be called on a const  
                         // CIMQualifierRep.  In this case we really do want to  
                         // add the EmbeddedObject qualifier, so we cast away the  
                         // constness.  
                         CIMPropertyRep* tmpRep=const_cast<CIMPropertyRep*>(rep);  
                         tmpRep->addQualifier(  
                             CIMQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT,  
                                          true));  
                     }  
                 }  
 */  
             }  
             else if (propertyType == CIMTYPE_INSTANCE)  
             {  
 /*  
                 CIMInstance a;  
                 rep->getValue().get(a);  
                 out << STRLIT(" TYPE=\"string\""  
                               " EmbeddedObject=\"instance\""  
                               " EMBEDDEDOBJECT=\"instance\"");  
   
 # ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY  
                 if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT)  
                     == PEG_NOT_FOUND)  
                 {  
                     // Note that addQualifiers() cannot be called on a const  
                     // CIMQualifierRep.  In this case we really do want to add  
                     // the EmbeddedInstance qualifier, so we cast away the  
                     // constness.  
                     CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);  
                     tmpRep->addQualifier(CIMQualifier(  
                         PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE,  
                         a.getClassName().getString()));  
                 }  
 # endif  
 */  
             }  
             else  
             {  
                 out.append(' ');  
                 out << xmlWriterTypeStrings(propertyType);  
             }             }
             out << STRLIT(">\n");          if (nameSpaceLength > 64)
   
             // Append Instance Qualifiers:  
             if (scmoInstance.inst.hdr->flags.includeQualifiers)  
             {  
                 SCMBQualifier * theArray=  
                     (SCMBQualifier*)  
                         &(clsbase[propertyDef->qualifierArray.start]);  
                 // need to iterate  
                 for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++)  
                 {                 {
                     SCMOXmlWriter::appendQualifierElement(              free(nameSpaceCopy);
                         out,  
                         theArray[i],  
                         clsbase);  
                 }                 }
           out << STRLIT("</LOCALNAMESPACEPATH>\n");
             }             }
             SCMOXmlWriter::appendValueElement(  
                 out,  
                 propertyValue,  
                 propertyValueBase);  
  
             out << STRLIT("</PROPERTY>\n");  
         }  
     }  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendValueElement()  // appendNameSpacePathElement()
 // //
 //    <!ELEMENT VALUE (#PCDATA)>  //     <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
 //    <!ELEMENT VALUE.ARRAY (VALUE*)>  
 //    <!ELEMENT VALUE.REFERENCE  
 //        (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|  
 //         INSTANCENAME)>  
 //    <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
     static void appendValueElement(      static void appendNameSpacePathElement(
         Buffer& out,         Buffer& out,
         SCMBValue * value,          const char* host,
         const char * base)          Uint64 hostLength,
     {          const char * nameSpace,
         if (value->flags.isNull)          Uint64 nameSpaceLength)
         {  
             return;  
         }  
         if (value->flags.isArray)  
         {  
 /*  
             switch (value.getType())  
             {  
                 case CIMTYPE_BOOLEAN:  
                 {  
                     Array<Boolean> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_UINT8:  
                 {  
                     Array<Uint8> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_SINT8:  
                 {  
                     Array<Sint8> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_UINT16:  
                 {  
                     Array<Uint16> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_SINT16:  
                 {  
                     Array<Sint16> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_UINT32:  
                 {  
                     Array<Uint32> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_SINT32:  
                 {  
                     Array<Sint32> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_UINT64:  
                 {  
                     Array<Uint64> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_SINT64:  
                 {                 {
                     Array<Sint64> a;          out << STRLIT("<NAMESPACEPATH>\n""<HOST>");
                     value.get(a);          out.append(host, hostLength);
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());          out << STRLIT("</HOST>\n");
                     break;          appendLocalNameSpacePathElement(out, nameSpace, nameSpaceLength);
           out << STRLIT("</NAMESPACEPATH>\n");
                 }                 }
  
                 case CIMTYPE_REAL32:  //------------------------------------------------------------------------------
                 {  // appendClassNameElement()
                     Array<Real32> a;  //     <!ELEMENT CLASSNAME EMPTY>
                     value.get(a);  //     <!ATTLIST CLASSNAME
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  //              %CIMName;>
                     break;  //------------------------------------------------------------------------------
                 }      static void appendClassNameElement(
           Buffer& out,
                 case CIMTYPE_REAL64:          const char* className,
                 {          Uint64 classNameLength)
                     Array<Real64> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_CHAR16:  
                 {  
                     Array<Char16> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_STRING:  
                 {  
                     const String* data;  
                     Uint32 size;  
                     value._get(data, size);  
                     _xmlWritter_appendValueArray(out, data, size);  
                     break;  
                 }  
   
                 case CIMTYPE_DATETIME:  
                 {  
                     Array<CIMDateTime> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_REFERENCE:  
                 {  
                     Array<CIMObjectPath> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
   
                 case CIMTYPE_OBJECT:  
                 {  
                     Array<CIMObject> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
                 case CIMTYPE_INSTANCE:  
                 {  
                     Array<CIMInstance> a;  
                     value.get(a);  
                     _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                     break;  
                 }  
                 default:  
                     PEGASUS_ASSERT(false);  
             }  
 */  
         }  
         else if (value->valueType == CIMTYPE_REFERENCE)  
         {  
 /*  
             // Has to be separate because it uses VALUE.REFERENCE tag  
             CIMObjectPath v;  
             value.get(v);  
             _xmlWritter_appendValue(out, v);  
 */  
         }  
         else  
         {  
             out << STRLIT("<VALUE>");  
   
             switch (value->valueType)  
             {  
                 case CIMTYPE_BOOLEAN:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.bin);  
                     break;  
                 }  
   
                 case CIMTYPE_UINT8:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.u8);  
                     break;  
                 }  
   
                 case CIMTYPE_SINT8:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.s8);  
                     break;  
                 }  
   
                 case CIMTYPE_UINT16:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.u16);  
                     break;  
                 }  
   
                 case CIMTYPE_SINT16:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.s16);  
                     break;  
                 }  
   
                 case CIMTYPE_UINT32:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.u32);  
                     break;  
                 }  
   
                 case CIMTYPE_SINT32:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.s32);  
                     break;  
                 }  
   
                 case CIMTYPE_UINT64:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.u64);  
                     break;  
                 }  
   
                 case CIMTYPE_SINT64:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.s64);  
                     break;  
                 }  
   
                 case CIMTYPE_REAL32:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.r32);  
                     break;  
                 }  
   
                 case CIMTYPE_REAL64:  
                 {  
                     SCMOXmlWriter::append(out, value->value.simple.val.r64);  
                     break;  
                 }  
   
                 case CIMTYPE_CHAR16:  
                 {  
                     SCMOXmlWriter::appendSpecial(  
                         out,  
                         value->value.simple.val.c16);  
                     break;  
                 }  
   
                 case CIMTYPE_STRING:  
                 {  
                     SCMOXmlWriter::appendSpecial(  
                         out,  
                         &(base[value->value.stringValue.start]),  
                         value->value.stringValue.length-1);  
                     break;  
                 }  
   
                 case CIMTYPE_DATETIME:  
                 {  
                     // an SCMBDateTime is a CIMDateTimeRep  
                     // this should help us to reuse existing optimized Datetime  
                     char buffer[26];  
                     _DateTimetoCStr(&(value->value.dateTimeValue), buffer);  
                     // datetime value is formatted with a \0 at end, ignore  
                     out.append(buffer,sizeof(buffer)-1);  
                     break;  
                 }  
 /*  
                 case CIMTYPE_OBJECT:  
                 {  
                     CIMObject v;  
                     value.get(v);  
                     _xmlWritter_appendValue(out, v);  
                     break;  
                 }  
                 case CIMTYPE_INSTANCE:  
                 {                 {
                     CIMInstance v;          out << STRLIT("<CLASSNAME NAME=\"");
                     value.get(v);          out.append(className, classNameLength);
                     _xmlWritter_appendValue(out, v);          out << STRLIT("\"/>\n");
                     break;  
                 }                 }
                 default:  
                     PEGASUS_ASSERT(false);  
 */  
             }  
             out << STRLIT("</VALUE>\n");  
         }  
     }  
   
 private:  
   
   
     SCMOXmlWriter();  
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.1.2.3  
changed lines
  Added in v.1.1.2.9
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2