(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.18 and 1.19

version 1.18, 2001/07/01 21:40:38 version 1.19, 2001/07/02 01:50:10
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM
 // //
Line 37 
Line 36 
 #include "CIMQualifierDecl.h" #include "CIMQualifierDecl.h"
 #include "CIMClass.h" #include "CIMClass.h"
 #include "CIMInstance.h" #include "CIMInstance.h"
   #include "CIMObject.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 773 
Line 773 
 { {
     // ATTN-B: accepting only UTF-8 for now! (affects string and char16):     // ATTN-B: accepting only UTF-8 for now! (affects string and char16):
  
 //SNIA      if (strlen(valueString)==0)
     if (strlen(valueString)==0) {      {
         switch (type) {          switch (type)
           {
             case CIMType::BOOLEAN: return CIMValue(false);             case CIMType::BOOLEAN: return CIMValue(false);
            case CIMType::STRING: return CIMValue(valueString);            case CIMType::STRING: return CIMValue(valueString);
            case CIMType::CHAR16: return CIMValue(Char16('\0'));            case CIMType::CHAR16: return CIMValue(Char16('\0'));
Line 791 
Line 792 
            case CIMType::REAL64: return CIMValue(Real64(0));            case CIMType::REAL64: return CIMValue(Real64(0));
         }         }
     }     }
 // end of SNIA  
  
     switch (type)     switch (type)
     {     {
Line 930 
Line 930 
  
     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
  
     // Get VALUE content:  
   
     const char* valueString = "";     const char* valueString = "";
     // cout << "DEBUG XMLReader:getValueElement " << __LINE__ ;  
  
     if (!empty)     if (!empty)
     {     {
         if (testContentOrCData(parser, entry))         if (testContentOrCData(parser, entry))
             valueString = entry.text;             valueString = entry.text;
         //cout << "DEBUG XMLReader:getValueElement " << __LINE__  
         //    <<  " valueString " << valueString ;  
  
         expectEndTag(parser, "VALUE");         expectEndTag(parser, "VALUE");
     }     }
  
     value = stringToValue(parser.getLine(), valueString,type);     value = stringToValue(parser.getLine(), valueString,type);
     //cout << "DEBUG XMLReader:getValueElement " << __LINE__  
     //  << " value " << value;  
     return true;     return true;
 } }
  
   //------------------------------------------------------------------------------
   //
   // getStringValueElement()
   //
   //     <!ELEMENT VALUE (#PCDATA)>
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::getStringValueElement(
       XmlParser& parser,
       String& str,
       Boolean required)
   {
       XmlEntry entry;
   
       if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
       {
           if (required)
               throw XmlValidationError(parser.getLine(),"Expected VALUE element");
           return false;
       }
   
       Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
   
       const char* valueString = "";
   
       if (!empty)
       {
           if (testContentOrCData(parser, entry))
               valueString = entry.text;
   
           expectEndTag(parser, "VALUE");
       }
   
       str = valueString;
       return true;
   }
  
 //---------------------------------------------------------------------------- //----------------------------------------------------------------------------
 // //
Line 1848 
Line 1879 
     return true;     return true;
 } }
  
   Boolean XmlReader::getInstanceNameElement(
       XmlParser& parser,
       CIMReference& instanceName)
   {
       String className;
       Array<KeyBinding> keyBindings;
   
       if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
           return false;
   
       instanceName.set(String(), String(), className, keyBindings);
       return true;
   }
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // getInstancePathElement() // getInstancePathElement()
Line 2828 
Line 2873 
     if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))     if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))
         return false;         return false;
  
     if (testStartTag(parser, entry, "INSTANCEPATH"))  
     {  
         CIMReference reference;         CIMReference reference;
       Boolean isInstance = false;
  
         if (!XmlReader::getInstancePathElement(parser, reference))      if (XmlReader::getInstancePathElement(parser, reference))
           isInstance = true;
       else if (!XmlReader::getClassPathElement(parser, reference))
         {         {
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected INSTANCEPATH element");              "Expected INSTANCE element");
         }         }
  
         CIMInstance instance;      if (isInstance)
       {
           CIMInstance cimInstance;
  
         if (!XmlReader::getInstanceElement(parser, instance))          if (!XmlReader::getInstanceElement(parser, cimInstance))
         {         {
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected INSTANCE element");                  "Expected INSTANCEPATH or CLASSPATH element");
         }         }
           objectWithPath.set(reference, CIMObject(cimInstance));
     }     }
     if (testStartTag(parser, entry, "CLASSPATH"))      else
     {  
         CIMReference reference;  
   
         if (!XmlReader::getClassPathElement(parser, reference))  
         {         {
             throw XmlValidationError(parser.getLine(),  
                 "Expected CLASSPATH element");  
         }  
   
         CIMClass cimClass;         CIMClass cimClass;
  
         if (!XmlReader::getClassElement(parser, cimClass))         if (!XmlReader::getClassElement(parser, cimClass))
Line 2863 
Line 2904 
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected CLASS element");                 "Expected CLASS element");
         }         }
           objectWithPath.set(reference, CIMObject(cimClass));
     }     }
   
       expectEndTag(parser, "VALUE.OBJECTWITHPATH");
   
       return true;
   }
   
   //------------------------------------------------------------------------------
   //
   // <objectName>: (CLASSNAME|INSTANCENAME)
   //
   //------------------------------------------------------------------------------
   
   
   Boolean XmlReader::getObjectNameElement(
       XmlParser& parser,
       CIMReference& objectName)
   {
       String className;
       CIMReference instanceName;
   
       if (getClassNameElement(parser, className, false))
       {
           objectName.set(String(), String(), className);
           return true;
       }
       else if (getInstanceNameElement(parser, objectName))
           return true;
     else     else
     {     {
         throw XmlValidationError(parser.getLine(),         throw XmlValidationError(parser.getLine(),
             "Expected INSTANCEPATH or CLASSPATH element");              "expected CLASSNAME or INSTANCENAME element");
     }     }
  
     expectEndTag(parser, "VALUE.OBJECTWITHPATH");      return false;
   
     return true;  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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