(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.26 and 1.31

version 1.26, 2002/02/20 03:51:29 version 1.31, 2002/02/23 03:47:22
Line 999 
Line 999 
 //---------------------------------------------------------------------------- //----------------------------------------------------------------------------
 // //
 // 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:  //     PropertyValue is one of:
 //      <!ELEMENT VALUE>  //
   //         <!ELEMENT VALUE (#PCDATA)>
 // //
 //      <!ELEMENT VALUE.ARRAY (VALUE*)> //      <!ELEMENT VALUE.ARRAY (VALUE*)>
 // //
 //      <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME| //      <!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;     CIMReference reference;
     if(XmlReader::getValueReferenceElement(parser, reference))     if(XmlReader::getValueReferenceElement(parser, reference))
     {     {
Line 1037 
Line 1041 
         return true;         return true;
     }     }
  
       // Test for VALUE.REFARRAY element
       if (XmlReader::getValueReferenceArrayElement(parser, cimValue))
       {
          return true;
       }
   
    return false;    return false;
 } }
  
Line 2164 
Line 2174 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // getValueReferenceArrayElement()
   //
   //     <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::getValueReferenceArrayElement(
       XmlParser& parser,
       CIMValue& value)
   {
       XmlEntry entry;
   
       value.clear();
   
       // Get VALUE.REFARRAY open tag:
   
       if (!testStartTagOrEmptyTag(parser, entry, "VALUE.REFARRAY"))
           return false;
   
       if (entry.type == XmlEntry::EMPTY_TAG)
           // ATTN-RK-P3-20020220: Should the type and array size get set in
           // the value even though it is null?  (See also getValueArrayElement.)
           return true;
   
       // For each VALUE.REFERENCE element:
   
       Array<CIMReference> referenceArray;
       CIMReference reference;
   
       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 3255 
Line 3307 
                 value.set(reference);                 value.set(reference);
                 type = CIMType::REFERENCE;                 type = CIMType::REFERENCE;
             }             }
             // ATTN-RK-P2-20010219: This method does not exist.  CIMValue does              else if (XmlReader::getValueReferenceArrayElement(parser, value))
             // not currently allow for an array of CIMReferences.              {
             //else if (XmlReader::getValueReferenceArrayElement(parser, value))                  type = CIMType::REFERENCE;
             //{              }
             //    type = CIMType::REFERENCE;              // If type==reference but no VALUE.REFERENCE found, use null value
             //}  
         }         }
  
         // Parse non-reference value         // Parse non-reference value
Line 3283 
Line 3334 
         expectEndTag(parser, "PARAMVALUE");         expectEndTag(parser, "PARAMVALUE");
     }     }
  
     paramValue = CIMParamValue(CIMParameter(name, type), value);      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) )
       {
           CIMReference 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.26  
changed lines
  Added in v.1.31
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2