(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.9 and 1.12

version 1.9, 2009/07/08 13:48:26 version 1.12, 2011/01/07 02:17:20
Line 341 
Line 341 
  
 static void _encodeEnumerateInstancesResponseBody( static void _encodeEnumerateInstancesResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMInstancesResponseData& data,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 354 
Line 354 
  
 static CIMEnumerateInstancesResponseMessage* _decodeEnumerateInstancesResponse( static CIMEnumerateInstancesResponseMessage* _decodeEnumerateInstancesResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     CIMEnumerateInstancesResponseMessage* msg;     CIMEnumerateInstancesResponseMessage* msg;
Line 372 
Line 371 
     // This allows an alternate client implementation to gain direct access     // This allows an alternate client implementation to gain direct access
     // to the binary data and pass this for example to the JNI implementation     // to the binary data and pass this for example to the JNI implementation
     // of the JSR48 CIM Client for Java.     // of the JSR48 CIM Client for Java.
     CIMInstancesResponseData& responseData = msg->getResponseData();      CIMResponseData& responseData = msg->getResponseData();
     responseData.setBinaryCimInstances(in,false);      responseData.setRemainingBinaryData(in);
  
     msg->binaryRequest=true;     msg->binaryRequest=true;
     return msg;     return msg;
Line 390 
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 424 
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.setRemainingBinaryData(in);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 473 
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 542 
Line 536 
  
 static CIMGetInstanceResponseMessage* _decodeGetInstanceResponse( static CIMGetInstanceResponseMessage* _decodeGetInstanceResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     CIMGetInstanceResponseMessage* msg;     CIMGetInstanceResponseMessage* msg;
Line 560 
Line 553 
     // This allows an alternate client implementation to gain direct access     // This allows an alternate client implementation to gain direct access
     // to the binary data and pass this for example to the JNI implementation     // to the binary data and pass this for example to the JNI implementation
     // of the JSR48 CIM Client for Java.     // of the JSR48 CIM Client for Java.
     CIMInstanceResponseData& responseData = msg->getResponseData();      CIMResponseData& responseData = msg->getResponseData();
     responseData.setBinaryCimInstance(in,false);      responseData.setRemainingBinaryData(in);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 599 
Line 592 
  
 static void _encodeGetInstanceResponseBody( static void _encodeGetInstanceResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMInstanceResponseData& data,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     static const CIMName NAME("GetInstance");     static const CIMName NAME("GetInstance");
Line 636 
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 682 
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 787 
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 799 
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 858 
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 892 
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 903 
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 1056 
Line 1039 
  
 static void _encodeAssociatorsResponseBody( static void _encodeAssociatorsResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMObjectsResponseData& data,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 1070 
Line 1053 
  
 static CIMAssociatorsResponseMessage* _decodeAssociatorsResponse( static CIMAssociatorsResponseMessage* _decodeAssociatorsResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     CIMAssociatorsResponseMessage* msg;     CIMAssociatorsResponseMessage* msg;
Line 1088 
Line 1070 
     // This allows an alternate client implementation to gain direct access     // This allows an alternate client implementation to gain direct access
     // to the binary data and pass this for example to the JNI implementation     // to the binary data and pass this for example to the JNI implementation
     // of the JSR48 CIM Client for Java.     // of the JSR48 CIM Client for Java.
     CIMObjectsResponseData& responseData = msg->getResponseData();      CIMResponseData& responseData = msg->getResponseData();
     responseData.setBinaryCimObjects(in,false);      responseData.setRemainingBinaryData(in);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 1139 
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 1207 
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.setRemainingBinaryData(in);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 1364 
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 1372 
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.setRemainingBinaryData(in);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 1447 
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 1499 
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.setRemainingBinaryData(in);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
   
     return msg;     return msg;
 } }
  
Line 1648 
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 1774 
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 1893 
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 1953 
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 1988 
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 1999 
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 2047 
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 2082 
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 2093 
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 2141 
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 2176 
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 2187 
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 2235 
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 2271 
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 2282 
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 2330 
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 2379 
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 2432 
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 2467 
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 2478 
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 2523 
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 2566 
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 2629 
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 2686 
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 2757 
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 2809 
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 2820 
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 2873 
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 2945 
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 3020 
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 3063 
Line 2982 
  
 static void _encodeExecQueryResponseBody( static void _encodeExecQueryResponseBody(
     CIMBuffer& out,     CIMBuffer& out,
     CIMObjectsResponseData& data,      CIMResponseData& data,
     CIMName& name)     CIMName& name)
 { {
     /* See ../Server/CIMOperationResponseEncoder.cpp */     /* See ../Server/CIMOperationResponseEncoder.cpp */
Line 3076 
Line 2995 
  
 static CIMExecQueryResponseMessage* _decodeExecQueryResponse( static CIMExecQueryResponseMessage* _decodeExecQueryResponse(
     CIMBuffer& in,     CIMBuffer& in,
     Uint32 flags,  
     const String& messageId)     const String& messageId)
 { {
     CIMExecQueryResponseMessage* msg;     CIMExecQueryResponseMessage* msg;
Line 3094 
Line 3012 
     // This allows an alternate client implementation to gain direct access     // This allows an alternate client implementation to gain direct access
     // to the binary data and pass this for example to the JNI implementation     // to the binary data and pass this for example to the JNI implementation
     // of the JSR48 CIM Client for Java.     // of the JSR48 CIM Client for Java.
     CIMObjectsResponseData& responseData = msg->getResponseData();      CIMResponseData& responseData = msg->getResponseData();
     responseData.setBinaryCimObjects(in,false);      responseData.setRemainingBinaryData(in);
  
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
Line 3191 
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 3227 
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 3283 
Line 3201 
 CIMResponseMessage* BinaryCodec::decodeResponse( CIMResponseMessage* BinaryCodec::decodeResponse(
     CIMBuffer& buf)     CIMBuffer& buf)
 { {
     // Turn on validation:      // Turn on validation: This is a debugging tool
 #if defined(ENABLE_VALIDATION) #if defined(ENABLE_VALIDATION)
     buf.setValidate(true);     buf.setValidate(true);
 #endif #endif
Line 3303 
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 3663 
Line 3581 
  
         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;
         }         }
  
Line 3686 
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;
         }         }
  
Line 3709 
Line 3627 
  
         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 3751 
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 3786 
Line 3706 
  
         case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:         case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
         {         {
             _encodeDeleteQualifierResponseBody(buf,              _encodeDeleteQualifierResponseBody(name);
                 (CIMDeleteQualifierResponseMessage*)msg, name);  
             break;             break;
         }         }
  
Line 3807 
Line 3726 
  
         case CIM_SET_PROPERTY_RESPONSE_MESSAGE:         case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
         {         {
             _encodeSetPropertyResponseBody(buf,              _encodeSetPropertyResponseBody(name);
                 (CIMSetPropertyResponseMessage*)msg, name);  
             break;             break;
         }         }
  

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