(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.59 and 1.60

version 1.59, 2004/07/20 13:24:26 version 1.60, 2004/07/22 20:08:40
Line 93 
Line 93 
     {     {
         case HTTP_MESSAGE:         case HTTP_MESSAGE:
         {         {
   
             HTTPMessage* httpMessage = (HTTPMessage*)message;             HTTPMessage* httpMessage = (HTTPMessage*)message;
             _handleHTTPMessage(httpMessage);             _handleHTTPMessage(httpMessage);
             break;             break;
Line 120 
Line 119 
  
     if (httpMessage->message.size() == 0)     if (httpMessage->message.size() == 0)
       {       {
   
         // l10n         // l10n
  
         // CIMClientMalformedHTTPException* malformedHTTPException =         // CIMClientMalformedHTTPException* malformedHTTPException =
Line 152 
Line 150 
         startLine, httpVersion, statusCode, reasonPhrase);         startLine, httpVersion, statusCode, reasonPhrase);
     if (!parsableMessage)     if (!parsableMessage)
     {     {
   
       // l10n       // l10n
  
       // CIMClientMalformedHTTPException* malformedHTTPException = new       // CIMClientMalformedHTTPException* malformedHTTPException = new
Line 310 
Line 307 
    }    }
    catch (Exception &)    catch (Exception &)
    {    {
   
      // l10n      // l10n
  
      // CIMClientMalformedHTTPException* malformedHTTPException = new      // CIMClientMalformedHTTPException* malformedHTTPException = new
Line 332 
Line 328 
     //     //
     // Search for "Content-Type" header:     // Search for "Content-Type" header:
     //     //
   
    // BUG 572, Use of Content-Type header and change error msg.    // BUG 572, Use of Content-Type header and change error msg.
    // If header exists, test type.  If not, ignore. We will find    // If header exists, test type.  If not, ignore. We will find
    // content type errors in text analysis.    // content type errors in text analysis.
Line 376 
Line 373 
  
                 _outputQueue->enqueue(response);                 _outputQueue->enqueue(response);
                 return;                 return;
   
    }    }
 #endif #endif
  
Line 434 
Line 430 
  
     if (!String::equalNoCase(cimOperation, "MethodResponse"))     if (!String::equalNoCase(cimOperation, "MethodResponse"))
     {     {
   
       // l10n       // l10n
  
       // CIMClientMalformedHTTPException* malformedHTTPException =       // CIMClientMalformedHTTPException* malformedHTTPException =
Line 442 
Line 437 
       //        String("Received CIMOperation HTTP header value \"") +       //        String("Received CIMOperation HTTP header value \"") +
       //        cimOperation + "\", expected \"MethodResponse\"");       //        cimOperation + "\", expected \"MethodResponse\"");
  
   
       MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_METHODRESPONSE", "Received CIMOperation HTTP header value \"$1\", expected \"MethodResponse\"", cimOperation);       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));
  
Line 500 
Line 494 
         String messageId;         String messageId;
         String protocolVersion;         String protocolVersion;
  
         if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion)) {          if (!XmlReader::getMessageStartTag(parser, messageId, protocolVersion))
           {
           // l10n           // l10n
  
           // throw XmlValidationError(           // throw XmlValidationError(
Line 513 
Line 507 
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
         }         }
  
   
         if (!String::equalNoCase(protocolVersion, "1.0"))         if (!String::equalNoCase(protocolVersion, "1.0"))
         {         {
   
           // l10n           // l10n
  
           // CIMClientResponseException* responseException =           // CIMClientResponseException* responseException =
Line 548 
Line 540 
         //         //
  
         const char* iMethodResponseName = 0;         const char* iMethodResponseName = 0;
           Boolean isEmptyTag = false;
  
         if (XmlReader::getIMethodResponseStartTag(parser, iMethodResponseName))          if (XmlReader::getIMethodResponseStartTag(
                   parser, iMethodResponseName, isEmptyTag))
         {         {
             //             //
             // Dispatch the method:             // Dispatch the method:
             //             //
  
             if (System::strcasecmp(iMethodResponseName, "GetClass") == 0)             if (System::strcasecmp(iMethodResponseName, "GetClass") == 0)
                 response = _decodeGetClassResponse(parser, messageId);                  response = _decodeGetClassResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "GetInstance") == 0)             else if (System::strcasecmp(iMethodResponseName, "GetInstance") == 0)
                 response = _decodeGetInstanceResponse(parser, messageId);                  response = _decodeGetInstanceResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "EnumerateClassNames") == 0)             else if (System::strcasecmp(iMethodResponseName, "EnumerateClassNames") == 0)
                 response = _decodeEnumerateClassNamesResponse(parser,messageId);                  response = _decodeEnumerateClassNamesResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "References") == 0)             else if (System::strcasecmp(iMethodResponseName, "References") == 0)
                 response = _decodeReferencesResponse(parser, messageId);                  response = _decodeReferencesResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "ReferenceNames") == 0)             else if (System::strcasecmp(iMethodResponseName, "ReferenceNames") == 0)
                 response = _decodeReferenceNamesResponse(parser, messageId);                  response = _decodeReferenceNamesResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "AssociatorNames") == 0)             else if (System::strcasecmp(iMethodResponseName, "AssociatorNames") == 0)
                 response = _decodeAssociatorNamesResponse(parser, messageId);                  response = _decodeAssociatorNamesResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "Associators") == 0)             else if (System::strcasecmp(iMethodResponseName, "Associators") == 0)
                 response = _decodeAssociatorsResponse(parser, messageId);                  response = _decodeAssociatorsResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "CreateInstance") == 0)             else if (System::strcasecmp(iMethodResponseName, "CreateInstance") == 0)
                 response = _decodeCreateInstanceResponse(parser, messageId);                  response = _decodeCreateInstanceResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName,"EnumerateInstanceNames") == 0)             else if (System::strcasecmp(iMethodResponseName,"EnumerateInstanceNames") == 0)
                 response = _decodeEnumerateInstanceNamesResponse(                 response = _decodeEnumerateInstanceNamesResponse(
                   parser, messageId);                      parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName,"EnumerateInstances") == 0)             else if (System::strcasecmp(iMethodResponseName,"EnumerateInstances") == 0)
                 response = _decodeEnumerateInstancesResponse(parser, messageId);                  response = _decodeEnumerateInstancesResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "GetProperty") == 0)             else if (System::strcasecmp(iMethodResponseName, "GetProperty") == 0)
                 response = _decodeGetPropertyResponse(parser, messageId);                  response = _decodeGetPropertyResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "SetProperty") == 0)             else if (System::strcasecmp(iMethodResponseName, "SetProperty") == 0)
                 response = _decodeSetPropertyResponse(parser, messageId);                  response = _decodeSetPropertyResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "DeleteQualifier") == 0)             else if (System::strcasecmp(iMethodResponseName, "DeleteQualifier") == 0)
                 response = _decodeDeleteQualifierResponse(parser, messageId);                  response = _decodeDeleteQualifierResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "GetQualifier") == 0)             else if (System::strcasecmp(iMethodResponseName, "GetQualifier") == 0)
                 response = _decodeGetQualifierResponse(parser, messageId);                  response = _decodeGetQualifierResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "SetQualifier") == 0)             else if (System::strcasecmp(iMethodResponseName, "SetQualifier") == 0)
                 response = _decodeSetQualifierResponse(parser, messageId);                  response = _decodeSetQualifierResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "EnumerateQualifiers") == 0)             else if (System::strcasecmp(iMethodResponseName, "EnumerateQualifiers") == 0)
                 response = _decodeEnumerateQualifiersResponse(parser,messageId);                  response = _decodeEnumerateQualifiersResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "EnumerateClasses") == 0)             else if (System::strcasecmp(iMethodResponseName, "EnumerateClasses") == 0)
                 response = _decodeEnumerateClassesResponse(parser, messageId);                  response = _decodeEnumerateClassesResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "CreateClass") == 0)             else if (System::strcasecmp(iMethodResponseName, "CreateClass") == 0)
                 response = _decodeCreateClassResponse(parser, messageId);                  response = _decodeCreateClassResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "ModifyClass") == 0)             else if (System::strcasecmp(iMethodResponseName, "ModifyClass") == 0)
                 response = _decodeModifyClassResponse(parser, messageId);                  response = _decodeModifyClassResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "ModifyInstance") == 0)             else if (System::strcasecmp(iMethodResponseName, "ModifyInstance") == 0)
                 response = _decodeModifyInstanceResponse(parser, messageId);                  response = _decodeModifyInstanceResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "DeleteClass") == 0)             else if (System::strcasecmp(iMethodResponseName, "DeleteClass") == 0)
                 response = _decodeDeleteClassResponse(parser, messageId);                  response = _decodeDeleteClassResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "DeleteInstance") == 0)             else if (System::strcasecmp(iMethodResponseName, "DeleteInstance") == 0)
                 response = _decodeDeleteInstanceResponse(parser, messageId);                  response = _decodeDeleteInstanceResponse(
                       parser, messageId, isEmptyTag);
             else if (System::strcasecmp(iMethodResponseName, "ExecQuery") == 0)             else if (System::strcasecmp(iMethodResponseName, "ExecQuery") == 0)
                 response = _decodeExecQueryResponse(parser, messageId);                  response = _decodeExecQueryResponse(
                       parser, messageId, isEmptyTag);
             else             else
             {             {
   
               // l10n               // l10n
  
                 // Unrecognized IMethodResponse name attribute                 // Unrecognized IMethodResponse name attribute
Line 612 
Line 627 
               //   String("Unrecognized IMethodResponse name \"") +               //   String("Unrecognized IMethodResponse name \"") +
               //        iMethodResponseName + "\"");               //        iMethodResponseName + "\"");
  
               MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.UNRECOGNIZED_NAME",                  MessageLoaderParms mlParms(
                       "Client.CIMOperationResponseDecoder.UNRECOGNIZED_NAME",
                                          "Unrecognized IMethodResponse name \"$0\"",                                          "Unrecognized IMethodResponse name \"$0\"",
                                          iMethodResponseName);                                          iMethodResponseName);
   
               throw XmlValidationError(parser.getLine(), mlParms);               throw XmlValidationError(parser.getLine(), mlParms);
             }             }
  
Line 623 
Line 638 
             // Handle end tag:             // Handle end tag:
             //             //
  
               if (!isEmptyTag)
               {
             XmlReader::expectEndTag(parser, "IMETHODRESPONSE");             XmlReader::expectEndTag(parser, "IMETHODRESPONSE");
         }         }
         else if (XmlReader::getMethodResponseStartTag(parser,          }
             iMethodResponseName))          else if (XmlReader::getMethodResponseStartTag(
                        parser, iMethodResponseName, isEmptyTag))
         {         {
             response = _decodeInvokeMethodResponse(             response = _decodeInvokeMethodResponse(
               parser, messageId, iMethodResponseName);                  parser, messageId, iMethodResponseName, isEmptyTag);
  
             //             //
             // Handle end tag:             // Handle end tag:
             //             //
               if (!isEmptyTag)
               {
             XmlReader::expectEndTag(parser, "METHODRESPONSE");             XmlReader::expectEndTag(parser, "METHODRESPONSE");
         }         }
           }
         else         else
         {         {
           // l10n           // l10n
Line 701 
Line 722 
         }         }
 // l10n end // l10n end
  
   
     _outputQueue->enqueue(response);     _outputQueue->enqueue(response);
 } }
  
 CIMCreateClassResponseMessage* CIMOperationResponseDecoder::_decodeCreateClassResponse( CIMCreateClassResponseMessage* CIMOperationResponseDecoder::_decodeCreateClassResponse(
     XmlParser& parser,     XmlParser& parser,
     const String& messageId)      const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMCreateClassResponseMessage(         return(new CIMCreateClassResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
   
     }     }
     else  
     {  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
             if (entry.type != XmlEntry::EMPTY_TAG)             if (entry.type != XmlEntry::EMPTY_TAG)
Line 729 
Line 750 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMCreateClassResponseMessage(         return(new CIMCreateClassResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
 }  
  
 CIMGetClassResponseMessage* CIMOperationResponseDecoder::_decodeGetClassResponse( CIMGetClassResponseMessage* CIMOperationResponseDecoder::_decodeGetClassResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
     if (XmlReader::getErrorElement(parser, cimException))      if (isEmptyImethodresponseTag)
       {
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
               "Expected open of $0 element", "IMETHODRESPONSE");
           throw XmlValidationError(parser.getLine(), mlParms);
       }
       else if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMGetClassResponseMessage(         return(new CIMGetClassResponseMessage(
             messageId,             messageId,
Line 758 
Line 787 
         if ((entry.type == XmlEntry::EMPTY_TAG) ||         if ((entry.type == XmlEntry::EMPTY_TAG) ||
             !XmlReader::getClassElement(parser, cimClass))             !XmlReader::getClassElement(parser, cimClass))
         {         {
   
           // l10n           // l10n
  
           // throw XmlValidationError(parser.getLine(),"expected CLASS element");           // throw XmlValidationError(parser.getLine(),"expected CLASS element");
  
           MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_CLASS_ELEMENT",              MessageLoaderParms mlParms(
                   "Client.CIMOperationResponseDecoder.EXPECTED_CLASS_ELEMENT",
                                      "expected CLASS element");                                      "expected CLASS element");
   
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
         }         }
  
Line 779 
Line 807 
     }     }
     else     else
     {     {
   
       // l10n       // l10n
  
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
Line 793 
Line 820 
 } }
  
 CIMModifyClassResponseMessage* CIMOperationResponseDecoder::_decodeModifyClassResponse( CIMModifyClassResponseMessage* CIMOperationResponseDecoder::_decodeModifyClassResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMModifyClassResponseMessage(         return(new CIMModifyClassResponseMessage(
Line 805 
Line 836 
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
     else  
     {  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
             if (entry.type != XmlEntry::EMPTY_TAG)             if (entry.type != XmlEntry::EMPTY_TAG)
Line 814 
Line 844 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMModifyClassResponseMessage(         return(new CIMModifyClassResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
 }  
  
 CIMEnumerateClassNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse( CIMEnumerateClassNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassNamesResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMName> classNames;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMEnumerateClassNamesResponseMessage(         return(new CIMEnumerateClassNamesResponseMessage(
Line 836 
Line 871 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMName>()));             Array<CIMName>()));
     }     }
     else  
     {  
         Array<CIMName> classNames;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 852 
Line 884 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMEnumerateClassNamesResponseMessage(         return(new CIMEnumerateClassNamesResponseMessage(
             messageId,             messageId,
Line 859 
Line 892 
             QueueIdStack(),             QueueIdStack(),
             classNames));             classNames));
     }     }
 }  
  
 CIMEnumerateClassesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassesResponse( CIMEnumerateClassesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateClassesResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMClass> cimClasses;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMEnumerateClassesResponseMessage(         return(new CIMEnumerateClassesResponseMessage(
Line 875 
Line 912 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMClass>()));             Array<CIMClass>()));
     }     }
     else  
     {  
         Array<CIMClass> cimClasses;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 891 
Line 925 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMEnumerateClassesResponseMessage(         return(new CIMEnumerateClassesResponseMessage(
             messageId,             messageId,
Line 898 
Line 933 
             QueueIdStack(),             QueueIdStack(),
             cimClasses));             cimClasses));
     }     }
 }  
  
 CIMDeleteClassResponseMessage* CIMOperationResponseDecoder::_decodeDeleteClassResponse( CIMDeleteClassResponseMessage* CIMOperationResponseDecoder::_decodeDeleteClassResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMDeleteClassResponseMessage(         return(new CIMDeleteClassResponseMessage(
Line 913 
Line 951 
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
     else  
     {  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
             if (entry.type != XmlEntry::EMPTY_TAG)             if (entry.type != XmlEntry::EMPTY_TAG)
Line 922 
Line 959 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMDeleteClassResponseMessage(         return(new CIMDeleteClassResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
 }  
  
 CIMCreateInstanceResponseMessage* CIMOperationResponseDecoder::_decodeCreateInstanceResponse( CIMCreateInstanceResponseMessage* CIMOperationResponseDecoder::_decodeCreateInstanceResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
     if (XmlReader::getErrorElement(parser, cimException))      if (isEmptyImethodresponseTag)
       {
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
               "Expected open of $0 element", "IMETHODRESPONSE");
           throw XmlValidationError(parser.getLine(), mlParms);
       }
       else if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMCreateInstanceResponseMessage(         return(new CIMCreateInstanceResponseMessage(
             messageId,             messageId,
Line 959 
Line 1004 
     }     }
     else     else
     {     {
   
       // l10n       // l10n
  
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
Line 973 
Line 1017 
 } }
  
 CIMGetInstanceResponseMessage* CIMOperationResponseDecoder::_decodeGetInstanceResponse( CIMGetInstanceResponseMessage* CIMOperationResponseDecoder::_decodeGetInstanceResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
     if (XmlReader::getErrorElement(parser, cimException))      if (isEmptyImethodresponseTag)
       {
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
               "Expected open of $0 element", "IMETHODRESPONSE");
           throw XmlValidationError(parser.getLine(), mlParms);
       }
       else if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMGetInstanceResponseMessage(         return(new CIMGetInstanceResponseMessage(
             messageId,             messageId,
Line 993 
Line 1045 
         if ((entry.type == XmlEntry::EMPTY_TAG) ||         if ((entry.type == XmlEntry::EMPTY_TAG) ||
             !XmlReader::getInstanceElement(parser, cimInstance))             !XmlReader::getInstanceElement(parser, cimInstance))
         {         {
   
           // l10n           // l10n
  
           // throw XmlValidationError(           // throw XmlValidationError(
           // parser.getLine(), "expected INSTANCE element");           // parser.getLine(), "expected INSTANCE element");
  
           MessageLoaderParms mlParms("Client.CIMOperationResponseDecoder.EXPECTED_INSTANCE_ELEMENT",              MessageLoaderParms mlParms(
                   "Client.CIMOperationResponseDecoder.EXPECTED_INSTANCE_ELEMENT",
                                      "expected INSTANCE element");                                      "expected INSTANCE element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
Line 1015 
Line 1067 
     }     }
     else     else
     {     {
   
       // l10n       // l10n
  
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
Line 1029 
Line 1080 
 } }
  
 CIMModifyInstanceResponseMessage* CIMOperationResponseDecoder::_decodeModifyInstanceResponse( CIMModifyInstanceResponseMessage* CIMOperationResponseDecoder::_decodeModifyInstanceResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMModifyInstanceResponseMessage(         return(new CIMModifyInstanceResponseMessage(
Line 1041 
Line 1096 
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
     else  
     {  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
             if (entry.type != XmlEntry::EMPTY_TAG)             if (entry.type != XmlEntry::EMPTY_TAG)
Line 1050 
Line 1104 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMModifyInstanceResponseMessage(         return(new CIMModifyInstanceResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
 }  
  
 CIMEnumerateInstanceNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse( CIMEnumerateInstanceNamesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstanceNamesResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMObjectPath> instanceNames;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMEnumerateInstanceNamesResponseMessage(         return(new CIMEnumerateInstanceNamesResponseMessage(
Line 1072 
Line 1131 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMObjectPath>()));             Array<CIMObjectPath>()));
     }     }
     else  
     {  
         Array<CIMObjectPath> instanceNames;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 1097 
Line 1153 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMEnumerateInstanceNamesResponseMessage(         return(new CIMEnumerateInstanceNamesResponseMessage(
             messageId,             messageId,
Line 1104 
Line 1161 
             QueueIdStack(),             QueueIdStack(),
             instanceNames));             instanceNames));
     }     }
 }  
  
 CIMEnumerateInstancesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstancesResponse( CIMEnumerateInstancesResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateInstancesResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMInstance> namedInstances;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMEnumerateInstancesResponseMessage(         return(new CIMEnumerateInstancesResponseMessage(
Line 1120 
Line 1181 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMInstance>()));             Array<CIMInstance>()));
     }     }
     else  
     {  
         Array<CIMInstance> namedInstances;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 1139 
Line 1197 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMEnumerateInstancesResponseMessage(         return(new CIMEnumerateInstancesResponseMessage(
             messageId,             messageId,
Line 1146 
Line 1205 
             QueueIdStack(),             QueueIdStack(),
             namedInstances));             namedInstances));
     }     }
 }  
  
 CIMDeleteInstanceResponseMessage* CIMOperationResponseDecoder::_decodeDeleteInstanceResponse( CIMDeleteInstanceResponseMessage* CIMOperationResponseDecoder::_decodeDeleteInstanceResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMDeleteInstanceResponseMessage(         return(new CIMDeleteInstanceResponseMessage(
Line 1161 
Line 1223 
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
     else  
     {  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
             if (entry.type != XmlEntry::EMPTY_TAG)             if (entry.type != XmlEntry::EMPTY_TAG)
Line 1170 
Line 1231 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMDeleteInstanceResponseMessage(         return(new CIMDeleteInstanceResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
 }  
  
 CIMGetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeGetPropertyResponse( CIMGetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeGetPropertyResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       CIMValue cimValue(CIMTYPE_STRING, false);
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMGetPropertyResponseMessage(         return(new CIMGetPropertyResponseMessage(
Line 1192 
Line 1258 
             QueueIdStack(),             QueueIdStack(),
             CIMValue()));             CIMValue()));
     }     }
     else  
     {  
         CIMValue cimValue(CIMTYPE_STRING, false);  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 1212 
Line 1275 
         {         {
             // No value given; just return a null String value             // No value given; just return a null String value
         }         }
       }
  
         return(new CIMGetPropertyResponseMessage(         return(new CIMGetPropertyResponseMessage(
             messageId,             messageId,
Line 1219 
Line 1283 
             QueueIdStack(),             QueueIdStack(),
             cimValue));             cimValue));
     }     }
 }  
  
 CIMSetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeSetPropertyResponse( CIMSetPropertyResponseMessage* CIMOperationResponseDecoder::_decodeSetPropertyResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMSetPropertyResponseMessage(         return(new CIMSetPropertyResponseMessage(
Line 1234 
Line 1301 
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
     else  
     {  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
             if (entry.type != XmlEntry::EMPTY_TAG)             if (entry.type != XmlEntry::EMPTY_TAG)
Line 1243 
Line 1309 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMSetPropertyResponseMessage(         return(new CIMSetPropertyResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
 }  
  
 CIMSetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeSetQualifierResponse( CIMSetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeSetQualifierResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMSetQualifierResponseMessage(         return(new CIMSetQualifierResponseMessage(
Line 1264 
Line 1334 
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
     else  
     {  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
             if (entry.type != XmlEntry::EMPTY_TAG)             if (entry.type != XmlEntry::EMPTY_TAG)
Line 1273 
Line 1342 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMSetQualifierResponseMessage(         return(new CIMSetQualifierResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
 }  
  
 CIMGetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeGetQualifierResponse( CIMGetQualifierResponseMessage* CIMOperationResponseDecoder::_decodeGetQualifierResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
     if (XmlReader::getErrorElement(parser, cimException))      if (isEmptyImethodresponseTag)
       {
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
               "Expected open of $0 element", "IMETHODRESPONSE");
           throw XmlValidationError(parser.getLine(), mlParms);
       }
       else if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMGetQualifierResponseMessage(         return(new CIMGetQualifierResponseMessage(
             messageId,             messageId,
Line 1310 
Line 1387 
     }     }
     else     else
     {     {
   
       // l10n       // l10n
  
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
Line 1324 
Line 1400 
 } }
  
 CIMEnumerateQualifiersResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse( CIMEnumerateQualifiersResponseMessage* CIMOperationResponseDecoder::_decodeEnumerateQualifiersResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMQualifierDecl> qualifierDecls;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMEnumerateQualifiersResponseMessage(         return(new CIMEnumerateQualifiersResponseMessage(
Line 1337 
Line 1418 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMQualifierDecl>()));             Array<CIMQualifierDecl>()));
     }     }
     else  
     {  
         Array<CIMQualifierDecl> qualifierDecls;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 1356 
Line 1434 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMEnumerateQualifiersResponseMessage(         return(new CIMEnumerateQualifiersResponseMessage(
             messageId,             messageId,
Line 1363 
Line 1442 
             QueueIdStack(),             QueueIdStack(),
             qualifierDecls));             qualifierDecls));
     }     }
 }  
  
 CIMDeleteQualifierResponseMessage* CIMOperationResponseDecoder::_decodeDeleteQualifierResponse( CIMDeleteQualifierResponseMessage* CIMOperationResponseDecoder::_decodeDeleteQualifierResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMDeleteQualifierResponseMessage(         return(new CIMDeleteQualifierResponseMessage(
Line 1378 
Line 1460 
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
     else  
     {  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
             if (entry.type != XmlEntry::EMPTY_TAG)             if (entry.type != XmlEntry::EMPTY_TAG)
Line 1387 
Line 1468 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMDeleteQualifierResponseMessage(         return(new CIMDeleteQualifierResponseMessage(
             messageId,             messageId,
             cimException,             cimException,
             QueueIdStack()));             QueueIdStack()));
     }     }
 }  
   
 //MEB:  
  
 CIMReferenceNamesResponseMessage* CIMOperationResponseDecoder::_decodeReferenceNamesResponse( CIMReferenceNamesResponseMessage* CIMOperationResponseDecoder::_decodeReferenceNamesResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMObjectPath> objectPaths;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMReferenceNamesResponseMessage(         return(new CIMReferenceNamesResponseMessage(
Line 1411 
Line 1495 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMObjectPath>()));             Array<CIMObjectPath>()));
     }     }
     else  
     {  
         Array<CIMObjectPath> objectPaths;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 1427 
Line 1508 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMReferenceNamesResponseMessage(         return(new CIMReferenceNamesResponseMessage(
             messageId,             messageId,
Line 1434 
Line 1516 
             QueueIdStack(),             QueueIdStack(),
             objectPaths));             objectPaths));
     }     }
 }  
  
 CIMReferencesResponseMessage* CIMOperationResponseDecoder::_decodeReferencesResponse( CIMReferencesResponseMessage* CIMOperationResponseDecoder::_decodeReferencesResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMObject> objectWithPathArray;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMReferencesResponseMessage(         return(new CIMReferencesResponseMessage(
Line 1450 
Line 1536 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMObject>()));             Array<CIMObject>()));
     }     }
     else  
     {  
         Array<CIMObject> objectWithPathArray;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 1469 
Line 1552 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMReferencesResponseMessage(         return(new CIMReferencesResponseMessage(
             messageId,             messageId,
Line 1476 
Line 1560 
             QueueIdStack(),             QueueIdStack(),
             objectWithPathArray));             objectWithPathArray));
     }     }
 }  
  
 CIMAssociatorNamesResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorNamesResponse( CIMAssociatorNamesResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorNamesResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMObjectPath> objectPaths;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMAssociatorNamesResponseMessage(         return(new CIMAssociatorNamesResponseMessage(
Line 1492 
Line 1580 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMObjectPath>()));             Array<CIMObjectPath>()));
     }     }
     else  
     {  
         Array<CIMObjectPath> objectPaths;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 1508 
Line 1593 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMAssociatorNamesResponseMessage(         return(new CIMAssociatorNamesResponseMessage(
             messageId,             messageId,
Line 1515 
Line 1601 
             QueueIdStack(),             QueueIdStack(),
             objectPaths));             objectPaths));
     }     }
 }  
  
 CIMAssociatorsResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorsResponse( CIMAssociatorsResponseMessage* CIMOperationResponseDecoder::_decodeAssociatorsResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMObject> objectWithPathArray;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMAssociatorsResponseMessage(         return(new CIMAssociatorsResponseMessage(
Line 1531 
Line 1621 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMObject>()));             Array<CIMObject>()));
     }     }
     else  
     {  
         Array<CIMObject> objectWithPathArray;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 1550 
Line 1637 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMAssociatorsResponseMessage(         return(new CIMAssociatorsResponseMessage(
             messageId,             messageId,
Line 1557 
Line 1645 
             QueueIdStack(),             QueueIdStack(),
             objectWithPathArray));             objectWithPathArray));
     }     }
 }  
  
 CIMExecQueryResponseMessage* CIMOperationResponseDecoder::_decodeExecQueryResponse( CIMExecQueryResponseMessage* CIMOperationResponseDecoder::_decodeExecQueryResponse(
     XmlParser& parser, const String& messageId)      XmlParser& parser,
       const String& messageId,
       Boolean isEmptyImethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
       Array<CIMObject> objectWithPathArray;
  
       if (!isEmptyImethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMExecQueryResponseMessage(         return(new CIMExecQueryResponseMessage(
Line 1573 
Line 1665 
             QueueIdStack(),             QueueIdStack(),
             Array<CIMObject>()));             Array<CIMObject>()));
     }     }
     else  
     {  
         Array<CIMObject> objectWithPathArray;  
  
         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))         if (XmlReader::testStartTagOrEmptyTag(parser, entry, "IRETURNVALUE"))
         {         {
Line 1586 
Line 1675 
                 XmlReader::expectEndTag(parser, "IRETURNVALUE");                 XmlReader::expectEndTag(parser, "IRETURNVALUE");
             }             }
         }         }
       }
  
         return(new CIMExecQueryResponseMessage(         return(new CIMExecQueryResponseMessage(
             messageId,             messageId,
Line 1593 
Line 1683 
             QueueIdStack(),             QueueIdStack(),
             objectWithPathArray));             objectWithPathArray));
     }     }
 }  
  
 CIMInvokeMethodResponseMessage* CIMOperationResponseDecoder::_decodeInvokeMethodResponse( CIMInvokeMethodResponseMessage* CIMOperationResponseDecoder::_decodeInvokeMethodResponse(
     XmlParser& parser, const String& messageId, const String& methodName)      XmlParser& parser,
       const String& messageId,
       const String& methodName,
       Boolean isEmptyMethodresponseTag)
 { {
     XmlEntry entry;     XmlEntry entry;
     CIMException cimException;     CIMException cimException;
Line 1604 
Line 1696 
     CIMParamValue paramValue;     CIMParamValue paramValue;
     Array<CIMParamValue> outParameters;     Array<CIMParamValue> outParameters;
     CIMValue returnValue;     CIMValue returnValue;
     const char* paramName;  
     String inValue;  
  
       if (!isEmptyMethodresponseTag)
       {
     if (XmlReader::getErrorElement(parser, cimException))     if (XmlReader::getErrorElement(parser, cimException))
     {     {
         return(new CIMInvokeMethodResponseMessage(         return(new CIMInvokeMethodResponseMessage(
Line 1617 
Line 1709 
             outParameters,             outParameters,
             methodName));             methodName));
     }     }
     else  
     {  
         Boolean isReturnValue = false;         Boolean isReturnValue = false;
         Boolean isParamValue = false;         Boolean isParamValue = false;
         Boolean gotReturnValue = false;         Boolean gotReturnValue = false;
Line 1632 
Line 1723 
             {             {
                 if (gotReturnValue)                 if (gotReturnValue)
                 {                 {
   
                   // l10n                   // l10n
  
                   // throw XmlValidationError(parser.getLine(),                   // throw XmlValidationError(parser.getLine(),
Line 1653 
Line 1743 
             isReturnValue = false;             isReturnValue = false;
             isParamValue = false;             isParamValue = false;
         }         }
       }
  
         return(new CIMInvokeMethodResponseMessage(         return(new CIMInvokeMethodResponseMessage(
             messageId,             messageId,
Line 1662 
Line 1753 
             outParameters,             outParameters,
             methodName));             methodName));
     }     }
 }  
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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