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

Diff for /pegasus/src/Pegasus/Common/BinaryCodec.cpp between version 1.3 and 1.11

version 1.3, 2008/12/01 17:49:47 version 1.11, 2010/02/17 11:28:21
Line 94 
Line 94 
     OP_Count     OP_Count
 }; };
  
 struct CIMBufferReleaser  
 {  
     CIMBufferReleaser(CIMBuffer& buf) : _buf(buf)  
     {  
     }  
   
     ~CIMBufferReleaser()  
     {  
         _buf.release();  
     }  
   
 private:  
     CIMBuffer& _buf;  
 };  
   
 static Operation _NameToOp(const CIMName& name) static Operation _NameToOp(const CIMName& name)
 { {
     const String& s = name.getString();     const String& s = name.getString();
Line 278 
Line 263 
  
     Uint32 flags = 0;     Uint32 flags = 0;
  
     if (msg->localOnly)  
         flags |= LOCAL_ONLY;  
   
     if (msg->deepInheritance)     if (msg->deepInheritance)
         flags |= DEEP_INHERITANCE;         flags |= DEEP_INHERITANCE;
  
Line 341 
Line 323 
             nameSpace,             nameSpace,
             className,             className,
             deepInheritance,             deepInheritance,
             false,    // Bug 1985 localOnly is deprecated  
 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
             false,             false,
 #else #else
Line 360 
Line 341 
  
 static void _encodeEnumerateInstancesResponseBody( static void _encodeEnumerateInstancesResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMEnumerateInstancesResponseMessage* msg,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 368 
Line 349 
     static const CIMName NAME("EnumerateInstances");     static const CIMName NAME("EnumerateInstances");
     name = NAME;     name = NAME;
  
     if (msg->resolveCallback && msg->binaryEncoding)      data.encodeBinaryResponse(out);
     {  
         const Array<Uint8>& data = msg->binaryData;  
         out.putBytes((char*)data.getData(), data.size());  
     }  
     else  
     {  
         out.putInstanceA(msg->getNamedInstances(), false);  
     }  
 } }
  
 static CIMEnumerateInstancesResponseMessage* _decodeEnumerateInstancesResponse( static CIMEnumerateInstancesResponseMessage* _decodeEnumerateInstancesResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */  
   
     Array<CIMInstance> instances;  
   
     while (in.more())  
     {  
         Array<CIMInstance> tmp;  
   
         if (!in.getInstanceA(tmp))  
             return 0;  
   
         instances.append(tmp.getData(), tmp.size());  
     }  
   
     CIMEnumerateInstancesResponseMessage* msg;     CIMEnumerateInstancesResponseMessage* msg;
     CIMException cimException;     CIMException cimException;
  
Line 406 
Line 364 
         cimException,         cimException,
         QueueIdStack());         QueueIdStack());
  
     msg->setNamedInstances(instances);      // Instead of resolving the binary data right here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to getNamedInstances, which is going to resolve the binary
       // data when the callback function is registered.
       // This allows an alternate client implementation to gain direct access
       // to the binary data and pass this for example to the JNI implementation
       // of the JSR48 CIM Client for Java.
       CIMResponseData& responseData = msg->getResponseData();
       responseData.setBinary(in,false);
   
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
 } }
Line 422 
Line 389 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     STAT_GETSTARTTIME     STAT_GETSTARTTIME
Line 456 
Line 422 
 static CIMEnumerateInstanceNamesResponseMessage* static CIMEnumerateInstanceNamesResponseMessage*
 _decodeEnumerateInstanceNamesResponse( _decodeEnumerateInstanceNamesResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     Array<CIMObjectPath> instanceNames;  
   
     while (in.more())  
     {  
         Array<CIMObjectPath> tmp;  
   
         if (!in.getObjectPathA(tmp))  
             return 0;  
   
         instanceNames.append(tmp.getData(), tmp.size());  
     }  
   
     CIMEnumerateInstanceNamesResponseMessage* msg;     CIMEnumerateInstanceNamesResponseMessage* msg;
     CIMException cimException;     CIMException cimException;
  
     msg = new CIMEnumerateInstanceNamesResponseMessage(     msg = new CIMEnumerateInstanceNamesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),          QueueIdStack());
         instanceNames);  
       // Instead of resolving the binary data right here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to getInstanceNames, which is going to resolve the binary
       // data when the callback function is registered.
       // This allows an alternate client implementation to gain direct access
       // to the binary data and pass this for example to the JNI implementation
       // of the JSR48 CIM Client for Java.
       CIMResponseData& responseData = msg->getResponseData();
       responseData.setBinary(in,false);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 505 
Line 467 
  
 static void _encodeEnumerateInstanceNamesResponseBody( static void _encodeEnumerateInstanceNamesResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMEnumerateInstanceNamesResponseMessage* msg,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     static const CIMName NAME("EnumerateInstanceNames");     static const CIMName NAME("EnumerateInstanceNames");
     name = NAME;     name = NAME;
  
     out.putObjectPathA(msg->instanceNames, false);      data.encodeBinaryResponse(out);
 } }
  
 //============================================================================== //==============================================================================
Line 556 
Line 518 
             messageId,             messageId,
             nameSpace,             nameSpace,
             instanceName,             instanceName,
             false,    // Bug 1985 localOnly is deprecated  
 #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS #ifdef PEGASUS_DISABLE_INSTANCE_QUALIFIERS
             false,             false,
 #else #else
Line 575 
Line 536 
  
 static CIMGetInstanceResponseMessage* _decodeGetInstanceResponse( static CIMGetInstanceResponseMessage* _decodeGetInstanceResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     CIMInstance instance;  
   
     if (!in.getInstance(instance))  
         return 0;  
   
     CIMGetInstanceResponseMessage* msg;     CIMGetInstanceResponseMessage* msg;
     CIMException cimException;     CIMException cimException;
  
Line 591 
Line 546 
         cimException,         cimException,
         QueueIdStack());         QueueIdStack());
  
     msg->setCimInstance(instance);      // Instead of resolving the binary data right here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to getNamedInstances, which is going to resolve the binary
       // data when the callback function is registered.
       // This allows an alternate client implementation to gain direct access
       // to the binary data and pass this for example to the JNI implementation
       // of the JSR48 CIM Client for Java.
       CIMResponseData& responseData = msg->getResponseData();
       responseData.setBinary(in,false);
   
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
 } }
Line 608 
Line 572 
  
     Uint32 flags = 0;     Uint32 flags = 0;
  
     if (msg->localOnly)  
         flags |= LOCAL_ONLY;  
   
     if (msg->includeQualifiers)     if (msg->includeQualifiers)
         flags |= INCLUDE_QUALIFIERS;         flags |= INCLUDE_QUALIFIERS;
  
Line 631 
Line 592 
  
 static void _encodeGetInstanceResponseBody( static void _encodeGetInstanceResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMGetInstanceResponseMessage* msg,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     static const CIMName NAME("GetInstance");     static const CIMName NAME("GetInstance");
     name = NAME;     name = NAME;
  
     if (msg->resolveCallback && msg->binaryEncoding)      data.encodeBinaryResponse(out);
     {  
         const Array<Uint8>& data = msg->binaryData;  
         out.putBytes((char*)data.getData(), data.size());  
     }  
     else  
     {  
         out.putInstance(msg->getCimInstance(), false, false);  
     }  
 } }
  
 //============================================================================== //==============================================================================
Line 676 
Line 629 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     STAT_GETSTARTTIME     STAT_GETSTARTTIME
Line 722 
Line 674 
  
 static CIMCreateInstanceResponseMessage* _decodeCreateInstanceResponse( static CIMCreateInstanceResponseMessage* _decodeCreateInstanceResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     CIMObjectPath instanceName;     CIMObjectPath instanceName;
Line 827 
Line 778 
 } }
  
 static void _encodeModifyInstanceResponseBody( static void _encodeModifyInstanceResponseBody(
     CIMBuffer& out,  
     CIMModifyInstanceResponseMessage* msg,  
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 839 
Line 788 
  
 static CIMModifyInstanceResponseMessage* _decodeModifyInstanceResponse( static CIMModifyInstanceResponseMessage* _decodeModifyInstanceResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 898 
Line 846 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 932 
Line 879 
 } }
  
 static void _encodeDeleteInstanceResponseBody( static void _encodeDeleteInstanceResponseBody(
     CIMBuffer& out,  
     CIMDeleteInstanceResponseMessage* msg,  
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 943 
Line 888 
 } }
  
 static CIMDeleteInstanceResponseMessage* _decodeDeleteInstanceResponse( static CIMDeleteInstanceResponseMessage* _decodeDeleteInstanceResponse(
     CIMBuffer& in,  
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 1096 
Line 1039 
  
 static void _encodeAssociatorsResponseBody( static void _encodeAssociatorsResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMAssociatorsResponseMessage* msg,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 1104 
Line 1047 
     static const CIMName NAME("Associators");     static const CIMName NAME("Associators");
     name = NAME;     name = NAME;
  
     out.putObjectA(msg->cimObjects);  
       data.encodeBinaryResponse(out);
 } }
  
 static CIMAssociatorsResponseMessage* _decodeAssociatorsResponse( static CIMAssociatorsResponseMessage* _decodeAssociatorsResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */  
   
     Array<CIMObject> cimObjects;  
   
     while (in.more())  
     {  
         Array<CIMObject> tmp;  
   
         if (!in.getObjectA(tmp))  
             return 0;  
   
         cimObjects.append(tmp.getData(), tmp.size());  
     }  
   
     CIMAssociatorsResponseMessage* msg;     CIMAssociatorsResponseMessage* msg;
     CIMException cimException;     CIMException cimException;
  
     msg = new CIMAssociatorsResponseMessage(     msg = new CIMAssociatorsResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),          QueueIdStack());
         cimObjects);  
       // Instead of resolving the binary data right here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to getNamedInstances, which is going to resolve the binary
       // data when the callback function is registered.
       // This allows an alternate client implementation to gain direct access
       // to the binary data and pass this for example to the JNI implementation
       // of the JSR48 CIM Client for Java.
       CIMResponseData& responseData = msg->getResponseData();
       responseData.setBinary(in,false);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 1183 
Line 1121 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 1251 
Line 1188 
  
 static void _encodeAssociatorNamesResponseBody( static void _encodeAssociatorNamesResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMAssociatorNamesResponseMessage* msg,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
  
     static const CIMName NAME("AssociatorNames");     static const CIMName NAME("AssociatorNames");
     name = NAME;     name = NAME;
       data.encodeBinaryResponse(out);
     out.putObjectPathA(msg->objectNames);  
 } }
  
 static CIMAssociatorNamesResponseMessage* _decodeAssociatorNamesResponse( static CIMAssociatorNamesResponseMessage* _decodeAssociatorNamesResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */  
   
     Array<CIMObjectPath> objectNames;  
   
     while (in.more())  
     {  
         Array<CIMObjectPath> tmp;  
   
         if (!in.getObjectPathA(tmp))  
             return 0;  
   
         objectNames.append(tmp.getData(), tmp.size());  
     }  
   
     CIMAssociatorNamesResponseMessage* msg;     CIMAssociatorNamesResponseMessage* msg;
     CIMException cimException;     CIMException cimException;
  
     msg = new CIMAssociatorNamesResponseMessage(     msg = new CIMAssociatorNamesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),          QueueIdStack());
         objectNames);  
       // Instead of resolving the binary data right here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to getNamedInstances, which is going to resolve the binary
       // data when the callback function is registered.
       // This allows an alternate client implementation to gain direct access
       // to the binary data and pass this for example to the JNI implementation
       // of the JSR48 CIM Client for Java.
       CIMResponseData& responseData = msg->getResponseData();
       responseData.setBinary(in,false);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 1408 
Line 1338 
  
 static void _encodeReferencesResponseBody( static void _encodeReferencesResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMReferencesResponseMessage* msg,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 1416 
Line 1346 
     static const CIMName NAME("References");     static const CIMName NAME("References");
     name = NAME;     name = NAME;
  
     out.putObjectA(msg->cimObjects);      data.encodeBinaryResponse(out);
 } }
  
 static CIMReferencesResponseMessage* _decodeReferencesResponse( static CIMReferencesResponseMessage* _decodeReferencesResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */  
   
     Array<CIMObject> cimObjects;  
   
     while (in.more())  
     {  
         Array<CIMObject> tmp;  
   
         if (!in.getObjectA(tmp))  
         {  
             return 0;  
         }  
   
         cimObjects.append(tmp.getData(), tmp.size());  
     }  
   
     CIMReferencesResponseMessage* msg;     CIMReferencesResponseMessage* msg;
     CIMException cimException;     CIMException cimException;
  
     msg = new CIMReferencesResponseMessage(     msg = new CIMReferencesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),          QueueIdStack());
         cimObjects);  
       // Instead of resolving the binary data right here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to getNamedInstances, which is going to resolve the binary
       // data when the callback function is registered.
       // This allows an alternate client implementation to gain direct access
       // to the binary data and pass this for example to the JNI implementation
       // of the JSR48 CIM Client for Java.
       CIMResponseData& responseData = msg->getResponseData();
       responseData.setBinary(in,false);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 1491 
Line 1413 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 1543 
Line 1464 
  
 static void _encodeReferenceNamesResponseBody( static void _encodeReferenceNamesResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMReferenceNamesResponseMessage* msg,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
  
     static const CIMName NAME("ReferenceNames");     static const CIMName NAME("ReferenceNames");
     name = NAME;     name = NAME;
       data.encodeBinaryResponse(out);
     out.putObjectPathA(msg->objectNames);  
 } }
  
 static CIMReferenceNamesResponseMessage* _decodeReferenceNamesResponse( static CIMReferenceNamesResponseMessage* _decodeReferenceNamesResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
  
     Array<CIMObjectPath> objectNames;  
   
     while (in.more())  
     {  
         Array<CIMObjectPath> tmp;  
   
         if (!in.getObjectPathA(tmp))  
             return 0;  
   
         objectNames.append(tmp.getData(), tmp.size());  
     }  
   
     CIMReferenceNamesResponseMessage* msg;     CIMReferenceNamesResponseMessage* msg;
     CIMException cimException;     CIMException cimException;
  
     msg = new CIMReferenceNamesResponseMessage(     msg = new CIMReferenceNamesResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),          QueueIdStack());
         objectNames);  
       // Instead of resolving the binary data right here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to getNamedInstances, which is going to resolve the binary
       // data when the callback function is registered.
       // This allows an alternate client implementation to gain direct access
       // to the binary data and pass this for example to the JNI implementation
       // of the JSR48 CIM Client for Java.
       CIMResponseData& responseData = msg->getResponseData();
       responseData.setBinary(in,false);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
   
     return msg;     return msg;
 } }
  
Line 1692 
Line 1609 
  
 static CIMGetClassResponseMessage* _decodeGetClassResponse( static CIMGetClassResponseMessage* _decodeGetClassResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 1818 
Line 1734 
  
 static CIMEnumerateClassesResponseMessage* _decodeEnumerateClassesResponse( static CIMEnumerateClassesResponseMessage* _decodeEnumerateClassesResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 1937 
Line 1852 
 static CIMEnumerateClassNamesResponseMessage* static CIMEnumerateClassNamesResponseMessage*
 _decodeEnumerateClassNamesResponse( _decodeEnumerateClassNamesResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 1997 
Line 1911 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2032 
Line 1945 
 } }
  
 static void _encodeCreateClassResponseBody( static void _encodeCreateClassResponseBody(
     CIMBuffer& out,  
     CIMCreateClassResponseMessage* msg,  
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 2043 
Line 1954 
 } }
  
 static CIMCreateClassResponseMessage* _decodeCreateClassResponse( static CIMCreateClassResponseMessage* _decodeCreateClassResponse(
     CIMBuffer& in,  
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 2091 
Line 2000 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2126 
Line 2034 
 } }
  
 static void _encodeDeleteClassResponseBody( static void _encodeDeleteClassResponseBody(
     CIMBuffer& out,  
     CIMDeleteClassResponseMessage* msg,  
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 2137 
Line 2043 
 } }
  
 static CIMDeleteClassResponseMessage* _decodeDeleteClassResponse( static CIMDeleteClassResponseMessage* _decodeDeleteClassResponse(
     CIMBuffer& in,  
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 2185 
Line 2089 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2220 
Line 2123 
 } }
  
 static void _encodeModifyClassResponseBody( static void _encodeModifyClassResponseBody(
     CIMBuffer& out,  
     CIMModifyClassResponseMessage* msg,  
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 2231 
Line 2132 
 } }
  
 static CIMModifyClassResponseMessage* _decodeModifyClassResponse( static CIMModifyClassResponseMessage* _decodeModifyClassResponse(
     CIMBuffer& in,  
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 2279 
Line 2178 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2315 
Line 2213 
 } }
  
 static void _encodeSetQualifierResponseBody( static void _encodeSetQualifierResponseBody(
     CIMBuffer& out,  
     CIMSetQualifierResponseMessage* msg,  
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 2326 
Line 2222 
 } }
  
 static CIMSetQualifierResponseMessage* _decodeSetQualifierResponse( static CIMSetQualifierResponseMessage* _decodeSetQualifierResponse(
     CIMBuffer& in,  
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 2374 
Line 2268 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2423 
Line 2316 
  
 static CIMGetQualifierResponseMessage* _decodeGetQualifierResponse( static CIMGetQualifierResponseMessage* _decodeGetQualifierResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 2476 
Line 2368 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2511 
Line 2402 
 } }
  
 static void _encodeDeleteQualifierResponseBody( static void _encodeDeleteQualifierResponseBody(
     CIMBuffer& out,  
     CIMDeleteQualifierResponseMessage* msg,  
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 2522 
Line 2411 
 } }
  
 static CIMDeleteQualifierResponseMessage* _decodeDeleteQualifierResponse( static CIMDeleteQualifierResponseMessage* _decodeDeleteQualifierResponse(
     CIMBuffer& in,  
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 2567 
Line 2454 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2610 
Line 2496 
 static CIMEnumerateQualifiersResponseMessage* static CIMEnumerateQualifiersResponseMessage*
     _decodeEnumerateQualifiersResponse(     _decodeEnumerateQualifiersResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 2673 
Line 2558 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2730 
Line 2614 
  
 static CIMGetPropertyResponseMessage* _decodeGetPropertyResponse( static CIMGetPropertyResponseMessage* _decodeGetPropertyResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 2801 
Line 2684 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2853 
Line 2735 
 } }
  
 static void _encodeSetPropertyResponseBody( static void _encodeSetPropertyResponseBody(
     CIMBuffer& out,  
     CIMSetPropertyResponseMessage* msg,  
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 2864 
Line 2744 
 } }
  
 static CIMSetPropertyResponseMessage* _decodeSetPropertyResponse( static CIMSetPropertyResponseMessage* _decodeSetPropertyResponse(
     CIMBuffer& in,  
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 2917 
Line 2795 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 2989 
Line 2866 
  
 static CIMInvokeMethodResponseMessage* _decodeInvokeMethodResponse( static CIMInvokeMethodResponseMessage* _decodeInvokeMethodResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */     /* See ../Client/CIMOperationResponseDecoder.cpp */
Line 3064 
Line 2940 
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId,     Uint32 returnQueueId,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Server/CIMOperationRequestDecoder.cpp */     /* See ../Server/CIMOperationRequestDecoder.cpp */
Line 3107 
Line 2982 
  
 static void _encodeExecQueryResponseBody( static void _encodeExecQueryResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMExecQueryResponseMessage* msg,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 3115 
Line 2990 
     static const CIMName NAME("ExecQuery");     static const CIMName NAME("ExecQuery");
     name = NAME;     name = NAME;
  
     out.putObjectA(msg->cimObjects, false);      data.encodeBinaryResponse(out);
 } }
  
 static CIMExecQueryResponseMessage* _decodeExecQueryResponse( static CIMExecQueryResponseMessage* _decodeExecQueryResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     /* See ../Client/CIMOperationResponseDecoder.cpp */  
   
     Array<CIMObject> cimObjects;  
   
     while (in.more())  
     {  
         Array<CIMObject> tmp;  
   
         if (!in.getObjectA(tmp))  
             return 0;  
   
         cimObjects.append(tmp.getData(), tmp.size());  
     }  
   
     CIMExecQueryResponseMessage* msg;     CIMExecQueryResponseMessage* msg;
     CIMException cimException;     CIMException cimException;
  
     msg = new CIMExecQueryResponseMessage(     msg = new CIMExecQueryResponseMessage(
         messageId,         messageId,
         cimException,         cimException,
         QueueIdStack(),          QueueIdStack());
         cimObjects);  
       // Instead of resolving the binary data right here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to getNamedInstances, which is going to resolve the binary
       // data when the callback function is registered.
       // This allows an alternate client implementation to gain direct access
       // to the binary data and pass this for example to the JNI implementation
       // of the JSR48 CIM Client for Java.
       CIMResponseData& responseData = msg->getResponseData();
       responseData.setBinary(in,false);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 3240 
Line 3109 
                 buf, queueId, returnQueueId, flags, messageId);                 buf, queueId, returnQueueId, flags, messageId);
         case OP_EnumerateInstanceNames:         case OP_EnumerateInstanceNames:
             return _decodeEnumerateInstanceNamesRequest(             return _decodeEnumerateInstanceNamesRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_GetInstance:         case OP_GetInstance:
             return _decodeGetInstanceRequest(             return _decodeGetInstanceRequest(
                 buf, queueId, returnQueueId, flags, messageId);                 buf, queueId, returnQueueId, flags, messageId);
         case OP_CreateInstance:         case OP_CreateInstance:
             return _decodeCreateInstanceRequest(             return _decodeCreateInstanceRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_ModifyInstance:         case OP_ModifyInstance:
             return _decodeModifyInstanceRequest(             return _decodeModifyInstanceRequest(
                 buf, queueId, returnQueueId, flags, messageId);                 buf, queueId, returnQueueId, flags, messageId);
         case OP_DeleteInstance:         case OP_DeleteInstance:
             return _decodeDeleteInstanceRequest(             return _decodeDeleteInstanceRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_Associators:         case OP_Associators:
             return _decodeAssociatorsRequest(             return _decodeAssociatorsRequest(
                 buf, queueId, returnQueueId, flags, messageId);                 buf, queueId, returnQueueId, flags, messageId);
         case OP_AssociatorNames:         case OP_AssociatorNames:
             return _decodeAssociatorNamesRequest(             return _decodeAssociatorNamesRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_References:         case OP_References:
             return _decodeReferencesRequest(             return _decodeReferencesRequest(
                 buf, queueId, returnQueueId, flags, messageId);                 buf, queueId, returnQueueId, flags, messageId);
         case OP_ReferenceNames:         case OP_ReferenceNames:
             return _decodeReferenceNamesRequest(             return _decodeReferenceNamesRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_GetClass:         case OP_GetClass:
             return _decodeGetClassRequest(             return _decodeGetClassRequest(
                 buf, queueId, returnQueueId, flags, messageId);                 buf, queueId, returnQueueId, flags, messageId);
Line 3276 
Line 3145 
                 buf, queueId, returnQueueId, flags, messageId);                 buf, queueId, returnQueueId, flags, messageId);
         case OP_CreateClass:         case OP_CreateClass:
             return _decodeCreateClassRequest(             return _decodeCreateClassRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_DeleteClass:         case OP_DeleteClass:
             return _decodeDeleteClassRequest(             return _decodeDeleteClassRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_ModifyClass:         case OP_ModifyClass:
             return _decodeModifyClassRequest(             return _decodeModifyClassRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_SetQualifier:         case OP_SetQualifier:
             return _decodeSetQualifierRequest(             return _decodeSetQualifierRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_GetQualifier:         case OP_GetQualifier:
             return _decodeGetQualifierRequest(             return _decodeGetQualifierRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_DeleteQualifier:         case OP_DeleteQualifier:
             return _decodeDeleteQualifierRequest(             return _decodeDeleteQualifierRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_EnumerateQualifiers:         case OP_EnumerateQualifiers:
             return _decodeEnumerateQualifiersRequest(             return _decodeEnumerateQualifiersRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_GetProperty:         case OP_GetProperty:
            return _decodeGetPropertyRequest(            return _decodeGetPropertyRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_SetProperty:         case OP_SetProperty:
            return _decodeSetPropertyRequest(            return _decodeSetPropertyRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_InvokeMethod:         case OP_InvokeMethod:
            return _decodeInvokeMethodRequest(            return _decodeInvokeMethodRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         case OP_ExecQuery:         case OP_ExecQuery:
            return _decodeExecQueryRequest(            return _decodeExecQueryRequest(
                 buf, queueId, returnQueueId, flags, messageId);                  buf, queueId, returnQueueId, messageId);
         default:         default:
             // Unexpected message type             // Unexpected message type
             PEGASUS_ASSERT(0);             PEGASUS_ASSERT(0);
Line 3326 
Line 3195 
     CIMBuffer buf((char*)in.getData(), in.size());     CIMBuffer buf((char*)in.getData(), in.size());
     CIMBufferReleaser buf_(buf);     CIMBufferReleaser buf_(buf);
  
       return decodeResponse(buf);
   }
   
   CIMResponseMessage* BinaryCodec::decodeResponse(
       CIMBuffer& buf)
   {
     // Turn on validation:     // Turn on validation:
 #if defined(ENABLE_VALIDATION) #if defined(ENABLE_VALIDATION)
     buf.setValidate(true);     buf.setValidate(true);
Line 3346 
Line 3221 
     switch (operation)     switch (operation)
     {     {
         case OP_EnumerateInstances:         case OP_EnumerateInstances:
             msg = _decodeEnumerateInstancesResponse(buf, flags, messageId);              msg = _decodeEnumerateInstancesResponse(buf, messageId);
             break;             break;
         case OP_EnumerateInstanceNames:         case OP_EnumerateInstanceNames:
             msg = _decodeEnumerateInstanceNamesResponse(buf, flags, messageId);              msg = _decodeEnumerateInstanceNamesResponse(buf, messageId);
             break;             break;
         case OP_GetInstance:         case OP_GetInstance:
             msg = _decodeGetInstanceResponse(buf, flags, messageId);              msg = _decodeGetInstanceResponse(buf, messageId);
             break;             break;
         case OP_CreateInstance:         case OP_CreateInstance:
             msg = _decodeCreateInstanceResponse(buf, flags, messageId);              msg = _decodeCreateInstanceResponse(buf, messageId);
             break;             break;
         case OP_ModifyInstance:         case OP_ModifyInstance:
             msg = _decodeModifyInstanceResponse(buf, flags, messageId);              msg = _decodeModifyInstanceResponse(buf, messageId);
             break;             break;
         case OP_DeleteInstance:         case OP_DeleteInstance:
             msg = _decodeDeleteInstanceResponse(buf, flags, messageId);              msg = _decodeDeleteInstanceResponse(messageId);
             break;             break;
         case OP_Associators:         case OP_Associators:
             msg = _decodeAssociatorsResponse(buf, flags, messageId);              msg = _decodeAssociatorsResponse(buf, messageId);
             break;             break;
         case OP_AssociatorNames:         case OP_AssociatorNames:
             msg = _decodeAssociatorNamesResponse(buf, flags, messageId);              msg = _decodeAssociatorNamesResponse(buf, messageId);
             break;             break;
         case OP_References:         case OP_References:
             msg = _decodeReferencesResponse(buf, flags, messageId);              msg = _decodeReferencesResponse(buf, messageId);
             break;             break;
         case OP_ReferenceNames:         case OP_ReferenceNames:
             msg = _decodeReferenceNamesResponse(buf, flags, messageId);              msg = _decodeReferenceNamesResponse(buf, messageId);
             break;             break;
         case OP_GetClass:         case OP_GetClass:
             msg = _decodeGetClassResponse(buf, flags, messageId);              msg = _decodeGetClassResponse(buf, messageId);
             break;             break;
         case OP_EnumerateClasses:         case OP_EnumerateClasses:
             msg = _decodeEnumerateClassesResponse(buf, flags, messageId);              msg = _decodeEnumerateClassesResponse(buf, messageId);
             break;             break;
         case OP_EnumerateClassNames:         case OP_EnumerateClassNames:
             msg = _decodeEnumerateClassNamesResponse(buf, flags, messageId);              msg = _decodeEnumerateClassNamesResponse(buf, messageId);
             break;             break;
         case OP_CreateClass:         case OP_CreateClass:
             msg = _decodeCreateClassResponse(buf, flags, messageId);              msg = _decodeCreateClassResponse(messageId);
             break;             break;
         case OP_DeleteClass:         case OP_DeleteClass:
             msg = _decodeDeleteClassResponse(buf, flags, messageId);              msg = _decodeDeleteClassResponse(messageId);
             break;             break;
         case OP_ModifyClass:         case OP_ModifyClass:
             msg = _decodeModifyClassResponse(buf, flags, messageId);              msg = _decodeModifyClassResponse(messageId);
             break;             break;
         case OP_SetQualifier:         case OP_SetQualifier:
             msg = _decodeSetQualifierResponse(buf, flags, messageId);              msg = _decodeSetQualifierResponse(messageId);
             break;             break;
         case OP_GetQualifier:         case OP_GetQualifier:
             msg = _decodeGetQualifierResponse(buf, flags, messageId);              msg = _decodeGetQualifierResponse(buf, messageId);
             break;             break;
         case OP_DeleteQualifier:         case OP_DeleteQualifier:
             msg = _decodeDeleteQualifierResponse(buf, flags, messageId);              msg = _decodeDeleteQualifierResponse(messageId);
             break;             break;
         case OP_EnumerateQualifiers:         case OP_EnumerateQualifiers:
             msg = _decodeEnumerateQualifiersResponse(buf, flags, messageId);              msg = _decodeEnumerateQualifiersResponse(buf, messageId);
             break;             break;
         case OP_GetProperty:         case OP_GetProperty:
             msg = _decodeGetPropertyResponse(buf, flags, messageId);              msg = _decodeGetPropertyResponse(buf, messageId);
             break;             break;
         case OP_SetProperty:         case OP_SetProperty:
             msg = _decodeSetPropertyResponse(buf, flags, messageId);              msg = _decodeSetPropertyResponse(messageId);
             break;             break;
         case OP_InvokeMethod:         case OP_InvokeMethod:
             msg = _decodeInvokeMethodResponse(buf, flags, messageId);              msg = _decodeInvokeMethodResponse(buf, messageId);
             break;             break;
         case OP_ExecQuery:         case OP_ExecQuery:
             msg = _decodeExecQueryResponse(buf, flags, messageId);              msg = _decodeExecQueryResponse(buf, messageId);
             break;             break;
         default:         default:
             // Unexpected message type             // Unexpected message type
Line 3697 
Line 3572 
     {     {
         case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:         case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
         {         {
             _encodeEnumerateInstancesResponseBody(buf,              _encodeEnumerateInstancesResponseBody(
                 (CIMEnumerateInstancesResponseMessage*)msg, name);                  buf,
                   ((CIMEnumerateInstancesResponseMessage*)msg)->getResponseData(),
                   name);
             break;             break;
         }         }
  
         case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:         case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
         {         {
             _encodeEnumerateInstanceNamesResponseBody(buf,              _encodeEnumerateInstanceNamesResponseBody(
                 (CIMEnumerateInstanceNamesResponseMessage*)msg, name);              buf,
               ((CIMEnumerateInstanceNamesResponseMessage*)msg)->getResponseData(),
               name);
             break;             break;
         }         }
  
         case CIM_GET_INSTANCE_RESPONSE_MESSAGE:         case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
         {         {
             _encodeGetInstanceResponseBody(buf,              _encodeGetInstanceResponseBody(
                 (CIMGetInstanceResponseMessage*)msg, name);                  buf,
                   ((CIMGetInstanceResponseMessage*)msg)->getResponseData(),
                   name);
             break;             break;
         }         }
  
Line 3725 
Line 3606 
  
         case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:         case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
         {         {
             _encodeModifyInstanceResponseBody(buf,              _encodeModifyInstanceResponseBody(name);
                 (CIMModifyInstanceResponseMessage*)msg, name);  
             break;             break;
         }         }
  
         case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:         case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
         {         {
             _encodeDeleteInstanceResponseBody(buf,              _encodeDeleteInstanceResponseBody(name);
                 (CIMDeleteInstanceResponseMessage*)msg, name);  
             break;             break;
         }         }
  
         case CIM_ASSOCIATORS_RESPONSE_MESSAGE:         case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
         {         {
             _encodeAssociatorsResponseBody(buf,              _encodeAssociatorsResponseBody(
                 (CIMAssociatorsResponseMessage*)msg, name);                  buf,
                   ((CIMAssociatorsResponseMessage*)msg)->getResponseData(),
                   name);
             break;             break;
         }         }
  
         case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:         case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
         {         {
             _encodeAssociatorNamesResponseBody(buf,              _encodeAssociatorNamesResponseBody(
                 (CIMAssociatorNamesResponseMessage*)msg, name);                  buf,
                   ((CIMAssociatorNamesResponseMessage*)msg)->getResponseData(),
                   name);
             break;             break;
         }         }
  
         case CIM_REFERENCES_RESPONSE_MESSAGE:         case CIM_REFERENCES_RESPONSE_MESSAGE:
         {         {
             _encodeReferencesResponseBody(buf,              _encodeReferencesResponseBody(
                 (CIMReferencesResponseMessage*)msg, name);                  buf,
                   ((CIMReferencesResponseMessage*)msg)->getResponseData(),
                   name);
             break;             break;
         }         }
  
         case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:         case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
         {         {
             _encodeReferenceNamesResponseBody(buf,              _encodeReferenceNamesResponseBody(
                 (CIMReferenceNamesResponseMessage*)msg, name);                  buf,
                   ((CIMReferenceNamesResponseMessage*)msg)->getResponseData(),
                   name);
             break;             break;
         }         }
  
Line 3788 
Line 3675 
  
         case CIM_CREATE_CLASS_RESPONSE_MESSAGE:         case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
         {         {
             _encodeCreateClassResponseBody(buf,              _encodeCreateClassResponseBody(name);
                 (CIMCreateClassResponseMessage*)msg, name);  
             break;             break;
         }         }
  
         case CIM_DELETE_CLASS_RESPONSE_MESSAGE:         case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
         {         {
             _encodeDeleteClassResponseBody(buf,              _encodeDeleteClassResponseBody(name);
                 (CIMDeleteClassResponseMessage*)msg, name);  
             break;             break;
         }         }
  
         case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:         case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
         {         {
             _encodeModifyClassResponseBody(buf,              _encodeModifyClassResponseBody(name);
                 (CIMModifyClassResponseMessage*)msg, name);  
             break;             break;
         }         }
  
         case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:         case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
         {         {
             _encodeSetQualifierResponseBody(buf,              _encodeSetQualifierResponseBody(name);
                 (CIMSetQualifierResponseMessage*)msg, name);  
             break;             break;
         }         }
  
Line 3823 
Line 3706 
  
         case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:         case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
         {         {
             _encodeDeleteQualifierResponseBody(buf,              _encodeDeleteQualifierResponseBody(name);
                 (CIMDeleteQualifierResponseMessage*)msg, name);  
             break;             break;
         }         }
  
Line 3844 
Line 3726 
  
         case CIM_SET_PROPERTY_RESPONSE_MESSAGE:         case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
         {         {
             _encodeSetPropertyResponseBody(buf,              _encodeSetPropertyResponseBody(name);
                 (CIMSetPropertyResponseMessage*)msg, name);  
             break;             break;
         }         }
  
Line 3858 
Line 3739 
  
         case CIM_EXEC_QUERY_RESPONSE_MESSAGE:         case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
         {         {
             _encodeExecQueryResponseBody(buf,              _encodeExecQueryResponseBody(
                 (CIMExecQueryResponseMessage*)msg, name);                  buf,
                   ((CIMExecQueryResponseMessage*)msg)->getResponseData(),
                   name);
             break;             break;
         }         }
  

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