(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.75 and 1.76

version 1.75, 2006/10/13 18:04:49 version 1.76, 2006/11/14 18:34:48
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)  
 //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)  
 //              Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)  
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //              Carol Ann Krug Graves, Hewlett-Packard Company  
 //                  (carolann_graves@hp.com)  
 //              Sushma Fernandes, Hewlett-Packard Company  
 //                  (sushma_fernandes@hp.com)  
 //              Dave Rosckes (rosckes@us.ibm.com)  
 //              Seema Gupta (gseema@in.ibm.com) for PEP135  
 //              Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1  
 //              Willis White, IBM (whiwill@us.ibm.com)  
 //              John Alex, IBM (johnalex@us.ibm.com) - Bug#2290  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
Line 59 
Line 43 
 #include <Pegasus/Common/Exception.h> #include <Pegasus/Common/Exception.h>
 #include "CIMOperationResponseDecoder.h" #include "CIMOperationResponseDecoder.h"
  
   
 // l10n  
 #include <Pegasus/Common/MessageLoader.h> #include <Pegasus/Common/MessageLoader.h>
  
   
   
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 81 
Line 61 
     _authenticator(authenticator),     _authenticator(authenticator),
     _showInput(showInput)     _showInput(showInput)
 { {
   
 } }
  
 CIMOperationResponseDecoder::~CIMOperationResponseDecoder() CIMOperationResponseDecoder::~CIMOperationResponseDecoder()
 { {
   
 } }
  
 void  CIMOperationResponseDecoder::setEncoderQueue(MessageQueue* encoderQueue) void  CIMOperationResponseDecoder::setEncoderQueue(MessageQueue* encoderQueue)
Line 139 
Line 117 
  
     if (httpMessage->message.size() == 0)     if (httpMessage->message.size() == 0)
     {     {
         // l10n          MessageLoaderParms mlParms(
               "Client.CIMOperationResponseDecoder.EMPTY_RESPONSE",
         // CIMClientMalformedHTTPException* malformedHTTPException =              "Empty HTTP response message.");
         //   new CIMClientMalformedHTTPException("Empty HTTP response message.");  
   
         MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EMPTY_RESPONSE", "Empty HTTP response message.");  
         String mlString(MessageLoader::getMessage(mlParms));         String mlString(MessageLoader::getMessage(mlParms));
  
         CIMClientMalformedHTTPException* malformedHTTPException =         CIMClientMalformedHTTPException* malformedHTTPException =
Line 182 
Line 157 
         startLine, httpVersion, statusCode, reasonPhrase);         startLine, httpVersion, statusCode, reasonPhrase);
     if (!parsableMessage)     if (!parsableMessage)
     {     {
         // l10n          MessageLoaderParms mlParms(
               "Client.CIMOperationResponseDecoder.MALFORMED_RESPONSE",
         // CIMClientMalformedHTTPException* malformedHTTPException = new              "Malformed HTTP response message.");
         //   CIMClientMalformedHTTPException("Malformed HTTP response message.");  
   
         MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.MALFORMED_RESPONSE", "Malformed HTTP response message.");  
         String mlString(MessageLoader::getMessage(mlParms));         String mlString(MessageLoader::getMessage(mlParms));
  
         CIMClientMalformedHTTPException* malformedHTTPException =         CIMClientMalformedHTTPException* malformedHTTPException =
Line 250 
Line 222 
         {         {
             //             //
             // Received a valid/error response from the server.             // Received a valid/error response from the server.
             // We do not need the original request message anymore, hence delete              // We do not need the original request message anymore, hence
             // the request message by getting the handle from the ClientAuthenticator.              // delete the request message by getting the handle from the
               // ClientAuthenticator.
             //             //
             Message* reqMessage = _authenticator->releaseRequestMessage();             Message* reqMessage = _authenticator->releaseRequestMessage();
             delete reqMessage;             delete reqMessage;
Line 282 
Line 255 
         String pegasusError;         String pegasusError;
  
         HTTPMessage::lookupHeader(headers, "CIMError", cimError, true);         HTTPMessage::lookupHeader(headers, "CIMError", cimError, true);
         HTTPMessage::lookupHeader(headers, PEGASUS_HTTPHEADERTAG_ERRORDETAIL, pegasusError);          HTTPMessage::lookupHeader(
               headers, PEGASUS_HTTPHEADERTAG_ERRORDETAIL, pegasusError);
         try         try
         {         {
             pegasusError = XmlReader::decodeURICharacters(pegasusError);             pegasusError = XmlReader::decodeURICharacters(pegasusError);
Line 312 
Line 286 
     if (!HTTPMessage::lookupHeader(     if (!HTTPMessage::lookupHeader(
         headers, "CIMOperation", cimOperation, true))         headers, "CIMOperation", cimOperation, true))
     {     {
       // l10n          MessageLoaderParms mlParms(
               "Client.CIMOperationResponseDecoder.MISSING_CIMOP_HEADER",
       // CIMClientMalformedHTTPException* malformedHTTPException = new              "Missing CIMOperation HTTP header");
       //   CIMClientMalformedHTTPException("Missing CIMOperation HTTP header");  
   
       MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.MISSING_CIMOP_HEADER", "Missing CIMOperation HTTP header");  
       String mlString(MessageLoader::getMessage(mlParms));       String mlString(MessageLoader::getMessage(mlParms));
  
       CIMClientMalformedHTTPException* malformedHTTPException = new          CIMClientMalformedHTTPException* malformedHTTPException =
         CIMClientMalformedHTTPException(mlString);              new CIMClientMalformedHTTPException(mlString);
  
         ClientExceptionMessage * response =         ClientExceptionMessage * response =
             new ClientExceptionMessage(malformedHTTPException);             new ClientExceptionMessage(malformedHTTPException);
Line 332 
Line 303 
         return;         return;
     }     }
  
   
                 // l10n start  
 // l10n end  
     //     //
     // Search for "Content-Type" header:     // Search for "Content-Type" header:
     //     //
Line 429 
Line 397 
         return;         return;
     }     }
     String serverTime;     String serverTime;
     if(HTTPMessage::lookupHeader(headers, "WBEMServerResponseTime", serverTime, true))      if (HTTPMessage::lookupHeader(
               headers, "WBEMServerResponseTime", serverTime, true))
     {     {
         Uint32 sTime = (Uint32) atol(serverTime.getCString());         Uint32 sTime = (Uint32) atol(serverTime.getCString());
         dataStore->setServerTime(sTime);         dataStore->setServerTime(sTime);
Line 454 
Line 423 
  
     if (!String::equalNoCase(cimOperation, "MethodResponse"))     if (!String::equalNoCase(cimOperation, "MethodResponse"))
     {     {
         // l10n          MessageLoaderParms mlParms(
               "Client.CIMOperationResponseDecoder.EXPECTED_METHODRESPONSE",
         // CIMClientMalformedHTTPException* malformedHTTPException =              "Received CIMOperation HTTP header value \"$1\", expected "
         //   new CIMClientMalformedHTTPException(                  "\"MethodResponse\"",
         //        String("Received CIMOperation HTTP header value \"") +              cimOperation);
         //        cimOperation + "\", expected \"MethodResponse\"");  
   
         MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_METHODRESPONSE", "Received CIMOperation HTTP header value \"$1\", expected \"MethodResponse\"", cimOperation);  
         String mlString(MessageLoader::getMessage(mlParms));         String mlString(MessageLoader::getMessage(mlParms));
  
         CIMClientMalformedHTTPException* malformedHTTPException =         CIMClientMalformedHTTPException* malformedHTTPException =
Line 478 
Line 444 
  
     dataStore->setResponseSize(contentLength);     dataStore->setResponseSize(contentLength);
     dataStore->setEndNetworkTime(networkEndTime);     dataStore->setEndNetworkTime(networkEndTime);
     //dataStore->print();      _handleMethodResponse(content, httpMessage->contentLanguages,cimReconnect);
     _handleMethodResponse(content, httpMessage->contentLanguages,cimReconnect);  // l10n  
 } }
  
 void CIMOperationResponseDecoder::_handleMethodResponse( void CIMOperationResponseDecoder::_handleMethodResponse(
     char* content,     char* content,
     const ContentLanguageList& contentLanguages,     const ContentLanguageList& contentLanguages,
     Boolean cimReconnect) //l10n      Boolean cimReconnect)
 { {
     Message* response = 0;     Message* response = 0;
  
Line 526 
Line 491 
  
         if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))         if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))
         {         {
             // l10n              MessageLoaderParms mlParms(
                   "Client.CIMOperationResponseDecoder.EXPECTED_MESSAGE_ELEMENT",
             // throw XmlValidationError(  
             // parser.getLine(), "expected MESSAGE element");  
   
             MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_MESSAGE_ELEMENT",  
                 "expected MESSAGE element");                 "expected MESSAGE element");
   
             throw XmlValidationError(parser.getLine(), mlParms);             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
  
  
         //         //
         // This code for checking the protocol version was taken from the server code.          // This code for checking the protocol version was taken from the
           // server code.
         //         //
         Boolean protocolVersionAccepted = false;         Boolean protocolVersionAccepted = false;
  
Line 564 
Line 525 
  
         if (!protocolVersionAccepted)         if (!protocolVersionAccepted)
         {         {
             MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.UNSUPPORTED_PROTOCOL", "Received unsupported protocol version \"$0\", expected \"$1\"", protocolVersion, "1.[0-9]+");              MessageLoaderParms mlParms(
                   "Client.CIMOperationResponseDecoder.UNSUPPORTED_PROTOCOL",
                   "Received unsupported protocol version \"$0\", expected "
                       "\"$1\"",
                   protocolVersion,
                   "1.[0-9]+");
             String mlString(MessageLoader::getMessage(mlParms));             String mlString(MessageLoader::getMessage(mlParms));
  
             CIMClientResponseException* responseException =             CIMClientResponseException* responseException =
Line 602 
Line 568 
             if (System::strcasecmp(iMethodResponseName, "GetClass") == 0)             if (System::strcasecmp(iMethodResponseName, "GetClass") == 0)
                 response = _decodeGetClassResponse(                 response = _decodeGetClassResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "GetInstance") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "GetInstance") == 0)
                 response = _decodeGetInstanceResponse(                 response = _decodeGetInstanceResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "EnumerateClassNames") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "EnumerateClassNames") == 0)
                 response = _decodeEnumerateClassNamesResponse(                 response = _decodeEnumerateClassNamesResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "References") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "References") == 0)
                 response = _decodeReferencesResponse(                 response = _decodeReferencesResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "ReferenceNames") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "ReferenceNames") == 0)
                 response = _decodeReferenceNamesResponse(                 response = _decodeReferenceNamesResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "AssociatorNames") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "AssociatorNames") == 0)
                 response = _decodeAssociatorNamesResponse(                 response = _decodeAssociatorNamesResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "Associators") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "Associators") == 0)
                 response = _decodeAssociatorsResponse(                 response = _decodeAssociatorsResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "CreateInstance") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "CreateInstance") == 0)
                 response = _decodeCreateInstanceResponse(                 response = _decodeCreateInstanceResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName,"EnumerateInstanceNames") == 0)              else if (System::strcasecmp(
                            iMethodResponseName,"EnumerateInstanceNames") == 0)
                 response = _decodeEnumerateInstanceNamesResponse(                 response = _decodeEnumerateInstanceNamesResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName,"EnumerateInstances") == 0)              else if (System::strcasecmp(
                            iMethodResponseName,"EnumerateInstances") == 0)
                 response = _decodeEnumerateInstancesResponse(                 response = _decodeEnumerateInstancesResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "GetProperty") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "GetProperty") == 0)
                 response = _decodeGetPropertyResponse(                 response = _decodeGetPropertyResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "SetProperty") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "SetProperty") == 0)
                 response = _decodeSetPropertyResponse(                 response = _decodeSetPropertyResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "DeleteQualifier") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "DeleteQualifier") == 0)
                 response = _decodeDeleteQualifierResponse(                 response = _decodeDeleteQualifierResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "GetQualifier") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "GetQualifier") == 0)
                 response = _decodeGetQualifierResponse(                 response = _decodeGetQualifierResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "SetQualifier") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "SetQualifier") == 0)
                 response = _decodeSetQualifierResponse(                 response = _decodeSetQualifierResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "EnumerateQualifiers") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "EnumerateQualifiers") == 0)
                 response = _decodeEnumerateQualifiersResponse(                 response = _decodeEnumerateQualifiersResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "EnumerateClasses") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "EnumerateClasses") == 0)
                 response = _decodeEnumerateClassesResponse(                 response = _decodeEnumerateClassesResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "CreateClass") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "CreateClass") == 0)
                 response = _decodeCreateClassResponse(                 response = _decodeCreateClassResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "ModifyClass") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "ModifyClass") == 0)
                 response = _decodeModifyClassResponse(                 response = _decodeModifyClassResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "ModifyInstance") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "ModifyInstance") == 0)
                 response = _decodeModifyInstanceResponse(                 response = _decodeModifyInstanceResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "DeleteClass") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "DeleteClass") == 0)
                 response = _decodeDeleteClassResponse(                 response = _decodeDeleteClassResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "DeleteInstance") == 0)              else if (System::strcasecmp(
                            iMethodResponseName, "DeleteInstance") == 0)
                 response = _decodeDeleteInstanceResponse(                 response = _decodeDeleteInstanceResponse(
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "ExecQuery") == 0)             else if (System::strcasecmp(iMethodResponseName, "ExecQuery") == 0)
Line 670 
Line 657 
                     parser, messageId, isEmptyTag);                     parser, messageId, isEmptyTag);
             else             else
             {             {
                 // l10n  
   
                 // Unrecognized IMethodResponse name attribute  
                 // throw XmlValidationError(parser.getLine(),  
                 //   String("Unrecognized IMethodResponse name \"") +  
                 //        iMethodResponseName + "\"");  
   
                 MessageLoaderParms mlParms(                 MessageLoaderParms mlParms(
                     "Client.CIMOperationResponseDecoder.UNRECOGNIZED_NAME",                     "Client.CIMOperationResponseDecoder.UNRECOGNIZED_NAME",
                     "Unrecognized IMethodResponse name \"$0\"",                     "Unrecognized IMethodResponse name \"$0\"",
Line 710 
Line 690 
         }         }
         else         else
         {         {
             // l10n              MessageLoaderParms mlParms(
                   "Client.CIMOperationResponseDecoder."
             // throw XmlValidationError(parser.getLine(),                      "EXPECTED_METHODRESPONSE_OR_IMETHODRESPONSE_ELEMENT",
             //   "expected METHODRESPONSE or IMETHODRESPONSE element");  
   
             MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_METHODRESPONSE_OR_IMETHODRESPONSE_ELEMENT",  
                 "expected METHODRESPONSE or IMETHODRESPONSE element");                 "expected METHODRESPONSE or IMETHODRESPONSE element");
   
             throw XmlValidationError(parser.getLine(), mlParms);             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
  
Line 731 
Line 707 
     catch (XmlException& x)     catch (XmlException& x)
     {     {
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::TRACE,         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::TRACE,
             "CIMOperationResponseDecoder::_handleMethodResponse - XmlException has occurred. Message: $0",x.getMessage());              "CIMOperationResponseDecoder::_handleMethodResponse - "
                   "XmlException has occurred. Message: $0",
               x.getMessage());
  
         if (response)         if (response)
         {         {
Line 765 
Line 743 
     CIMMessage * cimmsg = dynamic_cast<CIMMessage *>(response);     CIMMessage * cimmsg = dynamic_cast<CIMMessage *>(response);
     if (cimmsg != NULL)     if (cimmsg != NULL)
     {     {
         cimmsg->operationContext.set(ContentLanguageListContainer(contentLanguages));          cimmsg->operationContext.set(
               ContentLanguageListContainer(contentLanguages));
     }     }
     else     else
     {     {
Line 779 
Line 758 
     _outputQueue->enqueue(response);     _outputQueue->enqueue(response);
 } }
  
 CIMCreateClassResponseMessage* CIMOperationResponseDecoder::_decodeCreateClassResponse(  CIMCreateClassResponseMessage*
       CIMOperationResponseDecoder::_decodeCreateClassResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 791 
Line 771 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMCreateClassResponseMessage(              return new CIMCreateClassResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack()));                  QueueIdStack());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 806 
Line 786 
         }         }
     }     }
  
     return(new CIMCreateClassResponseMessage(      return new CIMCreateClassResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack()));          QueueIdStack());
 } }
  
 CIMGetClassResponseMessage* CIMOperationResponseDecoder::_decodeGetClassResponse(  CIMGetClassResponseMessage*
       CIMOperationResponseDecoder::_decodeGetClassResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 828 
Line 809 
     }     }
     else if (XmlReader::getErrorElement(parser, cimException))     else if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMGetClassResponseMessage(          return new CIMGetClassResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack(),             QueueIdStack(),
             CIMClass()));              CIMClass());
     }     }
     else if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))     else if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
     {     {
Line 841 
Line 822 
         if ((entry.type == XmlEntry::EMPTY_TAG) ||         if ((entry.type == XmlEntry::EMPTY_TAG) ||
             !XmlReader::getClassElement(parser, cimClass))             !XmlReader::getClassElement(parser, cimClass))
         {         {
             // l10n  
   
             // throw XmlValidationError(parser.getLine(),"expected CLASS element");  
   
             MessageLoaderParms mlParms(             MessageLoaderParms mlParms(
                 "Client.CIMOperationResponseDecoder.EXPECTED_CLASS_ELEMENT",                 "Client.CIMOperationResponseDecoder.EXPECTED_CLASS_ELEMENT",
                 "expected CLASS element");                 "expected CLASS element");
Line 853 
Line 830 
  
         XmlReader::expectEndTag(parser, "IRETURNVALUE");         XmlReader::expectEndTag(parser, "IRETURNVALUE");
  
         return(new CIMGetClassResponseMessage(          return new CIMGetClassResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack(),             QueueIdStack(),
             cimClass));              cimClass);
     }     }
     else     else
     {     {
         // l10n          MessageLoaderParms mlParms(
               "Client.CIMOperationResponseDecoder."
         // throw XmlValidationError(parser.getLine(),                  "EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",
         //   "expected ERROR or IRETURNVALUE element");  
   
         MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",  
             "expected ERROR or IRETURNVALUE element");             "expected ERROR or IRETURNVALUE element");
   
         throw XmlValidationError(parser.getLine(), mlParms);         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
 CIMModifyClassResponseMessage* CIMOperationResponseDecoder::_decodeModifyClassResponse(  CIMModifyClassResponseMessage*
       CIMOperationResponseDecoder::_decodeModifyClassResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 885 
Line 859 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMModifyClassResponseMessage(              return new CIMModifyClassResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack()));                  QueueIdStack());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 900 
Line 874 
         }         }
     }     }
  
     return(new CIMModifyClassResponseMessage(      return new CIMModifyClassResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack()));          QueueIdStack());
 } }
  
 CIMEnumerateClassNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(  CIMEnumerateClassNamesResponseMessage*
       CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 919 
Line 894 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMEnumerateClassNamesResponseMessage(              return new CIMEnumerateClassNamesResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMName>()));                  Array<CIMName>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 940 
Line 915 
         }         }
     }     }
  
     return(new CIMEnumerateClassNamesResponseMessage(      return new CIMEnumerateClassNamesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         classNames));          classNames);
 } }
  
 CIMEnumerateClassesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(  CIMEnumerateClassesResponseMessage*
       CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 960 
Line 936 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMEnumerateClassesResponseMessage(              return new CIMEnumerateClassesResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMClass>()));                  Array<CIMClass>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 981 
Line 957 
         }         }
     }     }
  
     return(new CIMEnumerateClassesResponseMessage(      return new CIMEnumerateClassesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         cimClasses));          cimClasses);
 } }
  
 CIMDeleteClassResponseMessage* CIMOperationResponseDecoder::_decodeDeleteClassResponse(  CIMDeleteClassResponseMessage*
       CIMOperationResponseDecoder::_decodeDeleteClassResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1000 
Line 977 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMDeleteClassResponseMessage(              return new CIMDeleteClassResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack()));                  QueueIdStack());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1015 
Line 992 
         }         }
     }     }
  
     return(new CIMDeleteClassResponseMessage(      return new CIMDeleteClassResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack()));          QueueIdStack());
 } }
  
 CIMCreateInstanceResponseMessage* CIMOperationResponseDecoder::_decodeCreateInstanceResponse(  CIMCreateInstanceResponseMessage*
       CIMOperationResponseDecoder::_decodeCreateInstanceResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1037 
Line 1015 
     }     }
     else if (XmlReader::getErrorElement(parser, cimException))     else if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMCreateInstanceResponseMessage(          return new CIMCreateInstanceResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack(),             QueueIdStack(),
             CIMObjectPath()));              CIMObjectPath());
     }     }
     else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))     else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
     {     {
Line 1050 
Line 1028 
  
         XmlReader::expectEndTag(parser, "IRETURNVALUE");         XmlReader::expectEndTag(parser, "IRETURNVALUE");
  
         return(new CIMCreateInstanceResponseMessage(          return new CIMCreateInstanceResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack(),             QueueIdStack(),
             instanceName));              instanceName);
     }     }
     else     else
     {     {
         // l10n          MessageLoaderParms mlParms(
               "Client.CIMOperationResponseDecoder."
         // throw XmlValidationError(parser.getLine(),                  "EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",
         //   "expected ERROR or IRETURNVALUE element");  
   
         MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",  
             "expected ERROR or IRETURNVALUE element");             "expected ERROR or IRETURNVALUE element");
  
         throw XmlValidationError(parser.getLine(), mlParms);         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
 CIMGetInstanceResponseMessage* CIMOperationResponseDecoder::_decodeGetInstanceResponse(  CIMGetInstanceResponseMessage*
       CIMOperationResponseDecoder::_decodeGetInstanceResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1086 
Line 1062 
     }     }
     else if (XmlReader::getErrorElement(parser, cimException))     else if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMGetInstanceResponseMessage(          return new CIMGetInstanceResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack(),             QueueIdStack(),
             CIMInstance()));              CIMInstance());
     }     }
     else if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))     else if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
     {     {
Line 1099 
Line 1075 
         if ((entry.type == XmlEntry::EMPTY_TAG) ||         if ((entry.type == XmlEntry::EMPTY_TAG) ||
             !XmlReader::getInstanceElement(parser, cimInstance))             !XmlReader::getInstanceElement(parser, cimInstance))
         {         {
             // l10n  
   
             // throw XmlValidationError(  
             // parser.getLine(), "expected INSTANCE element");  
   
             MessageLoaderParms mlParms(             MessageLoaderParms mlParms(
                 "Client.CIMOperationResponseDecoder.EXPECTED_INSTANCE_ELEMENT",                 "Client.CIMOperationResponseDecoder.EXPECTED_INSTANCE_ELEMENT",
                 "expected INSTANCE element");                 "expected INSTANCE element");
   
             throw XmlValidationError(parser.getLine(), mlParms);             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
  
         XmlReader::expectEndTag(parser, "IRETURNVALUE");         XmlReader::expectEndTag(parser, "IRETURNVALUE");
  
         return(new CIMGetInstanceResponseMessage(          return new CIMGetInstanceResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack(),             QueueIdStack(),
             cimInstance));              cimInstance);
     }     }
     else     else
     {     {
         // l10n          MessageLoaderParms mlParms(
               "Client.CIMOperationResponseDecoder."
         // throw XmlValidationError(parser.getLine(),                  "EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",
         //   "expected ERROR or IRETURNVALUE element");  
   
         MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",  
             "expected ERROR or IRETURNVALUE element");             "expected ERROR or IRETURNVALUE element");
   
         throw XmlValidationError(parser.getLine(), mlParms);         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
 CIMModifyInstanceResponseMessage* CIMOperationResponseDecoder::_decodeModifyInstanceResponse(  CIMModifyInstanceResponseMessage*
       CIMOperationResponseDecoder::_decodeModifyInstanceResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1145 
Line 1112 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMModifyInstanceResponseMessage(              return new CIMModifyInstanceResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack()));                  QueueIdStack());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1160 
Line 1127 
         }         }
     }     }
  
     return(new CIMModifyInstanceResponseMessage(      return new CIMModifyInstanceResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack()));          QueueIdStack());
 } }
  
 CIMEnumerateInstanceNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(  CIMEnumerateInstanceNamesResponseMessage*
       CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1179 
Line 1147 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMEnumerateInstanceNamesResponseMessage(              return new CIMEnumerateInstanceNamesResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMObjectPath>()));                  Array<CIMObjectPath>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1209 
Line 1177 
         }         }
     }     }
  
     return(new CIMEnumerateInstanceNamesResponseMessage(      return new CIMEnumerateInstanceNamesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         instanceNames));          instanceNames);
 } }
  
 CIMEnumerateInstancesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstancesResponse(  CIMEnumerateInstancesResponseMessage*
       CIMOperationResponseDecoder::_decodeEnumerateInstancesResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1229 
Line 1198 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMEnumerateInstancesResponseMessage(              return new CIMEnumerateInstancesResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMInstance>()));                  Array<CIMInstance>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1253 
Line 1222 
         }         }
     }     }
  
     return(new CIMEnumerateInstancesResponseMessage(      return new CIMEnumerateInstancesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         namedInstances));          namedInstances);
 } }
  
 CIMDeleteInstanceResponseMessage* CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(  CIMDeleteInstanceResponseMessage*
       CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1272 
Line 1242 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMDeleteInstanceResponseMessage(              return new CIMDeleteInstanceResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack()));                  QueueIdStack());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1287 
Line 1257 
         }         }
     }     }
  
     return(new CIMDeleteInstanceResponseMessage(      return new CIMDeleteInstanceResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack()));          QueueIdStack());
 } }
  
 CIMGetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeGetPropertyResponse(  CIMGetPropertyResponseMessage*
       CIMOperationResponseDecoder::_decodeGetPropertyResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1306 
Line 1277 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMGetPropertyResponseMessage(              return new CIMGetPropertyResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 CIMValue()));                  CIMValue());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1331 
Line 1302 
         }         }
     }     }
  
     return(new CIMGetPropertyResponseMessage(      return new CIMGetPropertyResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         cimValue));          cimValue);
 } }
  
 CIMSetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeSetPropertyResponse(  CIMSetPropertyResponseMessage*
       CIMOperationResponseDecoder::_decodeSetPropertyResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1350 
Line 1322 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMSetPropertyResponseMessage(              return new CIMSetPropertyResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack()));                  QueueIdStack());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1365 
Line 1337 
         }         }
     }     }
  
     return(new CIMSetPropertyResponseMessage(      return new CIMSetPropertyResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack()));          QueueIdStack());
 } }
  
 CIMSetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeSetQualifierResponse(  CIMSetQualifierResponseMessage*
       CIMOperationResponseDecoder::_decodeSetQualifierResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1383 
Line 1356 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMSetQualifierResponseMessage(              return new CIMSetQualifierResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack()));                  QueueIdStack());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1398 
Line 1371 
         }         }
     }     }
  
     return(new CIMSetQualifierResponseMessage(      return new CIMSetQualifierResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack()));          QueueIdStack());
 } }
  
 CIMGetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeGetQualifierResponse(  CIMGetQualifierResponseMessage*
       CIMOperationResponseDecoder::_decodeGetQualifierResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1420 
Line 1394 
     }     }
     else if (XmlReader::getErrorElement(parser, cimException))     else if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMGetQualifierResponseMessage(          return new CIMGetQualifierResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack(),             QueueIdStack(),
             CIMQualifierDecl()));              CIMQualifierDecl());
     }     }
     else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))     else if (XmlReader::testStartTag(parser, entry, "IRETURNVALUE"))
     {     {
Line 1433 
Line 1407 
  
         XmlReader::expectEndTag(parser, "IRETURNVALUE");         XmlReader::expectEndTag(parser, "IRETURNVALUE");
  
         return(new CIMGetQualifierResponseMessage(          return new CIMGetQualifierResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack(),             QueueIdStack(),
             qualifierDecl));              qualifierDecl);
     }     }
     else     else
     {     {
         // l10n          MessageLoaderParms mlParms(
               "Client.CIMOperationResponseDecoder."
         // throw XmlValidationError(parser.getLine(),                  "EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",
         //   "expected ERROR or IRETURNVALUE element");  
   
         MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_ERROR_OR_IRETURNVALUE_ELEMENT",  
         "expected ERROR or IRETURNVALUE element");         "expected ERROR or IRETURNVALUE element");
   
         throw XmlValidationError(parser.getLine(), mlParms);         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
 CIMEnumerateQualifiersResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(  CIMEnumerateQualifiersResponseMessage*
       CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1466 
Line 1437 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMEnumerateQualifiersResponseMessage(              return new CIMEnumerateQualifiersResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMQualifierDecl>()));                  Array<CIMQualifierDecl>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1490 
Line 1461 
         }         }
     }     }
  
     return(new CIMEnumerateQualifiersResponseMessage(      return new CIMEnumerateQualifiersResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         qualifierDecls));          qualifierDecls);
 } }
  
 CIMDeleteQualifierResponseMessage* CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(  CIMDeleteQualifierResponseMessage*
       CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1509 
Line 1481 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMDeleteQualifierResponseMessage(              return new CIMDeleteQualifierResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack()));                  QueueIdStack());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1524 
Line 1496 
         }         }
     }     }
  
     return(new CIMDeleteQualifierResponseMessage(      return new CIMDeleteQualifierResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack()));          QueueIdStack());
 } }
  
 CIMReferenceNamesResponseMessage* CIMOperationResponseDecoder::_decodeReferenceNamesResponse(  CIMReferenceNamesResponseMessage*
       CIMOperationResponseDecoder::_decodeReferenceNamesResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1543 
Line 1516 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMReferenceNamesResponseMessage(              return new CIMReferenceNamesResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMObjectPath>()));                  Array<CIMObjectPath>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1564 
Line 1537 
         }         }
     }     }
  
     return(new CIMReferenceNamesResponseMessage(      return new CIMReferenceNamesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         objectPaths));          objectPaths);
 } }
  
 CIMReferencesResponseMessage* CIMOperationResponseDecoder::_decodeReferencesResponse(  CIMReferencesResponseMessage*
       CIMOperationResponseDecoder::_decodeReferencesResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1584 
Line 1558 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMReferencesResponseMessage(              return new CIMReferencesResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMObject>()));                  Array<CIMObject>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1608 
Line 1582 
         }         }
     }     }
  
     return(new CIMReferencesResponseMessage(      return new CIMReferencesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         objectWithPathArray));          objectWithPathArray);
 } }
  
 CIMAssociatorNamesResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(  CIMAssociatorNamesResponseMessage*
       CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1628 
Line 1603 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMAssociatorNamesResponseMessage(              return new CIMAssociatorNamesResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMObjectPath>()));                  Array<CIMObjectPath>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1649 
Line 1624 
         }         }
     }     }
  
     return(new CIMAssociatorNamesResponseMessage(      return new CIMAssociatorNamesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         objectPaths));          objectPaths);
 } }
  
 CIMAssociatorsResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorsResponse(  CIMAssociatorsResponseMessage*
       CIMOperationResponseDecoder::_decodeAssociatorsResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1669 
Line 1645 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMAssociatorsResponseMessage(              return new CIMAssociatorsResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMObject>()));                  Array<CIMObject>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1693 
Line 1669 
         }         }
     }     }
  
     return(new CIMAssociatorsResponseMessage(      return new CIMAssociatorsResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         objectWithPathArray));          objectWithPathArray);
 } }
  
 CIMExecQueryResponseMessage* CIMOperationResponseDecoder::_decodeExecQueryResponse(  CIMExecQueryResponseMessage*
       CIMOperationResponseDecoder::_decodeExecQueryResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     Boolean isEmptyImethodresponseTag)     Boolean isEmptyImethodresponseTag)
Line 1713 
Line 1690 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMExecQueryResponseMessage(              return new CIMExecQueryResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 Array<CIMObject>()));                  Array<CIMObject>());
         }         }
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
Line 1731 
Line 1708 
         }         }
     }     }
  
     return(new CIMExecQueryResponseMessage(      return new CIMExecQueryResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         objectWithPathArray));          objectWithPathArray);
 } }
  
 CIMInvokeMethodResponseMessage* CIMOperationResponseDecoder::_decodeInvokeMethodResponse(  CIMInvokeMethodResponseMessage*
       CIMOperationResponseDecoder::_decodeInvokeMethodResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId,     const String& messageId,
     const String& methodName,     const String& methodName,
Line 1754 
Line 1732 
     {     {
         if (XmlReader::getErrorElement(parser, cimException))         if (XmlReader::getErrorElement(parser, cimException))
         {         {
             return(new CIMInvokeMethodResponseMessage(              return new CIMInvokeMethodResponseMessage(
                 messageId,                 messageId,
                 cimException,                 cimException,
                 QueueIdStack(),                 QueueIdStack(),
                 returnValue,                 returnValue,
                 outParameters,                 outParameters,
                 methodName));                  methodName);
         }         }
  
         Boolean isReturnValue = false;         Boolean isReturnValue = false;
Line 1776 
Line 1754 
             {             {
                 if (gotReturnValue)                 if (gotReturnValue)
                 {                 {
                     // l10n                      MessageLoaderParms mlParms(
                           "Client.CIMOperationResponseDecoder."
                     // throw XmlValidationError(parser.getLine(),                              "EXPECTED_RETURNVALUE_ELEMENT",
                     //   "unexpected RETURNVALUE element");  
   
                     MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_RETURNVALUE_ELEMENT",  
                         "unexpected RETURNVALUE element");                         "unexpected RETURNVALUE element");
   
                     throw XmlValidationError(parser.getLine(), mlParms);                     throw XmlValidationError(parser.getLine(), mlParms);
                 }                 }
                 gotReturnValue = true;                 gotReturnValue = true;
Line 1798 
Line 1772 
         }         }
     }     }
  
     return(new CIMInvokeMethodResponseMessage(      return new CIMInvokeMethodResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),         QueueIdStack(),
         returnValue,         returnValue,
         outParameters,         outParameters,
         methodName));          methodName);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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