(file) Return to CIMOperationResponseDecoder.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Client

Diff for /pegasus/src/Pegasus/Client/CIMOperationResponseDecoder.cpp between version 1.1.2.2 and 1.1.2.3

version 1.1.2.2, 2001/08/22 05:08:36 version 1.1.2.3, 2001/08/29 03:07:29
Line 251 
Line 251 
     XmlParser& parser,     XmlParser& parser,
     const String& messageId)     const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMCreateClassResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack()));
   
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMCreateClassResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack()));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeGetClassResponse( void CIMOperationResponseDecoder::_decodeGetClassResponse(
Line 262 
Line 290 
  
     if (XmlReader::getErrorElement(parser, code, description))     if (XmlReader::getErrorElement(parser, code, description))
     {     {
         CIMGetClassResponseMessage* message = new CIMGetClassResponseMessage(          _outputQueue->enqueue(new CIMGetClassResponseMessage(
             messageId,             messageId,
             code,             code,
             description,             description,
             QueueIdStack(),             QueueIdStack(),
             CIMClass());              CIMClass()));
   
         _outputQueue->enqueue(message);  
     }     }
     else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))     else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
     {     {
Line 280 
Line 306 
  
         XmlReader::testEndTag(parser, "IRETURNVALUE");         XmlReader::testEndTag(parser, "IRETURNVALUE");
  
         CIMGetClassResponseMessage* message = new CIMGetClassResponseMessage(          _outputQueue->enqueue(new CIMGetClassResponseMessage(
             messageId,             messageId,
             CIM_ERR_SUCCESS,             CIM_ERR_SUCCESS,
             String(),             String(),
             QueueIdStack(),             QueueIdStack(),
             cimClass);              cimClass));
     }     }
     else     else
     {     {
Line 297 
Line 323 
 void CIMOperationResponseDecoder::_decodeModifyClassResponse( void CIMOperationResponseDecoder::_decodeModifyClassResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMModifyClassResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMModifyClassResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack()));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse( void CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMEnumerateClassNamesResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               Array<String>()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           Array<String> classNames;
           String className;
   
           while (XmlReader::getClassNameElement(parser, className, false))
               classNames.append(className);
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMEnumerateClassNamesResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               classNames));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeEnumerateClassesResponse( void CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMEnumerateClassesResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               Array<CIMClass>()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           Array<CIMClass> cimClasses;
           CIMClass cimClass;
   
           while (XmlReader::getClassElement(parser, cimClass))
               cimClasses.append(cimClass);
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMEnumerateClassesResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               cimClasses));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeDeleteClassResponse( void CIMOperationResponseDecoder::_decodeDeleteClassResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMDeleteClassResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMDeleteClassResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack()));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeCreateInstanceResponse( void CIMOperationResponseDecoder::_decodeCreateInstanceResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMCreateInstanceResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMCreateInstanceResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack()));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeGetInstanceResponse( void CIMOperationResponseDecoder::_decodeGetInstanceResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMGetInstanceResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               CIMInstance()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           CIMInstance cimInstance;
   
           if (!XmlReader::getInstanceElement(parser, cimInstance))
           {
               throw XmlValidationError(
                   parser.getLine(), "expected INSTANCE element");
           }
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMGetInstanceResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               cimInstance));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeModifyInstanceResponse( void CIMOperationResponseDecoder::_decodeModifyInstanceResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMModifyInstanceResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMModifyInstanceResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack()));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse( void CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMEnumerateInstanceNamesResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               Array<CIMReference>()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           Array<CIMReference> instanceNames;
           String className;
           Array<KeyBinding> keyBindings;
   
           while (XmlReader::getInstanceNameElement(
               parser, className, keyBindings))
           {
               CIMReference r(
                   String::EMPTY,
                   String::EMPTY,
                   className,
                   keyBindings);
               instanceNames.append(r);
           }
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMEnumerateInstanceNamesResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               instanceNames));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeDeleteInstanceResponse( void CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMDeleteInstanceResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMDeleteInstanceResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack()));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeSetQualifierResponse( void CIMOperationResponseDecoder::_decodeSetQualifierResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMSetQualifierResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMSetQualifierResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack()));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeGetQualifierResponse( void CIMOperationResponseDecoder::_decodeGetQualifierResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMGetQualifierResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               CIMQualifierDecl()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           CIMQualifierDecl qualifierDecl;
           XmlReader::getQualifierDeclElement(parser, qualifierDecl);
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMGetQualifierResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               qualifierDecl));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse( void CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMEnumerateQualifiersResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               Array<CIMQualifierDecl>()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           Array<CIMQualifierDecl> qualifierDecls;
           CIMQualifierDecl qualifierDecl;
   
           while (XmlReader::getQualifierDeclElement(parser, qualifierDecl))
               qualifierDecls.append(qualifierDecl);
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMEnumerateQualifiersResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               qualifierDecls));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeDeleteQualifierResponse( void CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMDeleteQualifierResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack()));
 } }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMDeleteQualifierResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack()));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
   }
   
   //MEB:
  
 void CIMOperationResponseDecoder::_decodeReferenceNamesResponse( void CIMOperationResponseDecoder::_decodeReferenceNamesResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMReferenceNamesResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               Array<CIMReference>()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           CIMReference objectPath;
           Array<CIMReference> objectPaths;
   
           while (XmlReader::getObjectPathElement(parser, objectPath))
               objectPaths.append(objectPath);
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMReferenceNamesResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               objectPaths));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeReferencesResponse( void CIMOperationResponseDecoder::_decodeReferencesResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMReferencesResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               Array<CIMObjectWithPath>()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           Array<CIMObjectWithPath> objectWithPathArray;
           CIMObjectWithPath tmp;
   
           while (XmlReader::getObjectWithPath(parser, tmp))
               objectWithPathArray.append(tmp);
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMReferencesResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               objectWithPathArray));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeAssociatorNamesResponse( void CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMAssociatorNamesResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               Array<CIMReference>()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           CIMReference objectPath;
           Array<CIMReference> objectPaths;
   
           while (XmlReader::getObjectPathElement(parser, objectPath))
               objectPaths.append(objectPath);
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMAssociatorNamesResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               objectPaths));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 void CIMOperationResponseDecoder::_decodeAssociatorsResponse( void CIMOperationResponseDecoder::_decodeAssociatorsResponse(
     XmlParser& parser, const String& messageId)     XmlParser& parser, const String& messageId)
 { {
       XmlEntry entry;
       CIMStatusCode code;
       const char* description = 0;
   
       if (XmlReader::getErrorElement(parser, code, description))
       {
           _outputQueue->enqueue(new CIMAssociatorsResponseMessage(
               messageId,
               code,
               description,
               QueueIdStack(),
               Array<CIMObjectWithPath>()));
       }
       else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
       {
           Array<CIMObjectWithPath> objectWithPathArray;
           CIMObjectWithPath tmp;
   
           while (XmlReader::getObjectWithPath(parser, tmp))
               objectWithPathArray.append(tmp);
   
           XmlReader::testEndTag(parser, "IRETURNVALUE");
   
           _outputQueue->enqueue(new CIMAssociatorsResponseMessage(
               messageId,
               CIM_ERR_SUCCESS,
               String(),
               QueueIdStack(),
               objectWithPathArray));
       }
       else
       {
           throw XmlValidationError(parser.getLine(),
               "expected ERROR or IRETURNVALUE element");
       }
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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