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

Diff for /pegasus/src/Pegasus/Common/XmlReader.cpp between version 1.53 and 1.62

version 1.53, 2002/05/13 18:35:53 version 1.62, 2002/07/30 16:14:53
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
 // The Open Group, Tivoli Systems // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
Line 30 
Line 30 
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <cassert>  
 #include <cctype> #include <cctype>
 #include <cstdio> #include <cstdio>
 #include <cstdlib> #include <cstdlib>
Line 45 
Line 44 
 #include "CIMClass.h" #include "CIMClass.h"
 #include "CIMInstance.h" #include "CIMInstance.h"
 #include "CIMObject.h" #include "CIMObject.h"
 #include "CIMNamedInstance.h"  
 #include "CIMParamValue.h" #include "CIMParamValue.h"
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
Line 385 
Line 383 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 String XmlReader::getClassOriginAttribute(  CIMName XmlReader::getClassOriginAttribute(
     Uint32 lineNumber,     Uint32 lineNumber,
     const XmlEntry& entry,     const XmlEntry& entry,
     const char* tagName)     const char* tagName)
Line 393 
Line 391 
     String name;     String name;
  
     if (!entry.getAttributeValue("CLASSORIGIN", name))     if (!entry.getAttributeValue("CLASSORIGIN", name))
         return String();          return CIMName();
  
     if (!CIMName::legal(name))     if (!CIMName::legal(name))
     {     {
Line 414 
Line 412 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 String XmlReader::getReferenceClassAttribute(  CIMName XmlReader::getReferenceClassAttribute(
     Uint32 lineNumber,     Uint32 lineNumber,
     const XmlEntry& entry,     const XmlEntry& entry,
     const char* elementName)     const char* elementName)
Line 422 
Line 420 
     String name;     String name;
  
     if (!entry.getAttributeValue("REFERENCECLASS", name))     if (!entry.getAttributeValue("REFERENCECLASS", name))
         return String();          return CIMName();
  
     if (!CIMName::legal(name))     if (!CIMName::legal(name))
     {     {
Line 443 
Line 441 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 String XmlReader::getSuperClassAttribute(  CIMName XmlReader::getSuperClassAttribute(
     Uint32 lineNumber,     Uint32 lineNumber,
     const XmlEntry& entry,     const XmlEntry& entry,
     const char* tagName)     const char* tagName)
Line 451 
Line 449 
     String superClass;     String superClass;
  
     if (!entry.getAttributeValue("SUPERCLASS", superClass))     if (!entry.getAttributeValue("SUPERCLASS", superClass))
         return String();          return CIMName();
  
     if (!CIMName::legal(superClass))     if (!CIMName::legal(superClass))
     {     {
Line 501 
Line 499 
         }         }
         else         else
         {         {
             return CIMType::NONE;              return CIMTYPE_NONE;
         }         }
     }     }
  
     CIMType type = CIMType::NONE;      CIMType type = CIMTYPE_NONE;
  
     if (strcmp(typeName, "boolean") == 0)     if (strcmp(typeName, "boolean") == 0)
         type = CIMType::BOOLEAN;          type = CIMTYPE_BOOLEAN;
     else if (strcmp(typeName, "string") == 0)     else if (strcmp(typeName, "string") == 0)
         type = CIMType::STRING;          type = CIMTYPE_STRING;
     else if (strcmp(typeName, "char16") == 0)     else if (strcmp(typeName, "char16") == 0)
         type = CIMType::CHAR16;          type = CIMTYPE_CHAR16;
     else if (strcmp(typeName, "uint8") == 0)     else if (strcmp(typeName, "uint8") == 0)
         type = CIMType::UINT8;          type = CIMTYPE_UINT8;
     else if (strcmp(typeName, "sint8") == 0)     else if (strcmp(typeName, "sint8") == 0)
         type = CIMType::SINT8;          type = CIMTYPE_SINT8;
     else if (strcmp(typeName, "uint16") == 0)     else if (strcmp(typeName, "uint16") == 0)
         type = CIMType::UINT16;          type = CIMTYPE_UINT16;
     else if (strcmp(typeName, "sint16") == 0)     else if (strcmp(typeName, "sint16") == 0)
         type = CIMType::SINT16;          type = CIMTYPE_SINT16;
     else if (strcmp(typeName, "uint32") == 0)     else if (strcmp(typeName, "uint32") == 0)
         type = CIMType::UINT32;          type = CIMTYPE_UINT32;
     else if (strcmp(typeName, "sint32") == 0)     else if (strcmp(typeName, "sint32") == 0)
         type = CIMType::SINT32;          type = CIMTYPE_SINT32;
     else if (strcmp(typeName, "uint64") == 0)     else if (strcmp(typeName, "uint64") == 0)
         type = CIMType::UINT64;          type = CIMTYPE_UINT64;
     else if (strcmp(typeName, "sint64") == 0)     else if (strcmp(typeName, "sint64") == 0)
         type = CIMType::SINT64;          type = CIMTYPE_SINT64;
     else if (strcmp(typeName, "datetime") == 0)     else if (strcmp(typeName, "datetime") == 0)
         type = CIMType::DATETIME;          type = CIMTYPE_DATETIME;
     else if (strcmp(typeName, "real32") == 0)     else if (strcmp(typeName, "real32") == 0)
         type = CIMType::REAL32;          type = CIMTYPE_REAL32;
     else if (strcmp(typeName, "real64") == 0)     else if (strcmp(typeName, "real64") == 0)
         type = CIMType::REAL64;          type = CIMTYPE_REAL64;
     else if (strcmp(typeName, "reference") == 0)     else if (strcmp(typeName, "reference") == 0)
         type = CIMType::REFERENCE;          type = CIMTYPE_REFERENCE;
  
     if ((type == CIMType::NONE) ||      if ((type == CIMTYPE_NONE) ||
         ((type == CIMType::REFERENCE) &&          ((type == CIMTYPE_REFERENCE) &&
          (strcmp(attributeName, "PARAMTYPE") != 0)))          (strcmp(attributeName, "PARAMTYPE") != 0)))
     {     {
         char message[MESSAGE_SIZE];         char message[MESSAGE_SIZE];
Line 932 
Line 930 
     // Create value per type     // Create value per type
     switch (type)     switch (type)
     {     {
         case CIMType::BOOLEAN:          case CIMTYPE_BOOLEAN:
         {         {
             if (CompareNoCase(valueString, "TRUE") == 0)             if (CompareNoCase(valueString, "TRUE") == 0)
                 return CIMValue(true);                 return CIMValue(true);
Line 943 
Line 941 
                     lineNumber, "Bad boolean value");                     lineNumber, "Bad boolean value");
         }         }
  
         case CIMType::STRING:          case CIMTYPE_STRING:
         {         {
             return CIMValue(valueString);              return CIMValue(String(valueString));
         }         }
  
         case CIMType::CHAR16:          case CIMTYPE_CHAR16:
         {         {
             if (strlen(valueString) != 1)             if (strlen(valueString) != 1)
                 throw XmlSemanticError(lineNumber, "Bad char16 value");                 throw XmlSemanticError(lineNumber, "Bad char16 value");
Line 956 
Line 954 
             return CIMValue(Char16(valueString[0]));             return CIMValue(Char16(valueString[0]));
         }         }
  
         case CIMType::UINT8:          case CIMTYPE_UINT8:
         case CIMType::UINT16:          case CIMTYPE_UINT16:
         case CIMType::UINT32:          case CIMTYPE_UINT32:
         case CIMType::UINT64:          case CIMTYPE_UINT64:
         {         {
             Uint64 x;             Uint64 x;
  
Line 971 
Line 969 
  
             switch (type)             switch (type)
             {             {
                 case CIMType::UINT8:                  case CIMTYPE_UINT8:
                 {                 {
                     if (x >= (Uint64(1)<<8))                     if (x >= (Uint64(1)<<8))
                     {                     {
Line 980 
Line 978 
                     }                     }
                     return CIMValue(Uint8(x));                     return CIMValue(Uint8(x));
                 }                 }
                 case CIMType::UINT16:                  case CIMTYPE_UINT16:
                 {                 {
                     if (x >= (Uint64(1)<<16))                     if (x >= (Uint64(1)<<16))
                     {                     {
Line 989 
Line 987 
                     }                     }
                     return CIMValue(Uint16(x));                     return CIMValue(Uint16(x));
                 }                 }
                 case CIMType::UINT32:                  case CIMTYPE_UINT32:
                 {                 {
                     if (x >= (Uint64(1)<<32))                     if (x >= (Uint64(1)<<32))
                     {                     {
Line 998 
Line 996 
                     }                     }
                     return CIMValue(Uint32(x));                     return CIMValue(Uint32(x));
                 }                 }
                 case CIMType::UINT64: return CIMValue(Uint64(x));                  case CIMTYPE_UINT64: return CIMValue(Uint64(x));
                 default: break;                 default: break;
             }             }
         }         }
  
         case CIMType::SINT8:          case CIMTYPE_SINT8:
         case CIMType::SINT16:          case CIMTYPE_SINT16:
         case CIMType::SINT32:          case CIMTYPE_SINT32:
         case CIMType::SINT64:          case CIMTYPE_SINT64:
         {         {
             Sint64 x;             Sint64 x;
  
Line 1018 
Line 1016 
  
             switch (type)             switch (type)
             {             {
                 case CIMType::SINT8:                  case CIMTYPE_SINT8:
                 {                 {
                     if(  (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )                     if(  (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )
                     {                     {
Line 1027 
Line 1025 
                     }                     }
                     return CIMValue(Sint8(x));                     return CIMValue(Sint8(x));
                 }                 }
                 case CIMType::SINT16:                  case CIMTYPE_SINT16:
                 {                 {
                     if(  (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )                     if(  (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )
                     {                     {
Line 1036 
Line 1034 
                     }                     }
                     return CIMValue(Sint16(x));                     return CIMValue(Sint16(x));
                 }                 }
                 case CIMType::SINT32:                  case CIMTYPE_SINT32:
                 {                 {
                     if(  (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )                     if(  (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )
                     {                     {
Line 1045 
Line 1043 
                     }                     }
                     return CIMValue(Sint32(x));                     return CIMValue(Sint32(x));
                 }                 }
                 case CIMType::SINT64: return CIMValue(Sint64(x));                  case CIMTYPE_SINT64: return CIMValue(Sint64(x));
                 default: break;                 default: break;
             }             }
         }         }
  
         case CIMType::DATETIME:          case CIMTYPE_DATETIME:
         {         {
             CIMDateTime tmp;             CIMDateTime tmp;
  
Line 1066 
Line 1064 
             return CIMValue(tmp);             return CIMValue(tmp);
         }         }
  
         case CIMType::REAL32:          case CIMTYPE_REAL32:
         {         {
             Real64 x;             Real64 x;
  
Line 1076 
Line 1074 
             return CIMValue(Real32(x));             return CIMValue(Real32(x));
         }         }
  
         case CIMType::REAL64:          case CIMTYPE_REAL64:
         {         {
             Real64 x;             Real64 x;
  
Line 1195 
Line 1193 
     CIMValue& cimValue)     CIMValue& cimValue)
 { {
     // Can not test for value type, so assume String     // Can not test for value type, so assume String
     const CIMType type = CIMType::STRING;      const CIMType type = CIMTYPE_STRING;
  
     // Test for VALUE element     // Test for VALUE element
     if (XmlReader::getValueElement(parser, type, cimValue))     if (XmlReader::getValueElement(parser, type, cimValue))
Line 1210 
Line 1208 
     }     }
  
     // Test for VALUE.REFERENCE element     // Test for VALUE.REFERENCE element
     CIMReference reference;      CIMObjectPath reference;
     if (XmlReader::getValueReferenceElement(parser, reference))     if (XmlReader::getValueReferenceElement(parser, reference))
     {     {
         cimValue.set(reference);         cimValue.set(reference);
Line 1261 
Line 1259 
 { {
     switch (type)     switch (type)
     {     {
         case CIMType::BOOLEAN:          case CIMTYPE_BOOLEAN:
             return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);             return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);
  
         case CIMType::STRING:          case CIMTYPE_STRING:
             return StringArrayToValueAux(lineNumber, array, type, (String*)0);             return StringArrayToValueAux(lineNumber, array, type, (String*)0);
  
         case CIMType::CHAR16:          case CIMTYPE_CHAR16:
             return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);             return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);
  
         case CIMType::UINT8:          case CIMTYPE_UINT8:
             return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);             return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);
  
         case CIMType::UINT16:          case CIMTYPE_UINT16:
             return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);             return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);
  
         case CIMType::UINT32:          case CIMTYPE_UINT32:
             return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);             return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);
  
         case CIMType::UINT64:          case CIMTYPE_UINT64:
             return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);             return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);
  
         case CIMType::SINT8:          case CIMTYPE_SINT8:
             return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);             return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);
  
         case CIMType::SINT16:          case CIMTYPE_SINT16:
             return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);             return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);
  
         case CIMType::SINT32:          case CIMTYPE_SINT32:
             return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);             return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);
  
         case CIMType::SINT64:          case CIMTYPE_SINT64:
             return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);             return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);
  
         case CIMType::DATETIME:          case CIMTYPE_DATETIME:
             return StringArrayToValueAux(lineNumber, array, type, (CIMDateTime*)0);             return StringArrayToValueAux(lineNumber, array, type, (CIMDateTime*)0);
  
         case CIMType::REAL32:          case CIMTYPE_REAL32:
             return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);             return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);
  
         case CIMType::REAL64:          case CIMTYPE_REAL64:
             return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);             return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);
  
         default:         default:
Line 1603 
Line 1601 
  
     // Get PROPERTY.CLASSORIGIN attribute:     // Get PROPERTY.CLASSORIGIN attribute:
  
     String classOrigin =      CIMName classOrigin =
         getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");         getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
  
     // Get PROPERTY.PROPAGATED     // Get PROPERTY.PROPAGATED
Line 1616 
Line 1614 
     CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");     CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");
  
     // Create property: Sets type and !isarray     // Create property: Sets type and !isarray
     // ATTN: KS P1 change to use the correct constructor  
  
     CIMValue value;      CIMValue value(type, false);
     value.setNullValue(type, false);      property = CIMProperty(name, value, 0, CIMName(), classOrigin, propagated);
     property = CIMProperty(  
         name, value, 0, String(), classOrigin, propagated);  
  
     if (!empty)     if (!empty)
     {     {
Line 1718 
Line 1713 
  
     // Get PROPERTY.CLASSORIGIN attribute:     // Get PROPERTY.CLASSORIGIN attribute:
  
     String classOrigin      CIMName classOrigin
         = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");         = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
  
     // Get PROPERTY.ARRAY.PROPAGATED     // Get PROPERTY.ARRAY.PROPAGATED
Line 1728 
Line 1723 
  
     // Create property:     // Create property:
  
     // ATTN: KS P1 4 March 2002 Change to use correct constructor.      CIMValue value(type, true, arraySize);
     // ATTN: KS P3 4 March 2002.  Why create extra value. Use same one.  
   
     CIMValue nullValue;  
     nullValue.setNullValue(type, true, arraySize);  
     property = CIMProperty(     property = CIMProperty(
         name, nullValue, arraySize, String(), classOrigin, propagated);          name, value, arraySize, CIMName(), classOrigin, propagated);
  
     if (!empty)     if (!empty)
     {     {
Line 1744 
Line 1735 
  
         // Get value:         // Get value:
  
         // ATTN: KS P1 4 March 2002. Does not set array type into value.  
         // ATTN: Thus, if it returns false, the CIMValue is nothing.  
         CIMValue value;  
   
         if (getValueArrayElement(parser, type, value))         if (getValueArrayElement(parser, type, value))
         {         {
             if (arraySize && arraySize != value.getArraySize())             if (arraySize && arraySize != value.getArraySize())
Line 2037 
Line 2024 
  
     if (!getKeyValueElement(parser, type, value))     if (!getKeyValueElement(parser, type, value))
     {     {
         CIMReference reference;          CIMObjectPath reference;
  
         if (!getValueReferenceElement(parser, reference))         if (!getValueReferenceElement(parser, reference))
         {         {
Line 2091 
Line 2078 
     String name;     String name;
     KeyBinding::Type type;     KeyBinding::Type type;
     String value;     String value;
     CIMReference reference;      CIMObjectPath reference;
  
     if (getKeyValueElement(parser, type, value))     if (getKeyValueElement(parser, type, value))
     {     {
Line 2118 
Line 2105 
  
 Boolean XmlReader::getInstanceNameElement( Boolean XmlReader::getInstanceNameElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& instanceName)      CIMObjectPath& instanceName)
 { {
     String className;     String className;
     Array<KeyBinding> keyBindings;     Array<KeyBinding> keyBindings;
Line 2126 
Line 2113 
     if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))     if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
         return false;         return false;
  
     instanceName.set(String(), String(), className, keyBindings);      instanceName.set(String(), CIMNamespaceName(), className, keyBindings);
     return true;     return true;
 } }
  
Line 2140 
Line 2127 
  
 Boolean XmlReader::getInstancePathElement( Boolean XmlReader::getInstancePathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2181 
Line 2168 
  
 Boolean XmlReader::getLocalInstancePathElement( Boolean XmlReader::getLocalInstancePathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2221 
Line 2208 
  
 Boolean XmlReader::getClassPathElement( Boolean XmlReader::getClassPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2261 
Line 2248 
  
 Boolean XmlReader::getLocalClassPathElement( Boolean XmlReader::getLocalClassPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2303 
Line 2290 
  
 Boolean XmlReader::getValueReferenceElement( Boolean XmlReader::getValueReferenceElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2337 
Line 2324 
         parser.putBack(entry);         parser.putBack(entry);
         String className;         String className;
         getClassNameElement(parser, className);         getClassNameElement(parser, className);
         reference.set(String(), String(), className);          reference.set(String(), CIMNamespaceName(), className);
     }     }
     else if (strcmp(entry.text, "INSTANCEPATH") == 0)     else if (strcmp(entry.text, "INSTANCEPATH") == 0)
     {     {
Line 2355 
Line 2342 
         String className;         String className;
         Array<KeyBinding> keyBindings;         Array<KeyBinding> keyBindings;
         getInstanceNameElement(parser, className, keyBindings);         getInstanceNameElement(parser, className, keyBindings);
         reference.set(String(), String(), className, keyBindings);          reference.set(String(), CIMNamespaceName(), className, keyBindings);
     }     }
  
     expectEndTag(parser, "VALUE.REFERENCE");     expectEndTag(parser, "VALUE.REFERENCE");
Line 2375 
Line 2362 
     CIMValue& value)     CIMValue& value)
 { {
     XmlEntry entry;     XmlEntry entry;
     Array<CIMReference> referenceArray;      Array<CIMObjectPath> referenceArray;
     CIMReference reference;      CIMObjectPath reference;
  
     value.clear();     value.clear();
  
Line 2432 
Line 2419 
  
     // Get PROPERTY.REFERENCECLASS attribute:     // Get PROPERTY.REFERENCECLASS attribute:
  
     String referenceClass = getReferenceClassAttribute(      CIMName referenceClass = getReferenceClassAttribute(
         parser.getLine(), entry, "PROPERTY.REFERENCE");         parser.getLine(), entry, "PROPERTY.REFERENCE");
  
     // Get PROPERTY.CLASSORIGIN attribute:     // Get PROPERTY.CLASSORIGIN attribute:
  
     String classOrigin =      CIMName classOrigin =
         getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");         getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");
  
     // Get PROPERTY.PROPAGATED     // Get PROPERTY.PROPAGATED
Line 2447 
Line 2434 
  
     // Create property:     // Create property:
  
     CIMValue value = CIMValue(CIMType::REFERENCE, false, 0);      CIMValue value = CIMValue(CIMTYPE_REFERENCE, false, 0);
 //    value.set(CIMReference());  //    value.set(CIMObjectPath());
     property = CIMProperty(     property = CIMProperty(
         name, value, 0, referenceClass, classOrigin, propagated);         name, value, 0, referenceClass, classOrigin, propagated);
  
Line 2456 
Line 2443 
     {     {
         getQualifierElements(parser, property);         getQualifierElements(parser, property);
  
         CIMReference reference;          CIMObjectPath reference;
  
         if (getValueReferenceElement(parser, reference))         if (getValueReferenceElement(parser, reference))
             property.setValue(reference);             property.setValue(reference);
Line 2617 
Line 2604 
  
     // Get PARAMETER.REFERENCECLASS attribute:     // Get PARAMETER.REFERENCECLASS attribute:
  
     String referenceClass = getReferenceClassAttribute(      CIMName referenceClass = getReferenceClassAttribute(
         parser.getLine(), entry, "PARAMETER.REFERENCE");         parser.getLine(), entry, "PARAMETER.REFERENCE");
  
     // Create parameter:     // Create parameter:
  
     parameter = CIMParameter(name, CIMType::REFERENCE, false, 0, referenceClass);      parameter = CIMParameter(name, CIMTYPE_REFERENCE, false, 0, referenceClass);
  
     if (!empty)     if (!empty)
     {     {
Line 2663 
Line 2650 
  
     // Get PARAMETER.REFERENCECLASS attribute:     // Get PARAMETER.REFERENCECLASS attribute:
  
     String referenceClass = getReferenceClassAttribute(      CIMName referenceClass = getReferenceClassAttribute(
         parser.getLine(), entry, "PARAMETER.REFARRAY");         parser.getLine(), entry, "PARAMETER.REFARRAY");
  
     // Get PARAMETER.ARRAYSIZE attribute:     // Get PARAMETER.ARRAYSIZE attribute:
Line 2674 
Line 2661 
  
     // Create parameter:     // Create parameter:
  
     parameter = CIMParameter(name, CIMType::REFERENCE, true, arraySize,      parameter = CIMParameter(name, CIMTYPE_REFERENCE, true, arraySize,
                              referenceClass);                              referenceClass);
  
     if (!empty)     if (!empty)
Line 2807 
Line 2794 
         expectEndTag(parser, "QUALIFIER.DECLARATION");         expectEndTag(parser, "QUALIFIER.DECLARATION");
     }     }
  
     if (value.getType() == CIMType::NONE)      if (value.getType() == CIMTYPE_NONE)
     {     {
         if (isArray)         if (isArray)
             value.setNullValue(type, true, arraySize);             value.setNullValue(type, true, arraySize);
Line 2846 
Line 2833 
  
     CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");     CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");
  
     String classOrigin =      CIMName classOrigin =
         getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");         getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");
  
     Boolean propagated = getCimBooleanAttribute(     Boolean propagated = getCimBooleanAttribute(
Line 2886 
Line 2873 
  
     String name = getCimNameAttribute(parser.getLine(), entry, "CLASS");     String name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
  
     String superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");      CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");
  
     cimClass = CIMClass(name, superClass);     cimClass = CIMClass(name, superClass);
  
Line 2960 
Line 2947 
  
 Boolean XmlReader::getNamedInstanceElement( Boolean XmlReader::getNamedInstanceElement(
     XmlParser& parser,     XmlParser& parser,
     CIMNamedInstance& namedInstance)      CIMInstance& namedInstance)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))     if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))
         return false;         return false;
  
     CIMReference instanceName;      CIMObjectPath instanceName;
  
     // Get INSTANCENAME elements:     // Get INSTANCENAME elements:
  
Line 2977 
Line 2964 
             "expected INSTANCENAME element");             "expected INSTANCENAME element");
     }     }
  
     CIMInstance instance;  
   
     // Get INSTANCE elements:     // Get INSTANCE elements:
  
     if (!getInstanceElement(parser, instance))      if (!getInstanceElement(parser, namedInstance))
     {     {
         throw XmlValidationError(parser.getLine(),         throw XmlValidationError(parser.getLine(),
             "expected INSTANCE element");             "expected INSTANCE element");
Line 2991 
Line 2976 
  
     expectEndTag(parser, "VALUE.NAMEDINSTANCE");     expectEndTag(parser, "VALUE.NAMEDINSTANCE");
  
     namedInstance.set(instanceName, instance);      namedInstance.setPath (instanceName);
  
     return true;     return true;
 } }
Line 3280 
Line 3265 
  
 Boolean XmlReader::getValueObjectWithPathElement( Boolean XmlReader::getValueObjectWithPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMObjectWithPath& objectWithPath)      CIMObject& objectWithPath)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))     if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))
         return false;         return false;
  
     CIMReference reference;      CIMObjectPath reference;
     Boolean isInstance = false;     Boolean isInstance = false;
  
     if (XmlReader::getInstancePathElement(parser, reference))     if (XmlReader::getInstancePathElement(parser, reference))
Line 3307 
Line 3292 
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected INSTANCE element");                 "Expected INSTANCE element");
         }         }
         objectWithPath.set(reference, CIMObject(cimInstance));          objectWithPath = CIMObject (cimInstance);
           objectWithPath.setPath (reference);
     }     }
     else     else
     {     {
Line 3318 
Line 3304 
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected CLASS element");                 "Expected CLASS element");
         }         }
         objectWithPath.set(reference, CIMObject(cimClass));          objectWithPath = CIMObject (cimClass);
           objectWithPath.setPath (reference);
     }     }
  
     expectEndTag(parser, "VALUE.OBJECTWITHPATH");     expectEndTag(parser, "VALUE.OBJECTWITHPATH");
Line 3336 
Line 3323 
  
 Boolean XmlReader::getValueObjectWithLocalPathElement( Boolean XmlReader::getValueObjectWithLocalPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMObjectWithPath& objectWithPath)      CIMObject& objectWithPath)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))     if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))
         return false;         return false;
  
     CIMReference reference;      CIMObjectPath reference;
     Boolean isInstance = false;     Boolean isInstance = false;
  
     if (XmlReader::getLocalInstancePathElement(parser, reference))     if (XmlReader::getLocalInstancePathElement(parser, reference))
Line 3363 
Line 3350 
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected INSTANCE element");                 "Expected INSTANCE element");
         }         }
         objectWithPath.set(reference, CIMObject(cimInstance));          objectWithPath = CIMObject (cimInstance);
           objectWithPath.setPath (reference);
     }     }
     else     else
     {     {
Line 3374 
Line 3362 
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected CLASS element");                 "Expected CLASS element");
         }         }
         objectWithPath.set(reference, CIMObject(cimClass));          objectWithPath = CIMObject (cimClass);
           objectWithPath.setPath (reference);
     }     }
  
     expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");     expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");
Line 3392 
Line 3381 
  
 void XmlReader::getObjectArray( void XmlReader::getObjectArray(
     XmlParser& parser,     XmlParser& parser,
     Array<CIMObjectWithPath>& objectArray)      Array<CIMObject>& objectArray)
 { {
     CIMObject object;     CIMObject object;
     CIMObjectWithPath objectWithPath;      CIMObject objectWithPath;
  
     objectArray.clear();     objectArray.clear();
  
     if (getValueObjectElement(parser, object))     if (getValueObjectElement(parser, object))
     {     {
         objectArray.append(CIMObjectWithPath(CIMReference(), object));          objectArray.append(object);
         while (getValueObjectElement(parser, object))         while (getValueObjectElement(parser, object))
             objectArray.append(CIMObjectWithPath(CIMReference(), object));              objectArray.append(object);
     }     }
     else if (getValueObjectWithPathElement(parser, objectWithPath))     else if (getValueObjectWithPathElement(parser, objectWithPath))
     {     {
Line 3427 
Line 3416 
  
 Boolean XmlReader::getObjectNameElement( Boolean XmlReader::getObjectNameElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& objectName)      CIMObjectPath& objectName)
 { {
     String className;     String className;
  
     if (getClassNameElement(parser, className, false))     if (getClassNameElement(parser, className, false))
     {     {
         objectName.set(String(), String(), className);          objectName.set(String(), CIMNamespaceName(), className);
         return true;         return true;
     }     }
     else if (getInstanceNameElement(parser, objectName))     else if (getInstanceNameElement(parser, objectName))
Line 3455 
Line 3444 
  
 Boolean XmlReader::getObjectPathElement( Boolean XmlReader::getObjectPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& objectPath)      CIMObjectPath& objectPath)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 3616 
Line 3605 
     if (!empty)     if (!empty)
     {     {
         // Parse VALUE.REFERENCE and VALUE.REFARRAY type         // Parse VALUE.REFERENCE and VALUE.REFARRAY type
         if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )          if ( (type == CIMTYPE_REFERENCE) || (type == CIMTYPE_NONE) )
         {         {
             CIMReference reference;              CIMObjectPath reference;
             if (XmlReader::getValueReferenceElement(parser, reference))             if (XmlReader::getValueReferenceElement(parser, reference))
             {             {
                 value.set(reference);                 value.set(reference);
                 type = CIMType::REFERENCE;                  type = CIMTYPE_REFERENCE;
             }             }
             else if (XmlReader::getValueReferenceArrayElement(parser, value))             else if (XmlReader::getValueReferenceArrayElement(parser, value))
             {             {
                 type = CIMType::REFERENCE;                  type = CIMTYPE_REFERENCE;
             }             }
             // If type==reference but no VALUE.REFERENCE found, use null value             // If type==reference but no VALUE.REFERENCE found, use null value
         }         }
  
         // Parse non-reference value         // Parse non-reference value
         if ( type != CIMType::REFERENCE )          if ( type != CIMTYPE_REFERENCE )
         {         {
             // If we don't know what type the value is, read it as a String             // If we don't know what type the value is, read it as a String
             CIMType effectiveType = type;             CIMType effectiveType = type;
             if ( effectiveType == CIMType::NONE)              if ( effectiveType == CIMTYPE_NONE)
             {             {
                 effectiveType = CIMType::STRING;                  effectiveType = CIMTYPE_STRING;
             }             }
  
             if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&             if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&
Line 3651 
Line 3640 
         expectEndTag(parser, "PARAMVALUE");         expectEndTag(parser, "PARAMVALUE");
     }     }
  
     paramValue = CIMParamValue(name, value, Boolean(type!=CIMType::NONE));      paramValue = CIMParamValue(name, value, Boolean(type!=CIMTYPE_NONE));
  
     return true;     return true;
 } }
Line 3684 
Line 3673 
                                "PARAMTYPE", false);                                "PARAMTYPE", false);
  
     // Parse VALUE.REFERENCE type     // Parse VALUE.REFERENCE type
     if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )      if ( (type == CIMTYPE_REFERENCE) || (type == CIMTYPE_NONE) )
     {     {
         CIMReference reference;          CIMObjectPath reference;
         if (XmlReader::getValueReferenceElement(parser, reference))         if (XmlReader::getValueReferenceElement(parser, reference))
         {         {
             returnValue.set(reference);             returnValue.set(reference);
             type = CIMType::REFERENCE;              type = CIMTYPE_REFERENCE;
         }         }
         else if (type == CIMType::REFERENCE)          else if (type == CIMTYPE_REFERENCE)
         {         {
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "expected VALUE.REFERENCE element");                 "expected VALUE.REFERENCE element");
Line 3700 
Line 3689 
     }     }
  
     // Parse non-reference return value     // Parse non-reference return value
     if ( type != CIMType::REFERENCE )      if ( type != CIMTYPE_REFERENCE )
     {     {
         // If we don't know what type the value is, read it as a String         // If we don't know what type the value is, read it as a String
         if ( type == CIMType::NONE)          if ( type == CIMTYPE_NONE)
         {         {
             type = CIMType::STRING;              type = CIMTYPE_STRING;
         }         }
  
         if ( !XmlReader::getValueElement(parser, type, returnValue) )         if ( !XmlReader::getValueElement(parser, type, returnValue) )

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