(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.96 and 1.105

version 1.96, 2004/04/21 15:08:40 version 1.105, 2004/10/17 20:39:18
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%2004////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // 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
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 550 
Line 552 
     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))
     {     {
       // l10n       // l10n
Line 994 
Line 990 
     {     {
         // Convert UTF-8 to UTF-16 and return the String         // Convert UTF-8 to UTF-16 and return the String
         utf8Chars.append('\0');         utf8Chars.append('\0');
         return String((char *)utf8Chars.getData(),STRING_FLAG_UTF8);          return String((char *)utf8Chars.getData());
     }     }
     else     else
     {     {
Line 1269 
Line 1265 
  
         case CIMTYPE_STRING:         case CIMTYPE_STRING:
         {         {
             return CIMValue(String(valueString, STRING_FLAG_UTF8));              return CIMValue(String(valueString));
         }         }
  
         case CIMTYPE_CHAR16:         case CIMTYPE_CHAR16:
Line 1289 
Line 1285 
           }           }
 */ */
           // Converts UTF-8 to UTF-16           // Converts UTF-8 to UTF-16
           String tmp(valueString, STRING_FLAG_UTF8);            String tmp(valueString);
           if (tmp.size() != 1)           if (tmp.size() != 1)
           {           {
             // l10n             // l10n
Line 1668 
Line 1664 
         expectEndTag(parser, "VALUE");         expectEndTag(parser, "VALUE");
     }     }
  
     str = String(valueString,STRING_FLAG_UTF8);      str = String(valueString);
     return true;     return true;
 } }
  
Line 2014 
Line 2010 
     // Get QUALIFIER element:     // Get QUALIFIER element:
  
     XmlEntry entry;     XmlEntry entry;
     if (!testStartTag(parser, entry, "QUALIFIER"))      if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER"))
         return false;         return false;
  
       Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
   
     // Get QUALIFIER.NAME attribute:     // Get QUALIFIER.NAME attribute:
  
     CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");     CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
Line 2039 
Line 2037 
  
     CIMValue value;     CIMValue value;
  
       if (empty)
       {
           value.setNullValue(type, false);
       }
       else
       {
     if (!getValueElement(parser, type, value) &&     if (!getValueElement(parser, type, value) &&
         !getValueArrayElement(parser, type, value))         !getValueArrayElement(parser, type, value))
     {     {
Line 2048 
Line 2052 
     // Expect </QUALIFIER>:     // Expect </QUALIFIER>:
  
     expectEndTag(parser, "QUALIFIER");     expectEndTag(parser, "QUALIFIER");
       }
  
     // Build qualifier:     // Build qualifier:
  
Line 2311 
Line 2316 
             throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());             throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
  
         if (entry.type == XmlEntry::CONTENT)         if (entry.type == XmlEntry::CONTENT)
             host = String(entry.text,STRING_FLAG_UTF8);              host = String(entry.text);
         else         else
     {     {
             parser.putBack(entry);             parser.putBack(entry);
Line 2335 
Line 2340 
  
     }     }
  
     host = String(entry.text,STRING_FLAG_UTF8);      host = String(entry.text);
 #endif #endif
     expectEndTag(parser, "HOST");     expectEndTag(parser, "HOST");
     return true;     return true;
Line 2593 
Line 2598 
             throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());             throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
  
         if (entry.type == XmlEntry::CONTENT)         if (entry.type == XmlEntry::CONTENT)
             value = String(entry.text,STRING_FLAG_UTF8);              value = String(entry.text);
         else         else
             parser.putBack(entry);             parser.putBack(entry);
  
Line 3620 
Line 3625 
  
     cimClass = CIMClass(name, superClass);     cimClass = CIMClass(name, superClass);
  
           if(entry.type != XmlEntry::EMPTY_TAG)
           {
   
     // Get QUALIFIER elements:     // Get QUALIFIER elements:
  
     getQualifierElements(parser, cimClass);     getQualifierElements(parser, cimClass);
Line 3636 
Line 3644 
         cimClass.addMethod(method);         cimClass.addMethod(method);
  
     // Get CLASS end tag:     // Get CLASS end tag:
         if(entry.type != XmlEntry::EMPTY_TAG)  
                 expectEndTag(parser, "CLASS");                 expectEndTag(parser, "CLASS");
           }
  
     return true;     return true;
 } }
Line 3905 
Line 3914 
  
 Boolean XmlReader::getIMethodResponseStartTag( Boolean XmlReader::getIMethodResponseStartTag(
     XmlParser& parser,     XmlParser& parser,
     const char*& name)      const char*& name,
       Boolean& isEmptyTag)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "IMETHODRESPONSE"))      if (!testStartTagOrEmptyTag(parser, entry, "IMETHODRESPONSE"))
         return false;         return false;
  
       isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
   
     // Get IMETHODRESPONSE.NAME attribute:     // Get IMETHODRESPONSE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name)) {     if (!entry.getAttributeValue("NAME", name)) {
Line 3939 
Line 3951 
  
 Boolean XmlReader::getIParamValueTag( Boolean XmlReader::getIParamValueTag(
     XmlParser& parser,     XmlParser& parser,
     const char*& name)      const char*& name,
       Boolean& isEmptyTag)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "IPARAMVALUE"))      if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE"))
         return false;         return false;
  
       isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
   
     // Get IPARAMVALUE.NAME attribute:     // Get IPARAMVALUE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name)) {     if (!entry.getAttributeValue("NAME", name)) {
Line 3966 
Line 3981 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // rejectNullIParamValue()
   //
   //------------------------------------------------------------------------------
   
   void XmlReader::rejectNullIParamValue(
       XmlParser& parser,
       Boolean isEmptyTag,
       const char* paramName)
   {
       if (isEmptyTag)
       {
           MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE",
               "A null value is not valid for IPARAMVALUE \"$0\".",
               paramName);
           throw XmlValidationError(parser.getLine(), mlParms);
       }
   }
   
   //------------------------------------------------------------------------------
   //
 // getBooleanValueElement() // getBooleanValueElement()
 // //
 //     Get an elements like: "<VALUE>FALSE</VALUE>" //     Get an elements like: "<VALUE>FALSE</VALUE>"
Line 4121 
Line 4156 
     {     {
         object = CIMObject(cimInstance);         object = CIMObject(cimInstance);
     }     }
     else if (!XmlReader::getClassElement(parser, cimClass))      else if (XmlReader::getClassElement(parser, cimClass))
     {     {
         object = CIMObject(cimClass);         object = CIMObject(cimClass);
     }     }
Line 4471 
Line 4506 
  
 Boolean XmlReader::getEMethodResponseStartTag( Boolean XmlReader::getEMethodResponseStartTag(
     XmlParser& parser,     XmlParser& parser,
     const char*& name)      const char*& name,
       Boolean& isEmptyTag)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "EXPMETHODRESPONSE"))      if (!testStartTagOrEmptyTag(parser, entry, "EXPMETHODRESPONSE"))
         return false;         return false;
  
       isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
   
     // Get EXPMETHODRESPONSE.NAME attribute:     // Get EXPMETHODRESPONSE.NAME attribute:
  
  
Line 4575 
Line 4613 
  
 Boolean XmlReader::getMethodResponseStartTag( Boolean XmlReader::getMethodResponseStartTag(
     XmlParser& parser,     XmlParser& parser,
     const char*& name)      const char*& name,
       Boolean& isEmptyTag)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "METHODRESPONSE"))      if (!testStartTagOrEmptyTag(parser, entry, "METHODRESPONSE"))
         return false;         return false;
  
       isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
   
     // Get METHODRESPONSE.NAME attribute:     // Get METHODRESPONSE.NAME attribute:
  
  
Line 4618 
Line 4659 
 { {
     XmlEntry entry;     XmlEntry entry;
     const char* name;     const char* name;
     CIMType type;      CIMType type=CIMTYPE_BOOLEAN;
     CIMValue value;     CIMValue value;
  
     if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))     if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))

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