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

Diff for /pegasus/src/Pegasus/Common/SCMOXmlWriter.cpp between version 1.1.2.2 and 1.1.2.3

version 1.1.2.2, 2009/09/28 13:24:08 version 1.1.2.3, 2009/09/29 08:18:49
Line 272 
Line 272 
  
     if (propertyValue->flags.isArray)     if (propertyValue->flags.isArray)
     {     {
 /*          out << STRLIT("<PROPERTY.ARRAY NAME=\"");
         out << STRLIT("<PROPERTY.ARRAY NAME=\"")  
             << rep->getName()  
             << STRLIT("\" ");  
  
           out.append(
               &(clsbase[propertyDef->name.start]),
               propertyDef->name.length-1);
   
           out << STRLIT("\" ");
         if (propertyType == CIMTYPE_OBJECT)         if (propertyType == CIMTYPE_OBJECT)
         {         {
   /*
             // If the property array type is CIMObject, then             // If the property array type is CIMObject, then
             //    encode the property in CIM-XML as a string array with the             //    encode the property in CIM-XML as a string array with the
             //    EmbeddedObject attribute (there is not currently a CIM-XML             //    EmbeddedObject attribute (there is not currently a CIM-XML
Line 316 
Line 319 
                                      true));                                      true));
                 }                 }
             }             }
   */
         }         }
         else if (propertyType == CIMTYPE_INSTANCE)         else if (propertyType == CIMTYPE_INSTANCE)
         {         {
   /*
             // If the property array type is CIMInstance, then             // If the property array type is CIMInstance, then
             //   encode the property in CIM-XML as a string array with the             //   encode the property in CIM-XML as a string array with the
             //   EmbeddedObject attribute (there is not currently a CIM-XML             //   EmbeddedObject attribute (there is not currently a CIM-XML
Line 356 
Line 361 
                 }                 }
 # endif # endif
             }             }
   */
         }         }
         else         else
         {         {
             out.append(' ');             out.append(' ');
             out << xmlWriterTypeStrings(rep->getValue().getType());              out << xmlWriterTypeStrings(propertyType);
         }         }
  
         if (rep->getArraySize())          Uint32 arraySize=propertyValue->valueArraySize;
   
           if (0 != arraySize)
         {         {
             char buffer[32];              out << STRLIT(" ARRAYSIZE=\"");
             sprintf(buffer, "%u", rep->getArraySize());              SCMOXmlWriter::append(out, arraySize);
             out << STRLIT(" ARRAYSIZE=\"") << buffer;  
             out.append('"');             out.append('"');
         }         }
  
         if (!rep->getClassOrigin().isNull())  
           if (scmoInstance.inst.hdr->flags.includeClassOrigin)
         {         {
             out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();              if (propertyDef->originClassName.start != 0)
               {
                   out << STRLIT(" CLASSORIGIN=\"");
                   out.append(
                       &(clsbase[propertyDef->originClassName.start]),
                       propertyDef->originClassName.length-1);
             out.append('"');             out.append('"');
         }         }
           }
         if (rep->getPropagated())          if (propertyDef->flags.propagated)
         {         {
             out << STRLIT(" PROPAGATED=\"true\"");             out << STRLIT(" PROPAGATED=\"true\"");
         }         }
  
         out << STRLIT(">\n");         out << STRLIT(">\n");
  
         for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)          // Append Instance Qualifiers:
             XmlWriter::appendQualifierElement(out, rep->getQualifier(i));          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(
                       out,
                       theArray[i],
                       clsbase);
               }
           }
  
         XmlWriter::appendValueElement(out, rep->getValue());          SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
  
         out << STRLIT("</PROPERTY.ARRAY>\n");         out << STRLIT("</PROPERTY.ARRAY>\n");
 */  
     }     }
     else if (propertyType == CIMTYPE_REFERENCE)     else if (propertyType == CIMTYPE_REFERENCE)
     {     {
Line 428 
Line 453 
     }     }
     else     else
     {     {
         // TODO: Optimize the property name using length as input  
         out << STRLIT("<PROPERTY NAME=\"");         out << STRLIT("<PROPERTY NAME=\"");
  
         out.append(         out.append(
Line 543 
Line 567 
                     clsbase);                     clsbase);
             }             }
         }         }
         SCMOXmlWriter::appendValueElement(          SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase);
             out,  
             *propertyValue,  
             propertyValueBase);  
   
         out << STRLIT("</PROPERTY>\n");         out << STRLIT("</PROPERTY>\n");
     }     }
 } }
Line 575 
Line 595 
     }     }
     if (value.flags.isArray)     if (value.flags.isArray)
     {     {
           appendSCMBUnionArray(
               out,
               value.value,
               value.valueType,
               value.valueArraySize,
               base);
       }
       else if (value.valueType == CIMTYPE_REFERENCE)
       {
 /* /*
         switch (value.getType())          // Has to be separate because it uses VALUE.REFERENCE tag
           CIMObjectPath v;
           value.get(v);
           _xmlWritter_appendValue(out, v);
   */
       }
       else
       {
           out << STRLIT("<VALUE>");
   
           // Call function to write a SCMBUnion + type field
           appendSCMBUnion(out,value.value, value.valueType,base);
   
           out << STRLIT("</VALUE>\n");
       }
   }
   
   void SCMOXmlWriter::appendSCMBUnion(
       Buffer& out,
       const SCMBUnion & u,
       const CIMType & valueType,
       const char * base)
   {
       switch (valueType)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
             {             {
                 Array<Boolean> a;              SCMOXmlWriter::append(out, u.simple.val.bin);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
             {             {
                 Array<Uint8> a;              SCMOXmlWriter::append(out, u.simple.val.u8);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
             {             {
                 Array<Sint8> a;              SCMOXmlWriter::append(out, u.simple.val.s8);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
             {             {
                 Array<Uint16> a;              SCMOXmlWriter::append(out, u.simple.val.u16);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
             {             {
                 Array<Sint16> a;              SCMOXmlWriter::append(out, u.simple.val.s16);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
             {             {
                 Array<Uint32> a;              SCMOXmlWriter::append(out, u.simple.val.u32);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
             {             {
                 Array<Sint32> a;              SCMOXmlWriter::append(out, u.simple.val.s32);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
             {             {
                 Array<Uint64> a;              SCMOXmlWriter::append(out, u.simple.val.u64);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
             {             {
                 Array<Sint64> a;              SCMOXmlWriter::append(out, u.simple.val.s64);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
             {             {
                 Array<Real32> a;              SCMOXmlWriter::append(out, u.simple.val.r32);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
             {             {
                 Array<Real64> a;              SCMOXmlWriter::append(out, u.simple.val.r64);
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
  
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
             {             {
                 Array<Char16> a;              SCMOXmlWriter::appendSpecial(
                 value.get(a);                  out,
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());                  u.simple.val.c16);
                 break;                 break;
             }             }
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
             {             {
                 const String* data;              SCMOXmlWriter::appendSpecial(
                 Uint32 size;                  out,
                 value._get(data, size);                  &(base[u.stringValue.start]),
                 _xmlWritter_appendValueArray(out, data, size);                  u.stringValue.length-1);
                 break;                 break;
             }             }
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
             {             {
                 Array<CIMDateTime> a;              // an SCMBDateTime is a CIMDateTimeRep
                 value.get(a);              // this should help us to reuse existing optimized Datetime
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());              char buffer[26];
                 break;              _DateTimetoCStr(&(u.dateTimeValue), buffer);
             }              // datetime value is formatted with a \0 at end, ignore
               out.append(buffer,sizeof(buffer)-1);
             case CIMTYPE_REFERENCE:  
             {  
                 Array<CIMObjectPath> a;  
                 value.get(a);  
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());  
                 break;                 break;
             }             }
   /*
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
             {             {
                 Array<CIMObject> a;              CIMObject v;
                 value.get(a);              value.get(v);
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());              _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
             case CIMTYPE_INSTANCE:             case CIMTYPE_INSTANCE:
             {             {
                 Array<CIMInstance> a;              CIMInstance v;
                 value.get(a);              value.get(v);
                 _xmlWritter_appendValueArray(out, a.getData(), a.size());              _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
             default:             default:
                 PEGASUS_ASSERT(false);                 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>");  
  
         // Call function to write a SCMBUnion + type field  void SCMOXmlWriter::appendSCMBUnionArray(
         appendSCMBUnion(out,value.value, value.valueType,base);  
   
         out << STRLIT("</VALUE>\n");  
     }  
 }  
   
 void SCMOXmlWriter::appendSCMBUnion(  
     Buffer& out,     Buffer& out,
     const SCMBUnion & u,     const SCMBUnion & u,
     const CIMType & valueType,     const CIMType & valueType,
       Uint32 numElements,
     const char * base)     const char * base)
 { {
       SCMBUnion* arr = (SCMBUnion*) &(base[u.arrayValue.start]);
     switch (valueType)     switch (valueType)
     {     {
         case CIMTYPE_BOOLEAN:         case CIMTYPE_BOOLEAN:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.bin);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.bin);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
   
         case CIMTYPE_UINT8:         case CIMTYPE_UINT8:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.u8);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.u8);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_SINT8:         case CIMTYPE_SINT8:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.s8);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.s8);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_UINT16:         case CIMTYPE_UINT16:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.u16);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.u16);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_SINT16:         case CIMTYPE_SINT16:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.s16);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.s16);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_UINT32:         case CIMTYPE_UINT32:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.u32);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.u32);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_SINT32:         case CIMTYPE_SINT32:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.s32);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.s32);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_UINT64:         case CIMTYPE_UINT64:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.u64);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.u64);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_SINT64:         case CIMTYPE_SINT64:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.s64);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.s64);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_REAL32:         case CIMTYPE_REAL32:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.r32);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.r32);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_REAL64:         case CIMTYPE_REAL64:
         {         {
             SCMOXmlWriter::append(out, u.simple.val.r64);              out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.r64);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_CHAR16:         case CIMTYPE_CHAR16:
         {         {
             SCMOXmlWriter::appendSpecial(              out << STRLIT("<VALUE.ARRAY>\n");
                 out,              while (numElements--)
                 u.simple.val.c16);              {
                   out << STRLIT("<VALUE>");
                   SCMOXmlWriter::append(out, arr->simple.val.bin);
                   SCMOXmlWriter::appendSpecial(out, arr->simple.val.c16);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
  
         case CIMTYPE_STRING:         case CIMTYPE_STRING:
         {         {
               out << STRLIT("<VALUE.ARRAY>\n");
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
             SCMOXmlWriter::appendSpecial(             SCMOXmlWriter::appendSpecial(
                 out,                 out,
                 &(base[u.stringValue.start]),                      &(base[arr->stringValue.start]),
                 u.stringValue.length-1);                      arr->stringValue.length-1);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
   
             break;             break;
         }         }
  
         case CIMTYPE_DATETIME:         case CIMTYPE_DATETIME:
         {         {
               out << STRLIT("<VALUE.ARRAY>\n");
               char buffer[26];
               while (numElements--)
               {
                   out << STRLIT("<VALUE>");
             // an SCMBDateTime is a CIMDateTimeRep             // an SCMBDateTime is a CIMDateTimeRep
             // this should help us to reuse existing optimized Datetime             // this should help us to reuse existing optimized Datetime
             char buffer[26];                  _DateTimetoCStr(&(arr->dateTimeValue), buffer);
             _DateTimetoCStr(&(u.dateTimeValue), buffer);  
             // datetime value is formatted with a \0 at end, ignore             // datetime value is formatted with a \0 at end, ignore
             out.append(buffer,sizeof(buffer)-1);             out.append(buffer,sizeof(buffer)-1);
                   arr++;
                   out << STRLIT("</VALUE>\n");
               }
               out << STRLIT("</VALUE.ARRAY>\n");
             break;             break;
         }         }
 /* /*
Line 858 
Line 977 
             PEGASUS_ASSERT(false);             PEGASUS_ASSERT(false);
 */ */
     }     }
   
 } }
  
  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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