(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.50 and 1.57

version 1.50, 2002/04/06 02:52:19 version 1.57, 2002/05/31 04:02:09
Line 45 
Line 45 
 #include "CIMClass.h" #include "CIMClass.h"
 #include "CIMInstance.h" #include "CIMInstance.h"
 #include "CIMObject.h" #include "CIMObject.h"
 #include "CIMNamedInstance.h"  
 #include "CIMParamValue.h" #include "CIMParamValue.h"
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
Line 929 
Line 928 
 { {
     // ATTN-B: accepting only UTF-8 for now! (affects string and char16):     // ATTN-B: accepting only UTF-8 for now! (affects string and char16):
  
 // The Specification for the Representation of CIM in XML does not indicate  
 // that a default value should be used when a VALUE element is empty.  
 //#if 0  ATTN-RK-P3-20020321: Take this code out when null qualifiers are fixed  
     // If strlen == 0, set to default value for type  
   
     if (strlen(valueString)==0)  
     {  
         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));  
         }  
     }  
 //#endif  
   
     // Create value per type     // Create value per type
     switch (type)     switch (type)
     {     {
Line 1236 
Line 1209 
     }     }
  
     // Test for VALUE.REFERENCE element     // 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);
Line 1364 
Line 1337 
     if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))     if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))
         return false;         return false;
  
     //ATTN: P1 KS KSTESTNULL - Need to relook at this one.  
     if (entry.type == XmlEntry::EMPTY_TAG)  
         return true;  
   
     if (entry.type != XmlEntry::EMPTY_TAG)     if (entry.type != XmlEntry::EMPTY_TAG)
     {     {
         // For each VALUE element:         // For each VALUE element:
Line 1525 
Line 1494 
 // //
 // getQualifierElement() // getQualifierElement()
 // //
 //     <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>  //     <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)?>
 //     <!ATTLIST QUALIFIER //     <!ATTLIST QUALIFIER
 //         %CIMName; //         %CIMName;
 //         %CIMType; #REQUIRED //         %CIMType; #REQUIRED
Line 1563 
Line 1532 
  
     // Get VALUE or VALUE.ARRAY element:     // Get VALUE or VALUE.ARRAY element:
  
     // ATTN: KS P1 4 March 2002 - Requires either value or array element or  
     // generates exception.  Correct for spec but means no NULL values on qualifier  
     // values. Alternative is to set NULL value and continue  
   
     CIMValue value;     CIMValue value;
  
     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 1651 
Line 1615 
     CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");     CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");
  
     // Create property: Sets type and !isarray     // Create property: Sets type and !isarray
     // ATTN: KS P1 change to use the correct constructor  
  
     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 1763 
Line 1724 
  
     // Create property:     // Create property:
  
     // ATTN: KS P1 4 March 2002 Change to use correct constructor.      CIMValue value(type, true, arraySize);
     // ATTN: KS P3 4 March 2002.  Why create extra value. Use same one.  
   
     CIMValue nullValue;  
     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 1779 
Line 1736 
  
         // Get value:         // Get value:
  
         // ATTN: KS P1 4 March 2002. Does not set array type into value.  
         // ATTN: Thus, if it returns false, the CIMValue is nothing.  
         CIMValue value;  
   
         if (getValueArrayElement(parser, type, value))         if (getValueArrayElement(parser, type, value))
         {         {
             if (arraySize && arraySize != value.getArraySize())             if (arraySize && arraySize != value.getArraySize())
Line 2072 
Line 2025 
  
     if (!getKeyValueElement(parser, type, value))     if (!getKeyValueElement(parser, type, value))
     {     {
         CIMReference reference;          CIMObjectPath reference;
  
         if (!getValueReferenceElement(parser, reference))         if (!getValueReferenceElement(parser, reference))
         {         {
Line 2126 
Line 2079 
     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 2153 
Line 2106 
  
 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 2175 
Line 2128 
  
 Boolean XmlReader::getInstancePathElement( Boolean XmlReader::getInstancePathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2216 
Line 2169 
  
 Boolean XmlReader::getLocalInstancePathElement( Boolean XmlReader::getLocalInstancePathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2256 
Line 2209 
  
 Boolean XmlReader::getClassPathElement( Boolean XmlReader::getClassPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2296 
Line 2249 
  
 Boolean XmlReader::getLocalClassPathElement( Boolean XmlReader::getLocalClassPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2338 
Line 2291 
  
 Boolean XmlReader::getValueReferenceElement( Boolean XmlReader::getValueReferenceElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& reference)      CIMObjectPath& reference)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2410 
Line 2363 
     CIMValue& value)     CIMValue& value)
 { {
     XmlEntry entry;     XmlEntry entry;
     Array<CIMReference> referenceArray;      Array<CIMObjectPath> referenceArray;
     CIMReference reference;      CIMObjectPath reference;
  
     value.clear();     value.clear();
  
Line 2482 
Line 2435 
  
     // 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 2491 
Line 2444 
     {     {
         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 2995 
Line 2948 
  
 Boolean XmlReader::getNamedInstanceElement( Boolean XmlReader::getNamedInstanceElement(
     XmlParser& parser,     XmlParser& parser,
     CIMNamedInstance& namedInstance)      CIMInstance& namedInstance)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))     if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))
         return false;         return false;
  
     CIMReference instanceName;      CIMObjectPath instanceName;
  
     // Get INSTANCENAME elements:     // Get INSTANCENAME elements:
  
Line 3012 
Line 2965 
             "expected INSTANCENAME element");             "expected INSTANCENAME element");
     }     }
  
     CIMInstance instance;  
   
     // Get INSTANCE elements:     // Get INSTANCE elements:
  
     if (!getInstanceElement(parser, instance))      if (!getInstanceElement(parser, namedInstance))
     {     {
         throw XmlValidationError(parser.getLine(),         throw XmlValidationError(parser.getLine(),
             "expected INSTANCE element");             "expected INSTANCE element");
Line 3026 
Line 2977 
  
     expectEndTag(parser, "VALUE.NAMEDINSTANCE");     expectEndTag(parser, "VALUE.NAMEDINSTANCE");
  
     namedInstance.set(instanceName, instance);      namedInstance.setPath (instanceName);
  
     return true;     return true;
 } }
Line 3315 
Line 3266 
  
 Boolean XmlReader::getValueObjectWithPathElement( 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 3342 
Line 3293 
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected INSTANCE element");                 "Expected INSTANCE element");
         }         }
         objectWithPath.set(reference, CIMObject(cimInstance));          objectWithPath = CIMObject (cimInstance);
           objectWithPath.setPath (reference);
     }     }
     else     else
     {     {
Line 3353 
Line 3305 
             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 3371 
Line 3324 
  
 Boolean XmlReader::getValueObjectWithLocalPathElement( Boolean XmlReader::getValueObjectWithLocalPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMObjectWithPath& objectWithPath)      CIMObject& objectWithPath)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))     if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))
         return false;         return false;
  
     CIMReference reference;      CIMObjectPath reference;
     Boolean isInstance = false;     Boolean isInstance = false;
  
     if (XmlReader::getLocalInstancePathElement(parser, reference))     if (XmlReader::getLocalInstancePathElement(parser, reference))
Line 3398 
Line 3351 
             throw XmlValidationError(parser.getLine(),             throw XmlValidationError(parser.getLine(),
                 "Expected INSTANCE element");                 "Expected INSTANCE element");
         }         }
         objectWithPath.set(reference, CIMObject(cimInstance));          objectWithPath = CIMObject (cimInstance);
           objectWithPath.setPath (reference);
     }     }
     else     else
     {     {
Line 3409 
Line 3363 
             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.OBJECTWITHLOCALPATH");     expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");
Line 3427 
Line 3382 
  
 void XmlReader::getObjectArray( void XmlReader::getObjectArray(
     XmlParser& parser,     XmlParser& parser,
     Array<CIMObjectWithPath>& objectArray)      Array<CIMObject>& objectArray)
 { {
     CIMObject object;     CIMObject object;
     CIMObjectWithPath objectWithPath;      CIMObject objectWithPath;
  
     objectArray.clear();     objectArray.clear();
  
     if (getValueObjectElement(parser, object))     if (getValueObjectElement(parser, object))
     {     {
         objectArray.append(CIMObjectWithPath(CIMReference(), object));          objectArray.append(object);
         while (getValueObjectElement(parser, object))         while (getValueObjectElement(parser, object))
             objectArray.append(CIMObjectWithPath(CIMReference(), object));              objectArray.append(object);
     }     }
     else if (getValueObjectWithPathElement(parser, objectWithPath))     else if (getValueObjectWithPathElement(parser, objectWithPath))
     {     {
Line 3462 
Line 3417 
  
 Boolean XmlReader::getObjectNameElement( Boolean XmlReader::getObjectNameElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& objectName)      CIMObjectPath& objectName)
 { {
     String className;     String className;
  
Line 3490 
Line 3445 
  
 Boolean XmlReader::getObjectPathElement( Boolean XmlReader::getObjectPathElement(
     XmlParser& parser,     XmlParser& parser,
     CIMReference& objectPath)      CIMObjectPath& objectPath)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 3653 
Line 3608 
         // Parse VALUE.REFERENCE and VALUE.REFARRAY type         // Parse VALUE.REFERENCE and VALUE.REFARRAY type
         if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )         if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )
         {         {
             CIMReference reference;              CIMObjectPath reference;
             if (XmlReader::getValueReferenceElement(parser, reference))             if (XmlReader::getValueReferenceElement(parser, reference))
             {             {
                 value.set(reference);                 value.set(reference);
Line 3721 
Line 3676 
     // Parse VALUE.REFERENCE type     // Parse VALUE.REFERENCE type
     if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )     if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )
     {     {
         CIMReference reference;          CIMObjectPath reference;
         if (XmlReader::getValueReferenceElement(parser, reference))         if (XmlReader::getValueReferenceElement(parser, reference))
         {         {
             returnValue.set(reference);             returnValue.set(reference);

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