(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.70 and 1.76

version 1.70, 2002/08/25 06:43:56 version 1.76, 2002/10/02 20:35:06
Line 45 
Line 45 
 #include "CIMInstance.h" #include "CIMInstance.h"
 #include "CIMObject.h" #include "CIMObject.h"
 #include "CIMParamValue.h" #include "CIMParamValue.h"
   #include "System.h"
  
 //#define PEGASUS_SINT64_MIN (-PEGASUS_SINT64_LITERAL(9223372036854775808))  #define PEGASUS_SINT64_MIN (-PEGASUS_SINT64_LITERAL(0x8000000000000000))
 //#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(18446744073709551615)  #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)
 #define PEGASUS_SINT64_MIN (-PEGASUS_SINT64_LITERAL((Sint64) 0x8000000000000000))  
 #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL((Uint64) 0xFFFFFFFFFFFFFFFF)  
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 319 
Line 318 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 String XmlReader::getCimNameAttribute(  CIMName XmlReader::getCimNameAttribute(
     Uint32 lineNumber,     Uint32 lineNumber,
     const XmlEntry& entry,     const XmlEntry& entry,
     const char* elementName,     const char* elementName,
Line 335 
Line 334 
     }     }
  
     if (acceptNull && name.size() == 0)     if (acceptNull && name.size() == 0)
         return name;          return CIMName ();
  
     if (!CIMName::legal(name))     if (!CIMName::legal(name))
     {     {
Line 344 
Line 343 
         throw XmlSemanticError(lineNumber, buffer);         throw XmlSemanticError(lineNumber, buffer);
     }     }
  
     return name;      return CIMName (name);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 398 
Line 397 
     if (!entry.getAttributeValue("CLASSORIGIN", name))     if (!entry.getAttributeValue("CLASSORIGIN", name))
         return CIMName();         return CIMName();
  
       // KS 200209 This may be temp but we are adding test for form
       // CLASSNAME = "" for Wbemservices interoperability.  Returns same
       // as if attribute did not exist.
       if (name.size() == 0)
           return CIMName();
   
     if (!CIMName::legal(name))     if (!CIMName::legal(name))
     {     {
         char buffer[MESSAGE_SIZE];         char buffer[MESSAGE_SIZE];
Line 941 
Line 946 
     {     {
         case CIMTYPE_BOOLEAN:         case CIMTYPE_BOOLEAN:
         {         {
             if (CompareNoCase(valueString, "TRUE") == 0)              if (System::strcasecmp(valueString, "TRUE") == 0)
                 return CIMValue(true);                 return CIMValue(true);
             else if (CompareNoCase(valueString, "FALSE") == 0)              else if (System::strcasecmp(valueString, "FALSE") == 0)
                 return CIMValue(false);                 return CIMValue(false);
             else             else
                 throw XmlSemanticError(                 throw XmlSemanticError(
Line 1063 
Line 1068 
  
             try             try
             {             {
               // KS 20021002 - Exception if no datatime value. Test for
               // zero length and leave the NULL value in the variable
               // Bugzilla 137  Adds the following if line.
   #ifdef PEGASUS_SNIA_INTEROP_TEST
               if (strlen(valueString) != 0)
   #endif
                 tmp.set(valueString);                 tmp.set(valueString);
             }             }
             catch (InvalidDateTimeFormatException&)             catch (InvalidDateTimeFormatException&)
             {             {
           cout << "KSTESTSNIA Invalid date time" << strlen(valueString) << "xx" << valueString << endl;
                 throw XmlSemanticError(lineNumber, "Invalid datetime value");                 throw XmlSemanticError(lineNumber, "Invalid datetime value");
             }             }
  
Line 1524 
Line 1536 
  
     // Get QUALIFIER.NAME attribute:     // Get QUALIFIER.NAME attribute:
  
     String name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
  
     // Get QUALIFIER.TYPE attribute:     // Get QUALIFIER.TYPE attribute:
  
Line 1608 
Line 1620 
  
     // Get PROPERTY.NAME attribute:     // Get PROPERTY.NAME attribute:
  
     String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
  
     // Get PROPERTY.CLASSORIGIN attribute:     // Get PROPERTY.CLASSORIGIN attribute:
  
Line 1711 
Line 1723 
  
     // Get PROPERTY.NAME attribute:     // Get PROPERTY.NAME attribute:
  
     String name =      CIMName name =
         getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");         getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
  
     // Get PROPERTY.TYPE attribute:     // Get PROPERTY.TYPE attribute:
Line 1805 
Line 1817 
  
 Boolean XmlReader::getNameSpaceElement( Boolean XmlReader::getNameSpaceElement(
     XmlParser& parser,     XmlParser& parser,
     String& nameSpaceComponent)      CIMName& nameSpaceComponent)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 1840 
Line 1852 
     if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))     if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))
         return false;         return false;
  
     String nameSpaceComponent;      CIMName nameSpaceComponent;
  
     while (getNameSpaceElement(parser, nameSpaceComponent))     while (getNameSpaceElement(parser, nameSpaceComponent))
     {     {
         if (nameSpace.size())         if (nameSpace.size())
             nameSpace += '/';              nameSpace.append('/');
  
         nameSpace += nameSpaceComponent;          nameSpace.append(nameSpaceComponent.getString());
     }     }
  
     if (!nameSpace.size())     if (!nameSpace.size())
Line 1907 
Line 1919 
  
 Boolean XmlReader::getClassNameElement( Boolean XmlReader::getClassNameElement(
     XmlParser& parser,     XmlParser& parser,
     String& className,      CIMName& className,
     Boolean required)     Boolean required)
 { {
     XmlEntry entry;     XmlEntry entry;
Line 1942 
Line 1954 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 KeyBinding::Type XmlReader::getValueTypeAttribute(  CIMKeyBinding::Type XmlReader::getValueTypeAttribute(
     Uint32 lineNumber,     Uint32 lineNumber,
     const XmlEntry& entry,     const XmlEntry& entry,
     const char* elementName)     const char* elementName)
Line 1950 
Line 1962 
     String tmp;     String tmp;
  
     if (!entry.getAttributeValue("VALUETYPE", tmp))     if (!entry.getAttributeValue("VALUETYPE", tmp))
         return KeyBinding::STRING;          return CIMKeyBinding::STRING;
  
     if (String::equal(tmp, "string"))     if (String::equal(tmp, "string"))
         return KeyBinding::STRING;          return CIMKeyBinding::STRING;
     else if (String::equal(tmp, "boolean"))     else if (String::equal(tmp, "boolean"))
         return KeyBinding::BOOLEAN;          return CIMKeyBinding::BOOLEAN;
     else if (String::equal(tmp, "numeric"))     else if (String::equal(tmp, "numeric"))
         return KeyBinding::NUMERIC;          return CIMKeyBinding::NUMERIC;
  
     char buffer[MESSAGE_SIZE];     char buffer[MESSAGE_SIZE];
  
Line 1967 
Line 1979 
         elementName);         elementName);
  
     throw XmlSemanticError(lineNumber, buffer);     throw XmlSemanticError(lineNumber, buffer);
     return KeyBinding::BOOLEAN;      return CIMKeyBinding::BOOLEAN;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1982 
Line 1994 
  
 Boolean XmlReader::getKeyValueElement( Boolean XmlReader::getKeyValueElement(
     XmlParser& parser,     XmlParser& parser,
     KeyBinding::Type& type,      CIMKeyBinding::Type& type,
     String& value)     String& value)
 { {
     XmlEntry entry;     XmlEntry entry;
Line 2024 
Line 2036 
  
 Boolean XmlReader::getKeyBindingElement( Boolean XmlReader::getKeyBindingElement(
     XmlParser& parser,     XmlParser& parser,
     String& name,      CIMName& name,
     String& value,     String& value,
     KeyBinding::Type& type)      CIMKeyBinding::Type& type)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2045 
Line 2057 
                       "Expected KEYVALUE or VALUE.REFERENCE element");                       "Expected KEYVALUE or VALUE.REFERENCE element");
         }         }
  
         type = KeyBinding::REFERENCE;          type = CIMKeyBinding::REFERENCE;
         value = reference.toString();         value = reference.toString();
     }     }
  
Line 2069 
Line 2081 
 Boolean XmlReader::getInstanceNameElement( Boolean XmlReader::getInstanceNameElement(
     XmlParser& parser,     XmlParser& parser,
     String& className,     String& className,
     Array<KeyBinding>& keyBindings)      Array<CIMKeyBinding>& keyBindings)
 { {
     className.clear();     className.clear();
     keyBindings.clear();     keyBindings.clear();
Line 2088 
Line 2100 
         return true;         return true;
     }     }
  
     String name;      CIMName name;
     KeyBinding::Type type;      CIMKeyBinding::Type type;
     String value;     String value;
     CIMObjectPath reference;     CIMObjectPath reference;
  
     if (getKeyValueElement(parser, type, value))     if (getKeyValueElement(parser, type, value))
     {     {
         // Use empty key name because none was specified         // Use empty key name because none was specified
         keyBindings.append(KeyBinding(name, value, type));          keyBindings.append(CIMKeyBinding(name, value, type));
     }     }
     else if (getValueReferenceElement(parser, reference))     else if (getValueReferenceElement(parser, reference))
     {     {
         // Use empty key name because none was specified         // Use empty key name because none was specified
         type = KeyBinding::REFERENCE;          type = CIMKeyBinding::REFERENCE;
         value = reference.toString();         value = reference.toString();
         keyBindings.append(KeyBinding(name, value, type));          keyBindings.append(CIMKeyBinding(name, value, type));
     }     }
     else     else
     {     {
         while (getKeyBindingElement(parser, name, value, type))         while (getKeyBindingElement(parser, name, value, type))
             keyBindings.append(KeyBinding(name, value, type));              keyBindings.append(CIMKeyBinding(name, value, type));
     }     }
  
     expectEndTag(parser, "INSTANCENAME");     expectEndTag(parser, "INSTANCENAME");
Line 2121 
Line 2133 
     CIMObjectPath& instanceName)     CIMObjectPath& instanceName)
 { {
     String className;     String className;
     Array<KeyBinding> keyBindings;      Array<CIMKeyBinding> keyBindings;
  
     if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))     if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
         return false;         return false;
Line 2157 
Line 2169 
     }     }
  
     String className;     String className;
     Array<KeyBinding> keyBindings;      Array<CIMKeyBinding> keyBindings;
  
     if (!getInstanceNameElement(parser, className, keyBindings))     if (!getInstanceNameElement(parser, className, keyBindings))
     {     {
Line 2197 
Line 2209 
     }     }
  
     String className;     String className;
     Array<KeyBinding> keyBindings;      Array<CIMKeyBinding> keyBindings;
  
     if (!getInstanceNameElement(parser, className, keyBindings))     if (!getInstanceNameElement(parser, className, keyBindings))
     {     {
Line 2237 
Line 2249 
             "expected NAMESPACEPATH element");             "expected NAMESPACEPATH element");
     }     }
  
     String className;      CIMName className;
  
     if (!getClassNameElement(parser, className))     if (!getClassNameElement(parser, className))
     {     {
Line 2276 
Line 2288 
             "expected LOCALNAMESPACEPATH element");             "expected LOCALNAMESPACEPATH element");
     }     }
  
     String className;      CIMName className;
  
     if (!getClassNameElement(parser, className))     if (!getClassNameElement(parser, className))
     {     {
Line 2335 
Line 2347 
     else if (strcmp(entry.text, "CLASSNAME") == 0)     else if (strcmp(entry.text, "CLASSNAME") == 0)
     {     {
         parser.putBack(entry);         parser.putBack(entry);
         String className;          CIMName className;
         getClassNameElement(parser, className);         getClassNameElement(parser, className);
         reference.set(String(), CIMNamespaceName(), className);         reference.set(String(), CIMNamespaceName(), className);
     }     }
Line 2353 
Line 2365 
     {     {
         parser.putBack(entry);         parser.putBack(entry);
         String className;         String className;
         Array<KeyBinding> keyBindings;          Array<CIMKeyBinding> keyBindings;
         getInstanceNameElement(parser, className, keyBindings);         getInstanceNameElement(parser, className, keyBindings);
         reference.set(String(), CIMNamespaceName(), className, keyBindings);         reference.set(String(), CIMNamespaceName(), className, keyBindings);
     }     }
Line 2427 
Line 2439 
  
     // Get PROPERTY.NAME attribute:     // Get PROPERTY.NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "PROPERTY.REFERENCE");         parser.getLine(), entry, "PROPERTY.REFERENCE");
  
     // Get PROPERTY.REFERENCECLASS attribute:     // Get PROPERTY.REFERENCECLASS attribute:
Line 2517 
Line 2529 
  
     // Get PARAMETER.NAME attribute:     // Get PARAMETER.NAME attribute:
  
     String name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");
  
     // Get PARAMETER.TYPE attribute:     // Get PARAMETER.TYPE attribute:
  
Line 2563 
Line 2575 
  
     // Get PARAMETER.ARRAY.NAME attribute:     // Get PARAMETER.ARRAY.NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "PARAMETER.ARRAY");         parser.getLine(), entry, "PARAMETER.ARRAY");
  
     // Get PARAMETER.ARRAY.TYPE attribute:     // Get PARAMETER.ARRAY.TYPE attribute:
Line 2614 
Line 2626 
  
     // Get PARAMETER.NAME attribute:     // Get PARAMETER.NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "PARAMETER.REFERENCE");         parser.getLine(), entry, "PARAMETER.REFERENCE");
  
     // Get PARAMETER.REFERENCECLASS attribute:     // Get PARAMETER.REFERENCECLASS attribute:
Line 2660 
Line 2672 
  
     // Get PARAMETER.NAME attribute:     // Get PARAMETER.NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "PARAMETER.REFARRAY");         parser.getLine(), entry, "PARAMETER.REFARRAY");
  
     // Get PARAMETER.REFERENCECLASS attribute:     // Get PARAMETER.REFERENCECLASS attribute:
Line 2742 
Line 2754 
  
     // Get NAME attribute:     // Get NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "QUALIFIER.DECLARATION");         parser.getLine(), entry, "QUALIFIER.DECLARATION");
  
     // Get TYPE attribute:     // Get TYPE attribute:
Line 2850 
Line 2862 
  
     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
  
     String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
  
     CIMType type;     CIMType type;
     getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");     getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");
Line 2893 
Line 2905 
     if (!testStartTag(parser, entry, "CLASS"))     if (!testStartTag(parser, entry, "CLASS"))
         return false;         return false;
  
     String name = getCimNameAttribute(parser.getLine(), entry, "CLASS");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
  
     CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");     CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");
  
Line 3178 
Line 3190 
  
     expectContentOrCData(parser, entry);     expectContentOrCData(parser, entry);
  
     if (CompareNoCase(entry.text, "TRUE") == 0)      if (System::strcasecmp(entry.text, "TRUE") == 0)
         result = true;         result = true;
     else if (CompareNoCase(entry.text, "FALSE") == 0)      else if (System::strcasecmp(entry.text, "FALSE") == 0)
         result = false;         result = false;
     else     else
         throw XmlSemanticError(parser.getLine(),         throw XmlSemanticError(parser.getLine(),
Line 3440 
Line 3452 
     XmlParser& parser,     XmlParser& parser,
     CIMObjectPath& objectName)     CIMObjectPath& objectName)
 { {
     String className;      CIMName className;
  
     if (getClassNameElement(parser, className, false))     if (getClassNameElement(parser, className, false))
     {     {

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