(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.24.2.7 and 1.59

version 1.24.2.7, 2001/11/08 23:15:30 version 1.59, 2002/06/10 20:33:50
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 25 
Line 25 
 // //
 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
 //              (carolann_graves@hp.com) //              (carolann_graves@hp.com)
 //  
 //              Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) //              Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
   //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
   #include <Pegasus/Common/Config.h>
 #include <cassert>  
 #include <cctype> #include <cctype>
 #include <cstdio> #include <cstdio>
 #include <cstdlib> #include <cstdlib>
   #if defined(PEGASUS_OS_TYPE_UNIX)
   #include <errno.h>
   #endif
 #include "CIMName.h" #include "CIMName.h"
 #include "XmlReader.h" #include "XmlReader.h"
 #include "XmlWriter.h" #include "XmlWriter.h"
Line 51 
Line 53 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // expectXmlDeclaration()  // getXmlDeclaration()
   //
   //     <?xml version="1.0" encoding="utf-8"?>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlReader::expectXmlDeclaration(  void XmlReader::getXmlDeclaration(
     XmlParser& parser,     XmlParser& parser,
     XmlEntry& entry)      const char*& xmlVersion,
       const char*& xmlEncoding)
 { {
       XmlEntry entry;
   
     if (!parser.next(entry) ||     if (!parser.next(entry) ||
         entry.type != XmlEntry::XML_DECLARATION ||         entry.type != XmlEntry::XML_DECLARATION ||
         strcmp(entry.text, "xml") != 0)         strcmp(entry.text, "xml") != 0)
Line 66 
Line 73 
         throw XmlValidationError(parser.getLine(),         throw XmlValidationError(parser.getLine(),
             "Expected <?xml ... ?> style declaration");             "Expected <?xml ... ?> style declaration");
     }     }
   
       if (!entry.getAttributeValue("version", xmlVersion))
           throw XmlValidationError(
               parser.getLine(), "missing xml.version attribute");
   
       if (!entry.getAttributeValue("encoding", xmlEncoding))
       {
           // ATTN-RK-P3-20020403:  Is there a default encoding?
       }
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 199 
Line 215 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // testEndTag>()  // testEndTag()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
Line 264 
Line 280 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // testCimStartTag()  // getCimStartTag()
 // //
 //     <!ELEMENT CIM (MESSAGE|DECLARATION)> //     <!ELEMENT CIM (MESSAGE|DECLARATION)>
 //     <!ATTRLIST CIM //     <!ATTRLIST CIM
Line 273 
Line 289 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlReader::testCimStartTag(XmlParser& parser)  void XmlReader::getCimStartTag(
       XmlParser& parser,
       const char*& cimVersion,
       const char*& dtdVersion)
 { {
     XmlEntry entry;     XmlEntry entry;
     XmlReader::expectStartTag(parser, entry, "CIM");     XmlReader::expectStartTag(parser, entry, "CIM");
  
     const char* cimVersion;  
   
     if (!entry.getAttributeValue("CIMVERSION", cimVersion))     if (!entry.getAttributeValue("CIMVERSION", cimVersion))
         throw XmlValidationError(         throw XmlValidationError(
             parser.getLine(), "missing CIM.CIMVERSION attribute");             parser.getLine(), "missing CIM.CIMVERSION attribute");
  
     if (strcmp(cimVersion, "2.0") != 0)  
         throw XmlValidationError(parser.getLine(),  
             "CIM.CIMVERSION attribute must be \"2.0\"");  
   
     const char* dtdVersion;  
   
     if (!entry.getAttributeValue("DTDVERSION", dtdVersion))     if (!entry.getAttributeValue("DTDVERSION", dtdVersion))
         throw XmlValidationError(         throw XmlValidationError(
             parser.getLine(), "missing CIM.DTDVERSION attribute");             parser.getLine(), "missing CIM.DTDVERSION attribute");
   
     if (strcmp(dtdVersion, "2.0") != 0)  
         throw XmlValidationError(parser.getLine(),  
             "CIM.DTDVERSION attribute must be \"2.0\"");  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 459 
Line 466 
 // //
 // getCimTypeAttribute() // getCimTypeAttribute()
 // //
   // This method can be used to get a TYPE attribute or a PARAMTYPE attribute.
   // The only significant difference is that PARAMTYPE may specify a value of
   // "reference" type.  This method recognizes these attributes by name, and
   // does not allow a "TYPE" attribute to be of "reference" type.
   //
 //     <!ENTITY % CIMType "TYPE (boolean|string|char16|uint8|sint8|uint16 //     <!ENTITY % CIMType "TYPE (boolean|string|char16|uint8|sint8|uint16
 //         |sint16|uint32|sint32|uint64|sint64|datetime|real32|real64)"> //         |sint16|uint32|sint32|uint64|sint64|datetime|real32|real64)">
 // //
   //     <!ENTITY % ParamType "PARAMTYPE (boolean|string|char16|uint8|sint8
   //         |uint16|sint16|uint32|sint32|uint64|sint64|datetime|real32|real64
   //         |reference)">
   //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 CIMType XmlReader::getCimTypeAttribute( CIMType XmlReader::getCimTypeAttribute(
     Uint32 lineNumber,     Uint32 lineNumber,
     const XmlEntry& entry,     const XmlEntry& entry,
     const char* tagName)      const char* tagName,
       const char* attributeName,
       Boolean required)
 { {
     const char* typeName;     const char* typeName;
  
     if (!entry.getAttributeValue("TYPE", typeName))      if (!entry.getAttributeValue(attributeName, typeName))
       {
           if (required)
     {     {
         char message[MESSAGE_SIZE];         char message[MESSAGE_SIZE];
         sprintf(message, "missing %s.TYPE attribute", tagName);              sprintf(message, "missing %s.%s attribute", tagName, attributeName);
         throw XmlValidationError(lineNumber, message);         throw XmlValidationError(lineNumber, message);
     }     }
           else
           {
               return CIMType::NONE;
           }
       }
  
     CIMType type = CIMType::NONE;     CIMType type = CIMType::NONE;
  
Line 508 
Line 533 
         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)
           type = CIMType::REFERENCE;
  
     if (type == CIMType::NONE)      if ((type == CIMType::NONE) ||
           ((type == CIMType::REFERENCE) &&
            (strcmp(attributeName, "PARAMTYPE") != 0)))
     {     {
         char message[MESSAGE_SIZE];         char message[MESSAGE_SIZE];
         sprintf(message, "Illegal value for %s.TYPE attribute", tagName);          sprintf(message, "Illegal value for %s.%s attribute", tagName,
                   attributeName);
         throw XmlSemanticError(lineNumber, message);         throw XmlSemanticError(lineNumber, message);
     }     }
  
Line 569 
Line 599 
  
 Boolean XmlReader::stringToReal(const char* stringValue, Real64& x) Boolean XmlReader::stringToReal(const char* stringValue, Real64& x)
 { {
       //
       // Check the string against the DMTF-defined grammar
       //
     const char* p = stringValue;     const char* p = stringValue;
  
     if (!*p)     if (!*p)
Line 625 
Line 658 
     if (*p)     if (*p)
         return false;         return false;
  
       //
       // Do the conversion
       //
     char* end;     char* end;
       errno = 0;
     x = strtod(stringValue, &end);     x = strtod(stringValue, &end);
       if (*end || (errno == ERANGE))
       {
           return false;
       }
   
     return true;     return true;
 } }
  
   inline Uint8 _hexCharToNumeric(const char c)
   {
       Uint8 n;
   
       if (isdigit(c))
           n = (c - '0');
       else if (isupper(c))
           n = (c - 'A' + 10);
       else // if (islower(c))
           n = (c - 'a' + 10);
   
       return n;
   }
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // stringToSignedInteger // stringToSignedInteger
 // //
 //      [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" ) //      [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
   //    or
   //      [ "+" | "-" ] ( "0x" | "0X" ) 1*hexDigit
 // //
 // ATTN-B: handle conversion from hexadecimal.  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Boolean XmlReader::stringToSignedInteger( Boolean XmlReader::stringToSignedInteger(
Line 646 
Line 703 
     x = 0;     x = 0;
     const char* p = stringValue;     const char* p = stringValue;
  
     if (!*p)      if (!p || !*p)
         return false;         return false;
  
     // Skip optional sign:     // Skip optional sign:
Line 656 
Line 713 
     if (negative || *p == '+')     if (negative || *p == '+')
         p++;         p++;
  
     // If the next thing is a zero, then it must be the last:  
   
     if (*p == '0')     if (*p == '0')
         return p[1] == '\0';      {
           if ( (p[1] == 'x') || (p[1] == 'X') )
     // Expect a positive decimal digit:          {
               // Convert a hexadecimal string
  
     const char* first = p;              // Skip over the "0x"
               p+=2;
  
     if (!isdigit(*p) || *p == '0')              // At least one hexadecimal digit is required
               if (!isxdigit(*p))
         return false;         return false;
  
     p++;              // Build the Sint64 as a negative number, regardless of the
               // eventual sign (negative numbers can be bigger than positive ones)
  
     // Expect zero or more digits:              // Add on each digit, checking for overflow errors
               while (isxdigit(*p))
               {
                   // Make sure we won't overflow when we multiply by 16
                   if (x < PEGASUS_LLONG_MIN/16)
                   {
                       return false;
                   }
                   x = x << 4;
  
     while (isdigit(*p))                  // Make sure we don't overflow when we add the next digit
         p++;                  Sint64 newDigit = Sint64(_hexCharToNumeric(*p++));
                   if (PEGASUS_LLONG_MIN - x > -newDigit)
                   {
                       return false;
                   }
                   x = x - newDigit;
               }
  
               // If we found a non-hexadecimal digit, report an error
     if (*p)     if (*p)
         return false;         return false;
  
     const char* last = p;              // Return the integer to positive, if necessary, checking for an
               // overflow error
               if (!negative)
               {
                   if (x == PEGASUS_LLONG_MIN)
                   {
                       return false;
                   }
                   x = -x;
               }
               return true;
           }
           else
           {
               // A decimal string that starts with '0' must be exactly "0".
               return p[1] == '\0';
           }
       }
   
       // Expect a positive decimal digit:
   
       // At least one decimal digit is required
       if (!isdigit(*p))
           return false;
   
       // Build the Sint64 as a negative number, regardless of the
       // eventual sign (negative numbers can be bigger than positive ones)
  
     while (first != last)      // Add on each digit, checking for overflow errors
         x = 10 * x + (*first++ - '0');      while (isdigit(*p))
       {
           // Make sure we won't overflow when we multiply by 10
           if (x < PEGASUS_LLONG_MIN/10)
           {
               return false;
           }
           x = 10 * x;
  
     if (negative)          // Make sure we won't overflow when we add the next digit
         x = -x;          Sint64 newDigit = (*p++ - '0');
           if (PEGASUS_LLONG_MIN - x > -newDigit)
           {
               return false;
           }
           x = x - newDigit;
       }
  
       // If we found a non-decimal digit, report an error
       if (*p)
           return false;
   
       // Return the integer to positive, if necessary, checking for an
       // overflow error
       if (!negative)
       {
           if (x == PEGASUS_LLONG_MIN)
           {
               return false;
           }
           x = -x;
       }
     return true;     return true;
 } }
  
Line 693 
Line 820 
 // //
 // stringToUnsignedInteger // stringToUnsignedInteger
 // //
 //      [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )  //      ( positiveDecimalDigit *decimalDigit | "0" )
   //    or
   //      ( "0x" | "0X" ) 1*hexDigit
 // //
 // ATTN-B: handle conversion from hexadecimal.  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Boolean XmlReader::stringToUnsignedInteger( Boolean XmlReader::stringToUnsignedInteger(
Line 705 
Line 833 
     x = 0;     x = 0;
     const char* p = stringValue;     const char* p = stringValue;
  
     if (!*p)      if (!p || !*p)
         return false;         return false;
  
     // Skip optional sign:      if (*p == '0')
       {
           if ( (p[1] == 'x') || (p[1] == 'X') )
           {
               // Convert a hexadecimal string
  
     if (*p == '-')              // Skip over the "0x"
               p+=2;
   
               // At least one hexadecimal digit is required
               if (!*p)
         return false;         return false;
  
     if (*p == '+')              // Add on each digit, checking for overflow errors
         p++;              while (isxdigit(*p))
               {
                   // Make sure we won't overflow when we multiply by 16
                   if (x > PEGASUS_ULLONG_MAX/16)
                   {
                       return false;
                   }
                   x = x << 4;
  
     // If the next thing is a zero, then it must be the last:                  // We can't overflow when we add the next digit
                   Uint64 newDigit = Uint64(_hexCharToNumeric(*p++));
                   if (PEGASUS_ULLONG_MAX - x < newDigit)
                   {
                       return false;
                   }
                   x = x + newDigit;
               }
  
     if (*p == '0')              // If we found a non-hexadecimal digit, report an error
               if (*p)
                   return false;
   
               return true;
           }
           else
           {
               // A decimal string that starts with '0' must be exactly "0".
         return p[1] == '\0';         return p[1] == '\0';
           }
       }
  
     // Expect a positive decimal digit:     // Expect a positive decimal digit:
  
     const char* first = p;      // Add on each digit, checking for overflow errors
       while (isdigit(*p))
     if (!isdigit(*p) || *p == '0')      {
           // Make sure we won't overflow when we multiply by 10
           if (x > PEGASUS_ULLONG_MAX/10)
           {
         return false;         return false;
           }
           x = 10 * x;
  
     p++;          // Make sure we won't overflow when we add the next digit
           Uint64 newDigit = (*p++ - '0');
     // Expect zero or more digits:          if (PEGASUS_ULLONG_MAX - x < newDigit)
           {
     while (isdigit(*p))              return false;
         p++;          }
           x = x + newDigit;
       }
  
       // If we found a non-decimal digit, report an error
     if (*p)     if (*p)
         return false;         return false;
  
     const char* last = p;  
   
     while (first != last)  
         x = 10 * x + (*first++ - '0');  
   
     return true;     return true;
 } }
  
Line 750 
Line 913 
 // //
 // stringToValue() // stringToValue()
 // //
 // ATTN-C: note that integers are truncated without warning. What should be  // Return: CIMValue. If the string input is zero length creates a CIMValue
 // done in this case? In C they are truncated without warning by design.  //         with value defined by the type.  Else the value is inserted.
   //
   //         Note that this does not set the CIMValue Null if the string is empty.
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
Line 762 
Line 927 
 { {
     // ATTN-B: accepting only UTF-8 for now! (affects string and char16):     // ATTN-B: accepting only UTF-8 for now! (affects string and char16):
  
     if (strlen(valueString)==0)      // Create value per type
     {  
         switch (type)  
         {  
             case CIMType::BOOLEAN: return CIMValue(false);  
             case CIMType::STRING: return CIMValue(valueString);  
             case CIMType::CHAR16: return CIMValue(Char16('\0'));  
             case CIMType::UINT8: return CIMValue(Uint8(0));  
             case CIMType::UINT16: return CIMValue(Uint16(0));  
             case CIMType::UINT32: return CIMValue(Uint32(0));  
             case CIMType::UINT64: return CIMValue(Uint64(0));  
             case CIMType::SINT8: return CIMValue(Sint8(0));  
             case CIMType::SINT16: return CIMValue(Sint16(0));  
             case CIMType::SINT32: return CIMValue(Sint32(0));  
             case CIMType::SINT64: return CIMValue(Sint64(0));  
             case CIMType::REAL32: return CIMValue(Real32(0));  
             case CIMType::REAL64: return CIMValue(Real64(0));  
         }  
     }  
   
     switch (type)     switch (type)
     {     {
         case CIMType::BOOLEAN:         case CIMType::BOOLEAN:
Line 823 
Line 969 
  
             switch (type)             switch (type)
             {             {
                 case CIMType::UINT8: return CIMValue(Uint8(x));                  case CIMType::UINT8:
                 case CIMType::UINT16: return CIMValue(Uint16(x));                  {
                 case CIMType::UINT32: return CIMValue(Uint32(x));                      if (x >= (Uint64(1)<<8))
                       {
                           throw XmlSemanticError(
                               lineNumber, "Uint8 value out of range");
                       }
                       return CIMValue(Uint8(x));
                   }
                   case CIMType::UINT16:
                   {
                       if (x >= (Uint64(1)<<16))
                       {
                           throw XmlSemanticError(
                               lineNumber, "Uint16 value out of range");
                       }
                       return CIMValue(Uint16(x));
                   }
                   case CIMType::UINT32:
                   {
                       if (x >= (Uint64(1)<<32))
                       {
                           throw XmlSemanticError(
                               lineNumber, "Uint32 value out of range");
                       }
                       return CIMValue(Uint32(x));
                   }
                 case CIMType::UINT64: return CIMValue(Uint64(x));                 case CIMType::UINT64: return CIMValue(Uint64(x));
                 default: break;                 default: break;
             }             }
Line 846 
Line 1016 
  
             switch (type)             switch (type)
             {             {
                 case CIMType::SINT8: return CIMValue(Sint8(x));                  case CIMType::SINT8:
                 case CIMType::SINT16: return CIMValue(Sint16(x));                  {
                 case CIMType::SINT32: return CIMValue(Sint32(x));                      if(  (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )
                       {
                           throw XmlSemanticError(
                               lineNumber, "Sint8 value out of range");
                       }
                       return CIMValue(Sint8(x));
                   }
                   case CIMType::SINT16:
                   {
                       if(  (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )
                       {
                           throw XmlSemanticError(
                               lineNumber, "Sint16 value out of range");
                       }
                       return CIMValue(Sint16(x));
                   }
                   case CIMType::SINT32:
                   {
                       if(  (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )
                       {
                           throw XmlSemanticError(
                               lineNumber, "Sint32 value out of range");
                       }
                       return CIMValue(Sint32(x));
                   }
                 case CIMType::SINT64: return CIMValue(Sint64(x));                 case CIMType::SINT64: return CIMValue(Sint64(x));
                 default: break;                 default: break;
             }             }
Line 875 
Line 1069 
             Real64 x;             Real64 x;
  
             if (!stringToReal(valueString, x))             if (!stringToReal(valueString, x))
                 throw XmlSemanticError(lineNumber, "Bad real value");                  throw XmlSemanticError(lineNumber, "Bad real number value");
  
             return CIMValue(Real32(x));             return CIMValue(Real32(x));
         }         }
Line 885 
Line 1079 
             Real64 x;             Real64 x;
  
             if (!stringToReal(valueString, x))             if (!stringToReal(valueString, x))
                 throw XmlSemanticError(lineNumber, "Bad real value");                  throw XmlSemanticError(lineNumber, "Bad real number value");
  
             return CIMValue(x);             return CIMValue(x);
         }         }
Line 904 
Line 1098 
 // //
 //     <!ELEMENT VALUE (#PCDATA)> //     <!ELEMENT VALUE (#PCDATA)>
 // //
   // Return: false if no value element.
   //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Boolean XmlReader::getValueElement( Boolean XmlReader::getValueElement(
Line 911 
Line 1107 
     CIMType type,     CIMType type,
     CIMValue& value)     CIMValue& value)
 { {
     // Get VALUE start tag:      // Get VALUE start tag: Return false if no VALUE start Tag
  
     XmlEntry entry;     XmlEntry entry;
     if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))     if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
Line 975 
Line 1171 
 //---------------------------------------------------------------------------- //----------------------------------------------------------------------------
 // //
 // getPropertyValue // getPropertyValue
 //     Use: Decode property value from getPropertyResponse  //     Use: Decode property value from SetProperty request and
 //     Expect (ERROR|IRETURNVALUE).!ELEMENT VALUE (#PCDATA)>  //     GetProperty response.
   //
   //     PropertyValue is one of:
 // //
 //      PropertyValue:  
 //      <!ELEMENT VALUE>  
 // //
 //      <!ELEMENT VALUE.ARRAY (VALUE*)> //      <!ELEMENT VALUE.ARRAY (VALUE*)>
 // //
 //      <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME| //      <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
   //         <!ELEMENT VALUE.ARRAY (VALUE*)>
   //
   //         <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|
 //                           INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)> //                           INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
 // //
   //         <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
   //
 //---------------------------------------------------------------------------- //----------------------------------------------------------------------------
 Boolean XmlReader::getPropertyValue( Boolean XmlReader::getPropertyValue(
     XmlParser& parser,     XmlParser& parser,
     CIMValue& cimValue)     CIMValue& cimValue)
 { {
     //ATTN: Test for Element value type      // Can not test for value type, so assume String
     CIMType type = CIMType::STRING;      const CIMType type = CIMType::STRING;
  
       // Test for VALUE element
     if (XmlReader::getValueElement(parser, type, cimValue))     if (XmlReader::getValueElement(parser, type, cimValue))
     {     {
         //cout << "DEBUG xmlReader::getPropertyValue " << __LINE__  
         //    << " CimValue = " << cimValue.toString << endl;  
         return true;         return true;
     }     }
  
     //Test for Element.array value      // Test for VALUE.ARRAY element
     if(XmlReader::getValueArrayElement(parser, type, cimValue))     if(XmlReader::getValueArrayElement(parser, type, cimValue))
       {
        return true;        return true;
       }
  
     // Test for Value.reference type      // 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);
         return true;         return true;
     }     }
  
       // Test for VALUE.REFARRAY element
       if (XmlReader::getValueReferenceArrayElement(parser, cimValue))
       {
          return true;
       }
   
    return false;    return false;
 } }
  
Line 1107 
Line 1315 
 // //
 //     <!ELEMENT VALUE.ARRAY (VALUE*)> //     <!ELEMENT VALUE.ARRAY (VALUE*)>
 // //
   //  Return: Boolean. Returns false if there is no VALUE.ARRAY start element
   //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Boolean XmlReader::getValueArrayElement( Boolean XmlReader::getValueArrayElement(
Line 1114 
Line 1324 
     CIMType type,     CIMType type,
     CIMValue& value)     CIMValue& value)
 { {
       // Clears any values from the Array. Assumes this is array CIMValue
     value.clear();     value.clear();
  
     // Get VALUE.ARRAY open tag:     // Get VALUE.ARRAY open tag:
  
     XmlEntry entry;     XmlEntry entry;
       Array<const char*> stringArray;
  
       // If no VALUE.ARRAY start tag, return false
     if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))     if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))
         return false;         return false;
  
     if (entry.type == XmlEntry::EMPTY_TAG)      if (entry.type != XmlEntry::EMPTY_TAG)
         return true;      {
   
     // For each VALUE element:     // For each VALUE element:
  
     Array<const char*> stringArray;  
   
     while (testStartTagOrEmptyTag(parser, entry, "VALUE"))     while (testStartTagOrEmptyTag(parser, entry, "VALUE"))
     {     {
         if (entry.type == XmlEntry::EMPTY_TAG)         if (entry.type == XmlEntry::EMPTY_TAG)
Line 1147 
Line 1357 
     }     }
  
     expectEndTag(parser, "VALUE.ARRAY");     expectEndTag(parser, "VALUE.ARRAY");
       }
  
     value = stringArrayToValue(parser.getLine(), stringArray, type);     value = stringArrayToValue(parser.getLine(), stringArray, type);
     return true;     return true;
Line 1189 
Line 1400 
     Boolean translatable = getCimBooleanAttribute(     Boolean translatable = getCimBooleanAttribute(
         lineNumber, entry, tagName, "TRANSLATABLE", false, false);         lineNumber, entry, tagName, "TRANSLATABLE", false, false);
  
     Uint32 flavor = 0;      // Start with CIMFlavor::NONE.  Defaults are specified in the
       // getCimBooleanAttribute() calls above.
       Uint32 flavor = CIMFlavor::NONE;
  
     if (overridable)     if (overridable)
         flavor |= CIMFlavor::OVERRIDABLE;         flavor |= CIMFlavor::OVERRIDABLE;
           else
                   flavor |= CIMFlavor::DISABLEOVERRIDE;
  
     if (toSubClass)     if (toSubClass)
         flavor |= CIMFlavor::TOSUBCLASS;         flavor |= CIMFlavor::TOSUBCLASS;
           else
                   flavor |= CIMFlavor::RESTRICTED;
  
     if (toInstance)     if (toInstance)
         flavor |= CIMFlavor::TOINSTANCE;         flavor |= CIMFlavor::TOINSTANCE;
Line 1276 
Line 1493 
 // //
 // getQualifierElement() // getQualifierElement()
 // //
 //     <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>  //     <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)?>
 //     <!ATTLIST QUALIFIER //     <!ATTLIST QUALIFIER
 //         %CIMName; //         %CIMName;
 //         %CIMType; #REQUIRED //         %CIMType; #REQUIRED
Line 1319 
Line 1536 
     if (!getValueElement(parser, type, value) &&     if (!getValueElement(parser, type, value) &&
         !getValueArrayElement(parser, type, value))         !getValueArrayElement(parser, type, value))
     {     {
         throw XmlSemanticError(parser.getLine(),          value.setNullValue(type, false);
             "Expected VALUE or VALUE.ARRAY element");  
     }     }
  
     // Expect </QUALIFIER>:     // Expect </QUALIFIER>:
Line 1397 
Line 1613 
  
     CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");     CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");
  
     // Create property:      // Create property: Sets type and !isarray
  
     CIMValue value;      CIMValue value(type, false);
     value.setNullValue(type, false);      property = CIMProperty(name, value, 0, String(), classOrigin, propagated);
     property = CIMProperty(  
         name, value, 0, String(), classOrigin, propagated);  
  
     if (!empty)     if (!empty)
     {     {
Line 1410 
Line 1624 
  
         getQualifierElements(parser, property);         getQualifierElements(parser, property);
  
         // Get value:          // Get value:  Insert value if getValueElement exists (returns True)
  
         if (getValueElement(parser, type, value))         if (getValueElement(parser, type, value))
             property.setValue(value);             property.setValue(value);
Line 1509 
Line 1723 
  
     // Create property:     // Create property:
  
     CIMValue nullValue;      CIMValue value(type, true, arraySize);
     nullValue.setNullValue(type, true, arraySize);  
     property = CIMProperty(     property = CIMProperty(
         name, nullValue, arraySize, String(), classOrigin, propagated);          name, value, arraySize, String(), classOrigin, propagated);
  
     if (!empty)     if (!empty)
     {     {
Line 1522 
Line 1735 
  
         // Get value:         // Get value:
  
         CIMValue value;  
   
         if (getValueArrayElement(parser, type, value))         if (getValueArrayElement(parser, type, value))
         {         {
             if (arraySize && arraySize != value.getArraySize())             if (arraySize && arraySize != value.getArraySize())
Line 1813 
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 1867 
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 1894 
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 1916 
Line 2127 
  
 Boolean XmlReader::getInstancePathElement( Boolean XmlReader::getInstancePathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 1957 
Line 2168 
  
 Boolean XmlReader::getLocalInstancePathElement( Boolean XmlReader::getLocalInstancePathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 1997 
Line 2208 
  
 Boolean XmlReader::getClassPathElement( Boolean XmlReader::getClassPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2037 
Line 2248 
  
 Boolean XmlReader::getLocalClassPathElement( Boolean XmlReader::getLocalClassPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2079 
Line 2290 
  
 Boolean XmlReader::getValueReferenceElement( Boolean XmlReader::getValueReferenceElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2140 
Line 2351 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // getValueReferenceArrayElement()
   //
   //     <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::getValueReferenceArrayElement(
       XmlParser& parser,
       CIMValue& value)
   {
       XmlEntry entry;
       Array<CIMObjectPath> referenceArray;
       CIMObjectPath reference;
   
       value.clear();
   
       // Get VALUE.REFARRAY open tag:
   
       if (!testStartTagOrEmptyTag(parser, entry, "VALUE.REFARRAY"))
           return false;
   
       if (entry.type != XmlEntry::EMPTY_TAG)
       {
           // For each VALUE.REFERENCE element:
   
           while (getValueReferenceElement(parser, reference))
           {
               referenceArray.append(reference);
           }
   
           expectEndTag(parser, "VALUE.REFARRAY");
       }
   
       value.set(referenceArray);
       return true;
   }
   
   //------------------------------------------------------------------------------
   //
 // getPropertyReferenceElement() // getPropertyReferenceElement()
 // //
 //     <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)> //     <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)>
Line 2184 
Line 2434 
  
     // Create property:     // Create property:
  
     CIMValue value;      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 2193 
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 2372 
Line 2622 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // getParameterReferenceArrayElement()
   //
   //     <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
   //     <!ATTLIST PARAMETER.REFARRAY
   //         %CIMName;
   //         %ReferenceClass;
   //         %ArraySize;>
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::getParameterReferenceArrayElement(
       XmlParser& parser,
       CIMParameter& parameter)
   {
       XmlEntry entry;
   
       if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFARRAY"))
           return false;
   
       Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
   
       // Get PARAMETER.NAME attribute:
   
       String name = getCimNameAttribute(
           parser.getLine(), entry, "PARAMETER.REFARRAY");
   
       // Get PARAMETER.REFERENCECLASS attribute:
   
       String referenceClass = getReferenceClassAttribute(
           parser.getLine(), entry, "PARAMETER.REFARRAY");
   
       // Get PARAMETER.ARRAYSIZE attribute:
   
       Uint32 arraySize = 0;
       getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.REFARRAY",
                             arraySize);
   
       // Create parameter:
   
       parameter = CIMParameter(name, CIMType::REFERENCE, true, arraySize,
                                referenceClass);
   
       if (!empty)
       {
           getQualifierElements(parser, parameter);
           expectEndTag(parser, "PARAMETER.REFARRAY");
       }
   
       return true;
   }
   
   //------------------------------------------------------------------------------
   //
 // GetParameterElements() // GetParameterElements()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2383 
Line 2686 
  
     while (XmlReader::getParameterElement(parser, parameter) ||     while (XmlReader::getParameterElement(parser, parameter) ||
         XmlReader::getParameterArrayElement(parser, parameter) ||         XmlReader::getParameterArrayElement(parser, parameter) ||
         XmlReader::getParameterReferenceElement(parser, parameter))          XmlReader::getParameterReferenceElement(parser, parameter) ||
           XmlReader::getParameterReferenceArrayElement(parser, parameter))
     {     {
         try         try
         {         {
Line 2539 
Line 2843 
  
     if (!empty)     if (!empty)
     {     {
           // ATTN-RK-P2-20020219: Decoding algorithm must not depend on the
           // ordering of qualifiers and parameters.
         getQualifierElements(parser, method);         getQualifierElements(parser, method);
  
         GetParameterElements(parser, method);         GetParameterElements(parser, method);
Line 2633 
Line 2939 
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
   // getNamedInstanceElement()
   //
   //     <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::getNamedInstanceElement(
       XmlParser& parser,
       CIMInstance& namedInstance)
   {
       XmlEntry entry;
   
       if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))
           return false;
   
       CIMObjectPath instanceName;
   
       // Get INSTANCENAME elements:
   
       if (!getInstanceNameElement(parser, instanceName))
       {
           throw XmlValidationError(parser.getLine(),
               "expected INSTANCENAME element");
       }
   
       // Get INSTANCE elements:
   
       if (!getInstanceElement(parser, namedInstance))
       {
           throw XmlValidationError(parser.getLine(),
               "expected INSTANCE element");
       }
   
       // Get VALUE.NAMEDINSTANCE end tag:
   
       expectEndTag(parser, "VALUE.NAMEDINSTANCE");
   
       namedInstance.setPath (instanceName);
   
       return true;
   }
   
   //------------------------------------------------------------------------------
 // //
 // getObject() // getObject()
 // //
Line 2686 
Line 3035 
 Boolean XmlReader::getMessageStartTag( Boolean XmlReader::getMessageStartTag(
     XmlParser& parser,     XmlParser& parser,
     String& id,     String& id,
     const char*& protocolVersion)      String& protocolVersion)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2833 
Line 3182 
  
 Boolean XmlReader::getErrorElement( Boolean XmlReader::getErrorElement(
     XmlParser& parser,     XmlParser& parser,
     CIMStatusCode& code,      CIMException& cimException,
     const char*& description,  
     Boolean required)     Boolean required)
 { {
     XmlEntry entry;     XmlEntry entry;
Line 2856 
Line 3204 
         throw XmlValidationError(         throw XmlValidationError(
             parser.getLine(), "missing ERROR.CODE attribute");             parser.getLine(), "missing ERROR.CODE attribute");
  
     code = CIMStatusCode(tmpCode);  
   
     // Get ERROR.DESCRIPTION:     // Get ERROR.DESCRIPTION:
  
     description = "";      String tmpDescription;
     entry.getAttributeValue("DESCRIPTION", description);  
       entry.getAttributeValue("DESCRIPTION", tmpDescription);
  
     if (!empty)     if (!empty)
         expectEndTag(parser, "ERROR");         expectEndTag(parser, "ERROR");
  
       cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);
     return true;     return true;
 } }
  
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // getObjectWithPath()  // getValueObjectElement()
   //
   // <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::getValueObjectElement(
       XmlParser& parser,
       CIMObject& object)
   {
       XmlEntry entry;
   
       if (!testStartTag(parser, entry, "VALUE.OBJECT"))
           return false;
   
       CIMInstance cimInstance;
       CIMClass cimClass;
   
       if (XmlReader::getInstanceElement(parser, cimInstance))
       {
           object = CIMObject(cimInstance);
       }
       else if (!XmlReader::getClassElement(parser, cimClass))
       {
           object = CIMObject(cimClass);
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "Expected INSTANCE or CLASS element");
       }
   
       expectEndTag(parser, "VALUE.OBJECT");
   
       return true;
   }
   
   //------------------------------------------------------------------------------
   // getValueObjectWithPathElement()
 // //
 // <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))> // <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Boolean XmlReader::getObjectWithPath(  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 2894 
Line 3280 
     else if (!XmlReader::getClassPathElement(parser, reference))     else if (!XmlReader::getClassPathElement(parser, reference))
     {     {
         throw XmlValidationError(parser.getLine(),         throw XmlValidationError(parser.getLine(),
             "Expected INSTANCE element");              "Expected INSTANCEPATH or CLASSPATH element");
     }     }
  
     if (isInstance)     if (isInstance)
Line 2904 
Line 3290 
         if (!XmlReader::getInstanceElement(parser, cimInstance))         if (!XmlReader::getInstanceElement(parser, cimInstance))
         {         {
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected INSTANCEPATH or CLASSPATH element");                  "Expected INSTANCE element");
         }         }
         objectWithPath.set(reference, CIMObject(cimInstance));          objectWithPath = CIMObject (cimInstance);
           objectWithPath.setPath (reference);
     }     }
     else     else
     {     {
Line 2917 
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 2926 
Line 3314 
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
   // getValueObjectWithLocalPathElement()
   //
   // <!ELEMENT VALUE.OBJECTWITHLOCALPATH
   //     ((LOCALCLASSPATH,CLASS)|(LOCALINSTANCEPATH,INSTANCE))>
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::getValueObjectWithLocalPathElement(
       XmlParser& parser,
       CIMObject& objectWithPath)
   {
       XmlEntry entry;
   
       if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))
           return false;
   
       CIMObjectPath reference;
       Boolean isInstance = false;
   
       if (XmlReader::getLocalInstancePathElement(parser, reference))
           isInstance = true;
       else if (!XmlReader::getLocalClassPathElement(parser, reference))
       {
           throw XmlValidationError(parser.getLine(),
               "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");
       }
   
       if (isInstance)
       {
           CIMInstance cimInstance;
   
           if (!XmlReader::getInstanceElement(parser, cimInstance))
           {
               throw XmlValidationError(parser.getLine(),
                   "Expected INSTANCE element");
           }
           objectWithPath = CIMObject (cimInstance);
           objectWithPath.setPath (reference);
       }
       else
       {
           CIMClass cimClass;
   
           if (!XmlReader::getClassElement(parser, cimClass))
           {
               throw XmlValidationError(parser.getLine(),
                   "Expected CLASS element");
           }
           objectWithPath = CIMObject (cimClass);
           objectWithPath.setPath (reference);
       }
   
       expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");
   
       return true;
   }
   
   //------------------------------------------------------------------------------
   // getObjectArray()
   //
   // <object>
   //     (VALUE.OBJECT|VALUE.OBJECTWITHLOCALPATH|VALUE.OBJECTWITHPATH)
   //
   //------------------------------------------------------------------------------
   
   void XmlReader::getObjectArray(
       XmlParser& parser,
       Array<CIMObject>& objectArray)
   {
       CIMObject object;
       CIMObject objectWithPath;
   
       objectArray.clear();
   
       if (getValueObjectElement(parser, object))
       {
           objectArray.append(object);
           while (getValueObjectElement(parser, object))
               objectArray.append(object);
       }
       else if (getValueObjectWithPathElement(parser, objectWithPath))
       {
           objectArray.append(objectWithPath);
           while (getValueObjectWithPathElement(parser, objectWithPath))
               objectArray.append(objectWithPath);
       }
       else if (getValueObjectWithLocalPathElement(parser, objectWithPath))
       {
           objectArray.append(objectWithPath);
           while (getValueObjectWithLocalPathElement(parser, objectWithPath))
               objectArray.append(objectWithPath);
       }
   }
   
   //------------------------------------------------------------------------------
 // //
 // <objectName>: (CLASSNAME|INSTANCENAME) // <objectName>: (CLASSNAME|INSTANCENAME)
 // //
Line 2933 
Line 3416 
  
 Boolean XmlReader::getObjectNameElement( Boolean XmlReader::getObjectNameElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& objectName)      CIMObjectPath& objectName)
 { {
     String className;     String className;
     CIMReference instanceName;  
  
     if (getClassNameElement(parser, className, false))     if (getClassNameElement(parser, className, false))
     {     {
Line 2962 
Line 3444 
  
 Boolean XmlReader::getObjectPathElement( Boolean XmlReader::getObjectPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& objectPath)      CIMObjectPath& objectPath)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 3086 
Line 3568 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // getParamValueTag()  // getParamValueElement()
   //
   // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
   // <!ATTLIST PARAMVALUE
   //      %CIMName;
   //      %ParamType;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Boolean XmlReader::getParamValueTag(  Boolean XmlReader::getParamValueElement(
     XmlParser& parser,     XmlParser& parser,
     const char*& name)      CIMParamValue& paramValue)
 { {
     XmlEntry entry;     XmlEntry entry;
       const char* name;
       CIMType type;
       CIMValue value;
  
     if (!testStartTag(parser, entry, "PARAMVALUE"))      if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))
         return false;         return false;
  
     // Get IPARAMVALUE.NAME attribute:      Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
   
       // Get PARAMVALUE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name))     if (!entry.getAttributeValue("NAME", name))
         throw XmlValidationError(parser.getLine(),         throw XmlValidationError(parser.getLine(),
             "Missing PARAMVALUE.NAME attribute");             "Missing PARAMVALUE.NAME attribute");
  
       // Get PARAMVALUE.PARAMTYPE attribute:
   
       type = getCimTypeAttribute(parser.getLine(), entry, "PARAMVALUE",
                                  "PARAMTYPE", false);
   
       if (!empty)
       {
           // Parse VALUE.REFERENCE and VALUE.REFARRAY type
           if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )
           {
               CIMObjectPath reference;
               if (XmlReader::getValueReferenceElement(parser, reference))
               {
                   value.set(reference);
                   type = CIMType::REFERENCE;
               }
               else if (XmlReader::getValueReferenceArrayElement(parser, value))
               {
                   type = CIMType::REFERENCE;
               }
               // If type==reference but no VALUE.REFERENCE found, use null value
           }
   
           // Parse non-reference value
           if ( type != CIMType::REFERENCE )
           {
               // If we don't know what type the value is, read it as a String
               CIMType effectiveType = type;
               if ( effectiveType == CIMType::NONE)
               {
                   effectiveType = CIMType::STRING;
               }
   
               if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&
                    !XmlReader::getValueElement(parser, effectiveType, value) )
               {
                   value.clear();    // Isn't necessary; should already be cleared
               }
           }
   
           expectEndTag(parser, "PARAMVALUE");
       }
   
       paramValue = CIMParamValue(name, value, Boolean(type!=CIMType::NONE));
   
       return true;
   }
   
   //------------------------------------------------------------------------------
   //
   // getReturnValueElement()
   //
   // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
   // <!ATTLIST RETURNVALUE
   //      %ParamType;>
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::getReturnValueElement(
       XmlParser& parser,
       CIMValue& returnValue)
   {
       XmlEntry entry;
       CIMType type;
       CIMValue value;
   
       if (!testStartTag(parser, entry, "RETURNVALUE"))
           return false;
   
       // Get RETURNVALUE.PARAMTYPE attribute:
       // NOTE: Array type return values are not allowed (2/20/02)
   
       type = getCimTypeAttribute(parser.getLine(), entry, "RETURNVALUE",
                                  "PARAMTYPE", false);
   
       // Parse VALUE.REFERENCE type
       if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )
       {
           CIMObjectPath reference;
           if (XmlReader::getValueReferenceElement(parser, reference))
           {
               returnValue.set(reference);
               type = CIMType::REFERENCE;
           }
           else if (type == CIMType::REFERENCE)
           {
               throw XmlValidationError(parser.getLine(),
                   "expected VALUE.REFERENCE element");
           }
       }
   
       // Parse non-reference return value
       if ( type != CIMType::REFERENCE )
       {
           // If we don't know what type the value is, read it as a String
           if ( type == CIMType::NONE)
           {
               type = CIMType::STRING;
           }
   
           if ( !XmlReader::getValueElement(parser, type, returnValue) )
           {
               throw XmlValidationError(parser.getLine(),
                   "expected VALUE element");
           }
       }
   
       expectEndTag(parser, "RETURNVALUE");
   
     return true;     return true;
 } }
  

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