(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.12 and 1.12.2.1

version 1.12, 2011/01/07 02:17:20 version 1.12.2.1, 2011/01/15 21:26:53
Line 49 
Line 49 
 #define INCLUDE_QUALIFIERS      (1 << 1) #define INCLUDE_QUALIFIERS      (1 << 1)
 #define INCLUDE_CLASS_ORIGIN    (1 << 2) #define INCLUDE_CLASS_ORIGIN    (1 << 2)
 #define DEEP_INHERITANCE        (1 << 3) #define DEEP_INHERITANCE        (1 << 3)
   #define CONTINUE_ON_ERROR       (1 << 4)
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 91 
Line 92 
     OP_DeleteQualifier,     OP_DeleteQualifier,
     OP_EnumerateQualifiers,     OP_EnumerateQualifiers,
     OP_InvokeMethod,     OP_InvokeMethod,
       OP_OpenEnumerateInstances,
       OP_OpenEnumerateInstancePaths,
       OP_OpenReferenceInstances,
       OP_OpenReferenceInstancePaths,
       OP_OpenAssociatorInstances,
       OP_OpenAssociatorInstancePaths,
       OP_PullInstancesWithPath,
       OP_PullInstancePaths,
       OP_CloseEnumeration,
       OP_EnumerationCount,
     OP_Count     OP_Count
 }; };
  
Line 111 
Line 122 
                 return OP_CreateInstance;                 return OP_CreateInstance;
             if (_EQUAL(s, "CreateClass"))             if (_EQUAL(s, "CreateClass"))
                 return OP_CreateClass;                 return OP_CreateClass;
               if (_EQUAL(s, "CloseEnumeration"))
                   return OP_CloseEnumeration;
             break;             break;
         case 'D':         case 'D':
             if (_EQUAL(s, "DeleteInstance"))             if (_EQUAL(s, "DeleteInstance"))
Line 156 
Line 169 
             if (_EQUAL(s, "ModifyClass"))             if (_EQUAL(s, "ModifyClass"))
                 return OP_ModifyClass;                 return OP_ModifyClass;
             break;             break;
           case 'O':
               if (_EQUAL(s, "OpenEnumerateInstances"))
                   return OP_OpenEnumerateInstances;
               if (_EQUAL(s, "OpenEnumerateInstancePaths"))
                   return OP_OpenEnumerateInstancePaths;
               if (_EQUAL(s, "OpenReferenceInstances"))
                   return OP_OpenReferenceInstances;
               if (_EQUAL(s, "OpenReferenceInstancePaths"))
                   return OP_OpenReferenceInstancePaths;
               if (_EQUAL(s, "OpenAssociatorInstances"))
                   return OP_OpenAssociatorInstances;
               if (_EQUAL(s, "OpenAssociatorInstancePaths"))
                   return OP_OpenAssociatorInstancePaths;
               break;
           case 'P':
               if (_EQUAL(s, "PullInstancesWithPath"))
                   return OP_PullInstancesWithPath;
               if (_EQUAL(s, "PullInstancePaths"))
                   return OP_PullInstancePaths;
               break;
         case 'R':         case 'R':
             if (_EQUAL(s, "References"))             if (_EQUAL(s, "References"))
                 return OP_References;                 return OP_References;
Line 364 
Line 397 
         cimException,         cimException,
         QueueIdStack());         QueueIdStack());
  
     // Instead of resolving the binary data right here, we delegate this      // Instead of resolving the binary data here, we delegate this
     // to a later point in time when the data is actually retrieved through     // to a later point in time when the data is actually retrieved through
     // a call to getNamedInstances, which is going to resolve the binary      // a call to CIMResponseData::getInstances, which
     // data when the callback function is registered.      // resolves the binary data as it is passed to the next interface.
     // 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.
Line 432 
Line 465 
         cimException,         cimException,
         QueueIdStack());         QueueIdStack());
  
     // Instead of resolving the binary data right here, we delegate this      // Instead of resolving the binary data here, we delegate this
     // to a later point in time when the data is actually retrieved through     // to a later point in time when the data is actually retrieved through
     // a call to getInstanceNames, which is going to resolve the binary      // a call to CIMResponseData::getInstanceNames, which
     // data when the callback function is registered.      // resolves the binary data as it is passed to the next interface.
     // 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.
Line 546 
Line 579 
         cimException,         cimException,
         QueueIdStack());         QueueIdStack());
  
     // Instead of resolving the binary data right here, we delegate this      // Instead of resolving the binary data here, we delegate this
     // to a later point in time when the data is actually retrieved through     // to a later point in time when the data is actually retrieved through
     // a call to getNamedInstances, which is going to resolve the binary      // a call to CIMResponseData::getInstances, which
     // data when the callback function is registered.      // resolves the binary data as it is passed to the next interface.
     // 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.
Line 1063 
Line 1096 
         cimException,         cimException,
         QueueIdStack());         QueueIdStack());
  
     // Instead of resolving the binary data right here, we delegate this      // Instead of resolving the binary data here, we delegate this
     // to a later point in time when the data is actually retrieved through     // to a later point in time when the data is actually retrieved through
     // a call to getNamedInstances, which is going to resolve the binary      // a call to CIMResponseData::getObjects, which
     // data when the callback function is registered.      // resolves the binary data as it is passed to the next interface.
     // 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.
Line 1210 
Line 1243 
         cimException,         cimException,
         QueueIdStack());         QueueIdStack());
  
     // Instead of resolving the binary data right here, we delegate this      // Instead of resolving the binary data here, we delegate this
     // to a later point in time when the data is actually retrieved through     // to a later point in time when the data is actually retrieved through
     // a call to getNamedInstances, which is going to resolve the binary      // a call to CIMResponseData::getInstanceNames, which
     // data when the callback function is registered.      // resolves the binary data as it is passed to the next interface.
     // 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.
Line 1488 
Line 1521 
         cimException,         cimException,
         QueueIdStack());         QueueIdStack());
  
     // Instead of resolving the binary data right here, we delegate this      // Instead of resolving the binary data here, we delegate this
     // to a later point in time when the data is actually retrieved through     // to a later point in time when the data is actually retrieved through
     // a call to getNamedInstances, which is going to resolve the binary      // a call to CIMResponseData::getInstanceNames, which
     // data when the callback function is registered.      // resolves the binary data as it is passed to the next interface.
     // 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.
Line 3018 
Line 3051 
     msg->binaryRequest = true;     msg->binaryRequest = true;
     return msg;     return msg;
 } }
   // KS_PULL_BEGIN
 //============================================================================== //==============================================================================
 // //
 // BinaryCodec::hexDump()  // OpenEnumerateInstances
 // //
 //============================================================================== //==============================================================================
  
 #if defined(PEGASUS_DEBUG)  static void _encodeOpenEnumerateInstancesRequest(
       CIMBuffer& buf,
 void BinaryCodec::hexDump(const void* data, size_t size)      CIMOpenEnumerateInstancesRequestMessage* msg,
       CIMName& name)
 { {
     unsigned char* p = (unsigned char*)data;      /* See ../Client/CIMOperationRequestEncoder.cpp */
     unsigned char buf[16];  
     size_t n = 0;  
  
     for (size_t i = 0, col = 0; i < size; i++)      static const CIMName NAME("OpenEnumerateInstances");
     {      name = NAME;
         unsigned char c = p[i];  
         buf[n++] = c;  
  
         if (col == 0)      // [HEADER]
             printf("%06X ", (unsigned int)i);  
  
         printf("%02X ", c);      Uint32 flags = 0;
  
         if (col + 1 == sizeof(buf) || i + 1 == size)      if (msg->deepInheritance)
         {          flags |= DEEP_INHERITANCE;
             for (size_t j = col + 1; j < sizeof(buf); j++)  
                 printf("   ");  
  
             for (size_t j = 0; j < n; j++)      if (msg->includeClassOrigin)
             {          flags |= INCLUDE_CLASS_ORIGIN;
                 c = buf[j];  
  
                 if (c >= ' ' && c <= '~')      if (msg->continueOnError)
                     printf("%c", buf[j]);          flags |= CONTINUE_ON_ERROR;
                 else  
                     printf(".");  
             }  
  
             printf("\n");      _putHeader(buf, flags, msg->messageId, OP_OpenEnumerateInstances);
             n = 0;  
         }  
  
         if (col + 1 == sizeof(buf))      // [NAMESPACE]
             col = 0;      buf.putNamespaceName(msg->nameSpace);
         else  
             col++;  
     }  
  
     printf("\n");      // [CLASSNAME]
 }      buf.putName(msg->className);
  
 #endif /* defined(PEGASUS_DEBUG) */      // [PROPERTY-LIST]
       buf.putPropertyList(msg->propertyList);
  
 //==============================================================================      buf.putUint32Arg(msg->maxObjectCount);
 //      buf.putUint32Arg(msg->operationTimeout);
 // BinaryCodec::decodeRequest()      buf.putString(msg->filterQueryLanguage);
 //      buf.putString(msg->filterQuery);
 //==============================================================================  }
  
 CIMOperationRequestMessage* BinaryCodec::decodeRequest(  static CIMOpenEnumerateInstancesRequestMessage*
     const Buffer& in,      _decodeOpenEnumerateInstancesRequest(
       CIMBuffer& in,
     Uint32 queueId,     Uint32 queueId,
     Uint32 returnQueueId)      Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
 { {
     CIMBuffer buf((char*)in.getData(), in.size());      /* See ../Server/CIMOperationRequestDecoder.cpp */
     CIMBufferReleaser buf_(buf);  
  
     // Turn on validation:      STAT_GETSTARTTIME
 #if defined(ENABLE_VALIDATION)  
     buf.setValidate(true);  
 #endif  
  
     Uint32 flags;      Boolean deepInheritance = flags & DEEP_INHERITANCE;
     String messageId;      Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
     Operation operation;      Boolean continueOnError = flags & CONTINUE_ON_ERROR;
  
       // [NAMESPACE]
  
     if (!_getHeader(buf, flags, messageId, operation))      CIMNamespaceName nameSpace;
     {      if (!in.getNamespaceName(nameSpace))
         return 0;         return 0;
     }  
  
     switch (operation)      // [CLASSNAME]
     {      CIMName className;
         case OP_EnumerateInstances:      if (!in.getName(className))
             return _decodeEnumerateInstancesRequest(  
                 buf, queueId, returnQueueId, flags, messageId);  
         case OP_EnumerateInstanceNames:  
             return _decodeEnumerateInstanceNamesRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_GetInstance:  
             return _decodeGetInstanceRequest(  
                 buf, queueId, returnQueueId, flags, messageId);  
         case OP_CreateInstance:  
             return _decodeCreateInstanceRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_ModifyInstance:  
             return _decodeModifyInstanceRequest(  
                 buf, queueId, returnQueueId, flags, messageId);  
         case OP_DeleteInstance:  
             return _decodeDeleteInstanceRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_Associators:  
             return _decodeAssociatorsRequest(  
                 buf, queueId, returnQueueId, flags, messageId);  
         case OP_AssociatorNames:  
             return _decodeAssociatorNamesRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_References:  
             return _decodeReferencesRequest(  
                 buf, queueId, returnQueueId, flags, messageId);  
         case OP_ReferenceNames:  
             return _decodeReferenceNamesRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_GetClass:  
             return _decodeGetClassRequest(  
                 buf, queueId, returnQueueId, flags, messageId);  
         case OP_EnumerateClasses:  
             return _decodeEnumerateClassesRequest(  
                 buf, queueId, returnQueueId, flags, messageId);  
         case OP_EnumerateClassNames:  
             return _decodeEnumerateClassNamesRequest(  
                 buf, queueId, returnQueueId, flags, messageId);  
         case OP_CreateClass:  
             return _decodeCreateClassRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_DeleteClass:  
             return _decodeDeleteClassRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_ModifyClass:  
             return _decodeModifyClassRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_SetQualifier:  
             return _decodeSetQualifierRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_GetQualifier:  
             return _decodeGetQualifierRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_DeleteQualifier:  
             return _decodeDeleteQualifierRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_EnumerateQualifiers:  
             return _decodeEnumerateQualifiersRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_GetProperty:  
            return _decodeGetPropertyRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_SetProperty:  
            return _decodeSetPropertyRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_InvokeMethod:  
            return _decodeInvokeMethodRequest(  
                 buf, queueId, returnQueueId, messageId);  
         case OP_ExecQuery:  
            return _decodeExecQueryRequest(  
                 buf, queueId, returnQueueId, messageId);  
         default:  
             // Unexpected message type  
             PEGASUS_ASSERT(0);  
             return 0;             return 0;
     }  
 }  
  
 //==============================================================================      // [PROPERTY-LIST]
 //      CIMPropertyList propertyList;
 // BinaryCodec::decodeResponse()      if (!in.getPropertyList(propertyList))
 //          return 0;
 //==============================================================================  
  
 CIMResponseMessage* BinaryCodec::decodeResponse(      // These can all be one common function.
     const Buffer& in)      Uint32Arg maxObjectCount;
       if (!in.getUint32Arg(maxObjectCount))
          return 0;
       Uint32Arg operationTimeout;
       if (!in.getUint32Arg(operationTimeout))
           return 0;
       String filterQueryLanguage;
       if (!in.getString(filterQueryLanguage))
           return 0;
       String filterQuery;
       if (!in.getString(filterQuery))
           return 0;
   
       AutoPtr<CIMOpenEnumerateInstancesRequestMessage> request(
           new CIMOpenEnumerateInstancesRequestMessage(
               messageId,
               nameSpace,
               className,
               deepInheritance,
               includeClassOrigin,
               propertyList,
               filterQueryLanguage,
               filterQuery,
               operationTimeout,
               continueOnError,
               maxObjectCount,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   // For the pull Response messages the interface is the message and the,
   // not just the responseData.
   static void _encodeOpenEnumerateInstancesResponseBody(
       CIMBuffer& out,
       CIMOpenEnumerateInstancesResponseMessage* msg,
       CIMResponseData& data,
       CIMName& name)
 { {
     CIMBuffer buf((char*)in.getData(), in.size());      /* See ../Server/CIMOperationResponseEncoder.cpp */
     CIMBufferReleaser buf_(buf);  
  
     return decodeResponse(buf);      static const CIMName NAME("OpenEnumerateInstances");
       name = NAME;
   
       // [endOfSequence]
       out.putBoolean(msg->endOfSequence);
   
       // [enumerationContext]
       out.putString(msg->enumerationContext);
   
       data.encodeBinaryResponse(out);
 } }
  
 CIMResponseMessage* BinaryCodec::decodeResponse(  static CIMOpenEnumerateInstancesResponseMessage*
     CIMBuffer& buf)      _decodeOpenEnumerateInstancesResponse(
       CIMBuffer& in,
       const String& messageId)
 { {
       CIMException cimException;
   
       // KS_TODO Should we set validation???
     // Turn on validation: This is a debugging tool     // Turn on validation: This is a debugging tool
 #if defined(ENABLE_VALIDATION)  //#if defined(ENABLE_VALIDATION)
     buf.setValidate(true);  //    buf.setValidate(true);
 #endif  //#endif
  
     Uint32 flags;      Boolean endOfSequence;
     String messageId;      if (!in.getBoolean(endOfSequence))
     Operation operation;          return 0;
  
     if (!_getHeader(buf, flags, messageId, operation))      String enumerationContext;
     {      if (!in.getString(enumerationContext))
         throw CIMException(CIM_ERR_FAILED, "Corrupt binary message header");  
         return 0;         return 0;
     }  
  
     CIMResponseMessage* msg = 0;      CIMOpenEnumerateInstancesResponseMessage* msg =
           new CIMOpenEnumerateInstancesResponseMessage(
               messageId,
               cimException,
               endOfSequence,
               enumerationContext,
               QueueIdStack());
  
     switch (operation)      // Instead of resolving the binary data here, we delegate this
     {      // to a later point in time when the data is actually retrieved through
         case OP_EnumerateInstances:      // a call to CIMResponseData::getInstances, which
             msg = _decodeEnumerateInstancesResponse(buf, messageId);      // resolves the binary data as it is passed to the next interface.
             break;      // This allows an alternate client implementation to gain direct access
         case OP_EnumerateInstanceNames:      // to the binary data and pass this for example to the JNI implementation
             msg = _decodeEnumerateInstanceNamesResponse(buf, messageId);      // of the JSR48 CIM Client for Java.
       CIMResponseData& responseData = msg->getResponseData();
       responseData.setRemainingBinaryData(in);
   
       msg->binaryRequest=true;
       return msg;
   }
   //==============================================================================
   //
   // OpenEnumerateInstancesPaths
   //
   //==============================================================================
   
   static void _encodeOpenEnumerateInstancePathsRequest(
       CIMBuffer& buf,
       CIMOpenEnumerateInstancePathsRequestMessage* msg,
       CIMName& name)
   {
       /* See ../Client/CIMOperationRequestEncoder.cpp */
   
       static const CIMName NAME("OpenEnumerateInstancePaths");
       name = NAME;
   
       // [HEADER]
   
       Uint32 flags = 0;
   
       if (msg->continueOnError)
           flags |= CONTINUE_ON_ERROR;
   
       _putHeader(buf, flags, msg->messageId, OP_OpenEnumerateInstancePaths);
   
       // [NAMESPACE]
       buf.putNamespaceName(msg->nameSpace);
   
       // [CLASSNAME]
       buf.putName(msg->className);
   
       buf.putUint32Arg(msg->maxObjectCount);
       buf.putUint32Arg(msg->operationTimeout);
       buf.putString(msg->filterQueryLanguage);
       buf.putString(msg->filterQuery);
   }
   
   static CIMOpenEnumerateInstancePathsRequestMessage*
       _decodeOpenEnumerateInstancePathsRequest(
       CIMBuffer& in,
       Uint32 queueId,
       Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
   {
       /* See ../Server/CIMOperationRequestDecoder.cpp */
   
       STAT_GETSTARTTIME
   
       Boolean continueOnError = flags & CONTINUE_ON_ERROR;
   
       // [NAMESPACE]
   
       CIMNamespaceName nameSpace;
       if (!in.getNamespaceName(nameSpace))
           return 0;
   
       // [CLASSNAME]
       CIMName className;
       if (!in.getName(className))
           return 0;
   
       // These can all be one common function.
   
       Uint32Arg maxObjectCount;
       if (!in.getUint32Arg(maxObjectCount))
          return 0;
       Uint32Arg operationTimeout;
       if (!in.getUint32Arg(operationTimeout))
           return 0;
       String filterQueryLanguage;
       if (!in.getString(filterQueryLanguage))
           return 0;
       String filterQuery;
       if (!in.getString(filterQuery))
           return 0;
   
       AutoPtr<CIMOpenEnumerateInstancePathsRequestMessage> request(
           new CIMOpenEnumerateInstancePathsRequestMessage(
               messageId,
               nameSpace,
               className,
               filterQueryLanguage,
               filterQuery,
               operationTimeout,
               continueOnError,
               maxObjectCount,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   
   // For the pull Response messages the interface is the message and the,
   // not just the responseData.
   static void _encodeOpenEnumerateInstancePathsResponseBody(
       CIMBuffer& out,
       CIMOpenEnumerateInstancePathsResponseMessage* msg,
       CIMResponseData& data,
       CIMName& name)
   {
       /* See ../Server/CIMOperationResponseEncoder.cpp */
   
       static const CIMName NAME("OpenEnumerateInstancePaths");
       name = NAME;
   
       // [endOfSequence]
       out.putBoolean(msg->endOfSequence);
   
       // [enumerationContext]
       out.putString(msg->enumerationContext);
   
       data.encodeBinaryResponse(out);
   }
   
   static CIMOpenEnumerateInstancePathsResponseMessage*
       _decodeOpenEnumerateInstancePathsResponse(
       CIMBuffer& in,
       const String& messageId)
   {
       CIMException cimException;
   
       Boolean endOfSequence;
       if (!in.getBoolean(endOfSequence))
           return 0;
   
       String enumerationContext;
       if (!in.getString(enumerationContext))
       {
           return 0;
       }
       CIMOpenEnumerateInstancePathsResponseMessage* msg =
           new CIMOpenEnumerateInstancePathsResponseMessage(
               messageId,
               cimException,
               endOfSequence,
               enumerationContext,
               QueueIdStack());
   
       // Instead of resolving the binary data here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to CIMResponseData::getInstanceNames, which
       // resolves the binary data as it is passed to the next interface.
       // 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;
       return msg;
   }
   //==============================================================================
   //
   // OpenReferenceInstances
   //
   //==============================================================================
   
   static void _encodeOpenReferenceInstancesRequest(
       CIMBuffer& buf,
       CIMOpenReferenceInstancesRequestMessage* msg,
       CIMName& name)
   {
       /* See ../Client/CIMOperationRequestEncoder.cpp */
   
       static const CIMName NAME("OpenReferenceInstances");
       name = NAME;
   
       // [HEADER]
   
       Uint32 flags = 0;
   
       if (msg->includeClassOrigin)
           flags |= INCLUDE_CLASS_ORIGIN;
   
       if (msg->continueOnError)
           flags |= CONTINUE_ON_ERROR;
   
       _putHeader(buf, flags, msg->messageId, OP_OpenReferenceInstances);
   
       // [NAMESPACE]
       buf.putNamespaceName(msg->nameSpace);
   
       // [OBJECT-NAME]
       buf.putObjectPath(msg->objectName);
   
       // [RESULT-CLASS]
       buf.putName(msg->resultClass);
   
       // [ROLE]
       buf.putString(msg->role);
   
       // [PROPERTY-LIST]
       buf.putPropertyList(msg->propertyList);
   
       buf.putUint32Arg(msg->maxObjectCount);
       buf.putUint32Arg(msg->operationTimeout);
       buf.putString(msg->filterQueryLanguage);
       buf.putString(msg->filterQuery);
   }
   
   static CIMOpenReferenceInstancesRequestMessage*
       _decodeOpenReferenceInstancesRequest(
       CIMBuffer& in,
       Uint32 queueId,
       Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
   {
       /* See ../Server/CIMOperationRequestDecoder.cpp */
   
       STAT_GETSTARTTIME
   
       Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
       Boolean continueOnError = flags & CONTINUE_ON_ERROR;
   
       // [NAMESPACE]
   
       CIMNamespaceName nameSpace;
       if (!in.getNamespaceName(nameSpace))
           return 0;
   
       // [OBJECT-NAME]
   
       CIMObjectPath objectName;
   
       if (!in.getObjectPath(objectName))
           return 0;
   
       // [RESULT-CLASS]
   
       CIMName resultClass;
   
       if (!in.getName(resultClass))
           return 0;
   
       // [ROLE]
   
       String role;
   
       if (!in.getString(role))
           return 0;
   
       // [PROPERTY-LIST]
       CIMPropertyList propertyList;
       if (!in.getPropertyList(propertyList))
           return 0;
   
       // These can all be one common function.
       Uint32Arg maxObjectCount;
       if (!in.getUint32Arg(maxObjectCount))
          return 0;
       Uint32Arg operationTimeout;
       if (!in.getUint32Arg(operationTimeout))
           return 0;
       String filterQueryLanguage;
       if (!in.getString(filterQueryLanguage))
           return 0;
       String filterQuery;
       if (!in.getString(filterQuery))
           return 0;
   
       AutoPtr<CIMOpenReferenceInstancesRequestMessage> request(
           new CIMOpenReferenceInstancesRequestMessage(
               messageId,
               nameSpace,
               objectName,
               resultClass,
               role,
               includeClassOrigin,
               propertyList,
               filterQueryLanguage,
               filterQuery,
               operationTimeout,
               continueOnError,
               maxObjectCount,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   // For the pull Response messages the interface is the message and the,
   // not just the responseData.
   static void _encodeOpenReferenceInstancesResponseBody(
       CIMBuffer& out,
       CIMOpenReferenceInstancesResponseMessage* msg,
       CIMResponseData& data,
       CIMName& name)
   {
       /* See ../Server/CIMOperationResponseEncoder.cpp */
   
       static const CIMName NAME("OpenReferenceInstances");
       name = NAME;
   
       // [endOfSequence]
       out.putBoolean(msg->endOfSequence);
   
       // [enumerationContext]
       out.putString(msg->enumerationContext);
   
       data.encodeBinaryResponse(out);
   }
   
   static CIMOpenReferenceInstancesResponseMessage*
       _decodeOpenReferenceInstancesResponse(
       CIMBuffer& in,
       const String& messageId)
   {
       CIMException cimException;
   
       Boolean endOfSequence;
       if (!in.getBoolean(endOfSequence))
           return 0;
   
       String enumerationContext;
       if (!in.getString(enumerationContext))
           return 0;
   
       CIMOpenReferenceInstancesResponseMessage* msg =
           new CIMOpenReferenceInstancesResponseMessage(
               messageId,
               cimException,
               endOfSequence,
               enumerationContext,
               QueueIdStack());
   
       // Instead of resolving the binary data here, we delegate this
       // to a later point in time when the data is actually retrieved through
       // a call to CIMResponseData::getInstances, which
       // resolves the binary data is passed to the next interface.
       // 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;
       return msg;
   }
   //==============================================================================
   //
   // OpenReferenceInstancePaths
   //
   //==============================================================================
   
   static void _encodeOpenReferenceInstancePathsRequest(
       CIMBuffer& buf,
       CIMOpenReferenceInstancePathsRequestMessage* msg,
       CIMName& name)
   {
       /* See ../Client/CIMOperationRequestEncoder.cpp */
   
       static const CIMName NAME("OpenReferenceInstancePaths");
       name = NAME;
   
       // [HEADER]
   
       Uint32 flags = 0;
       if (msg->continueOnError)
           flags |= CONTINUE_ON_ERROR;
   
       _putHeader(buf, flags, msg->messageId, OP_OpenReferenceInstancePaths);
   
       // [NAMESPACE]
       buf.putNamespaceName(msg->nameSpace);
   
       // [OBJECT-NAME]
       buf.putObjectPath(msg->objectName);
   
       // [RESULT-CLASS]
       buf.putName(msg->resultClass);
   
       // [ROLE]
       buf.putString(msg->role);
   
       buf.putUint32Arg(msg->maxObjectCount);
       buf.putUint32Arg(msg->operationTimeout);
       buf.putString(msg->filterQueryLanguage);
       buf.putString(msg->filterQuery);
   }
   
   static CIMOpenReferenceInstancePathsRequestMessage*
       _decodeOpenReferenceInstancePathsRequest(
       CIMBuffer& in,
       Uint32 queueId,
       Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
   {
       /* See ../Server/CIMOperationRequestDecoder.cpp */
   
       STAT_GETSTARTTIME
   
       Boolean continueOnError = flags & CONTINUE_ON_ERROR;
   
       // [NAMESPACE]
   
       CIMNamespaceName nameSpace;
       if (!in.getNamespaceName(nameSpace))
           return 0;
   
       // [OBJECT-NAME]
   
       CIMObjectPath objectName;
       if (!in.getObjectPath(objectName))
           return 0;
   
       // [RESULT-CLASS]
   
       CIMName resultClass;
       if (!in.getName(resultClass))
           return 0;
   
       // [ROLE]
   
       String role;
       if (!in.getString(role))
           return 0;
   
       // These can all be one common function.
       Uint32Arg maxObjectCount;
       if (!in.getUint32Arg(maxObjectCount))
          return 0;
       Uint32Arg operationTimeout;
       if (!in.getUint32Arg(operationTimeout))
           return 0;
       String filterQueryLanguage;
       if (!in.getString(filterQueryLanguage))
           return 0;
       String filterQuery;
       if (!in.getString(filterQuery))
           return 0;
   
       AutoPtr<CIMOpenReferenceInstancePathsRequestMessage> request(
           new CIMOpenReferenceInstancePathsRequestMessage(
               messageId,
               nameSpace,
               objectName,
               resultClass,
               role,
               filterQueryLanguage,
               filterQuery,
               operationTimeout,
               continueOnError,
               maxObjectCount,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   // For the pull Response messages the interface is the message and the,
   // not just the responseData.
   static void _encodeOpenReferenceInstancePathsResponseBody(
       CIMBuffer& out,
       CIMOpenReferenceInstancePathsResponseMessage* msg,
       CIMResponseData& data,
       CIMName& name)
   {
       /* See ../Server/CIMOperationResponseEncoder.cpp */
   
       static const CIMName NAME("OpenReferenceInstancePaths");
       name = NAME;
   
       // [endOfSequence]
       out.putBoolean(msg->endOfSequence);
   
       // [enumerationContext]
       out.putString(msg->enumerationContext);
   
       data.encodeBinaryResponse(out);
   }
   
   static CIMOpenReferenceInstancePathsResponseMessage*
       _decodeOpenReferenceInstancePathsResponse(
       CIMBuffer& in,
       const String& messageId)
   {
       CIMException cimException;
   
       Boolean endOfSequence;
       if (!in.getBoolean(endOfSequence))
           return 0;
   
       String enumerationContext;
       if (!in.getString(enumerationContext))
           return 0;
   
       CIMOpenReferenceInstancePathsResponseMessage* msg =
           new CIMOpenReferenceInstancePathsResponseMessage(
               messageId,
               cimException,
               endOfSequence,
               enumerationContext,
               QueueIdStack());
   
       // 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;
       return msg;
   }
   
   //==============================================================================
   //
   // OpenAssociatorInstances
   //
   //==============================================================================
   
   static void _encodeOpenAssociatorInstancesRequest(
       CIMBuffer& buf,
       CIMOpenAssociatorInstancesRequestMessage* msg,
       CIMName& name)
   {
       /* See ../Client/CIMOperationRequestEncoder.cpp */
   
       static const CIMName NAME("OpenAssociatorInstances");
       name = NAME;
   
       // [HEADER]
   
       Uint32 flags = 0;
   
       if (msg->includeClassOrigin)
           flags |= INCLUDE_CLASS_ORIGIN;
   
       if (msg->continueOnError)
           flags |= CONTINUE_ON_ERROR;
   
       _putHeader(buf, flags, msg->messageId, OP_OpenAssociatorInstances);
   
       // [NAMESPACE]
       buf.putNamespaceName(msg->nameSpace);
   
       // [OBJECT-NAME]
       buf.putObjectPath(msg->objectName);
   
       // [ASSOC-CLASS]
       buf.putName(msg->assocClass);
   
       // [RESULT-CLASS]
       buf.putName(msg->resultClass);
   
       // [ROLE]
       buf.putString(msg->role);
   
       // [RESULT-ROLE]
       buf.putString(msg->resultRole);
   
       // [PROPERTY-LIST]
       buf.putPropertyList(msg->propertyList);
   
       buf.putUint32Arg(msg->maxObjectCount);
       buf.putUint32Arg(msg->operationTimeout);
       buf.putString(msg->filterQueryLanguage);
       buf.putString(msg->filterQuery);
   }
   
   static CIMOpenAssociatorInstancesRequestMessage*
       _decodeOpenAssociatorInstancesRequest(
       CIMBuffer& in,
       Uint32 queueId,
       Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
   {
       /* See ../Server/CIMOperationRequestDecoder.cpp */
   
       STAT_GETSTARTTIME
   
       Boolean includeClassOrigin = flags & INCLUDE_CLASS_ORIGIN;
       Boolean continueOnError = flags & CONTINUE_ON_ERROR;
   
       // [NAMESPACE]
   
       CIMNamespaceName nameSpace;
       if (!in.getNamespaceName(nameSpace))
           return 0;
   
       // [OBJECT-NAME]
   
       CIMObjectPath objectName;
   
       if (!in.getObjectPath(objectName))
           return 0;
   
       // [ASSOC-CLASS]
   
       CIMName assocClass;
   
       if (!in.getName(assocClass))
           return 0;
   
       // [RESULT-CLASS]
   
       CIMName resultClass;
   
       if (!in.getName(resultClass))
           return 0;
   
       // [ROLE]
   
       String role;
   
       if (!in.getString(role))
           return 0;
   
       // [RESULT-ROLE]
   
       String resultRole;
   
       if (!in.getString(resultRole))
           return 0;
   
       // [PROPERTY-LIST]
       CIMPropertyList propertyList;
       if (!in.getPropertyList(propertyList))
           return 0;
   
       // These can all be one common function.
       Uint32Arg maxObjectCount;
       if (!in.getUint32Arg(maxObjectCount))
          return 0;
       Uint32Arg operationTimeout;
       if (!in.getUint32Arg(operationTimeout))
           return 0;
       String filterQueryLanguage;
       if (!in.getString(filterQueryLanguage))
           return 0;
       String filterQuery;
       if (!in.getString(filterQuery))
           return 0;
   
       AutoPtr<CIMOpenAssociatorInstancesRequestMessage> request(
           new CIMOpenAssociatorInstancesRequestMessage(
               messageId,
               nameSpace,
               objectName,
               assocClass,
               resultClass,
               role,
               resultRole,
               includeClassOrigin,
               propertyList,
               filterQueryLanguage,
               filterQuery,
               operationTimeout,
               continueOnError,
               maxObjectCount,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   // For the pull Response messages the interface is the message and the,
   // not just the responseData.
   static void _encodeOpenAssociatorInstancesResponseBody(
       CIMBuffer& out,
       CIMOpenAssociatorInstancesResponseMessage* msg,
       CIMResponseData& data,
       CIMName& name)
   {
       /* See ../Server/CIMOperationResponseEncoder.cpp */
   
       static const CIMName NAME("OpenAssociatorInstances");
       name = NAME;
   
       // [endOfSequence]
       out.putBoolean(msg->endOfSequence);
   
       // [enumerationContext]
       out.putString(msg->enumerationContext);
   
       data.encodeBinaryResponse(out);
   }
   
   static CIMOpenAssociatorInstancesResponseMessage*
       _decodeOpenAssociatorInstancesResponse(
       CIMBuffer& in,
       const String& messageId)
   {
       CIMException cimException;
   
       Boolean endOfSequence;
       if (!in.getBoolean(endOfSequence))
           return 0;
   
       String enumerationContext;
       if (!in.getString(enumerationContext))
           return 0;
   
       CIMOpenAssociatorInstancesResponseMessage* msg =
           new CIMOpenAssociatorInstancesResponseMessage(
               messageId,
               cimException,
               endOfSequence,
               enumerationContext,
               QueueIdStack());
   
       // 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;
       return msg;
   }
   
   //==============================================================================
   //
   // OpenAssociatorInstancePaths
   //
   //==============================================================================
   
   static void _encodeOpenAssociatorInstancePathsRequest(
       CIMBuffer& buf,
       CIMOpenAssociatorInstancePathsRequestMessage* msg,
       CIMName& name)
   {
       /* See ../Client/CIMOperationRequestEncoder.cpp */
   
       static const CIMName NAME("OpenAssociatorInstancePaths");
       name = NAME;
   
       // [HEADER]
   
       Uint32 flags = 0;
   
       if (msg->continueOnError)
           flags |= CONTINUE_ON_ERROR;
   
       _putHeader(buf, flags, msg->messageId, OP_OpenAssociatorInstancePaths);
   
       // [NAMESPACE]
       buf.putNamespaceName(msg->nameSpace);
   
       // [OBJECT-NAME]
       buf.putObjectPath(msg->objectName);
   
       // [ASSOC-CLASS]
       buf.putName(msg->assocClass);
   
       // [RESULT-CLASS]
       buf.putName(msg->resultClass);
   
       // [ROLE]
       buf.putString(msg->role);
   
       // [RESULT-ROLE]
       buf.putString(msg->resultRole);
   
       buf.putUint32Arg(msg->maxObjectCount);
       buf.putUint32Arg(msg->operationTimeout);
       buf.putString(msg->filterQueryLanguage);
       buf.putString(msg->filterQuery);
   }
   
   static CIMOpenAssociatorInstancePathsRequestMessage*
       _decodeOpenAssociatorInstancePathsRequest(
       CIMBuffer& in,
       Uint32 queueId,
       Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
   {
       /* See ../Server/CIMOperationRequestDecoder.cpp */
   
       STAT_GETSTARTTIME
   
       Boolean continueOnError = flags & CONTINUE_ON_ERROR;
   
       // [NAMESPACE]
   
       CIMNamespaceName nameSpace;
       if (!in.getNamespaceName(nameSpace))
           return 0;
   
       // [OBJECT-NAME]
   
       CIMObjectPath objectName;
       if (!in.getObjectPath(objectName))
           return 0;
   
       // [ASSOC-CLASS]
   
       CIMName assocClass;
       if (!in.getName(assocClass))
           return 0;
   
       // [RESULT-CLASS]
   
       CIMName resultClass;
       if (!in.getName(resultClass))
           return 0;
   
       // [ROLE]
   
       String role;
       if (!in.getString(role))
           return 0;
   
       // [RESULT-ROLE]
   
       String resultRole;
       if (!in.getString(resultRole))
           return 0;
   
       // These can all be one common function.
       Uint32Arg maxObjectCount;
       if (!in.getUint32Arg(maxObjectCount))
          return 0;
       Uint32Arg operationTimeout;
       if (!in.getUint32Arg(operationTimeout))
           return 0;
       String filterQueryLanguage;
       if (!in.getString(filterQueryLanguage))
           return 0;
       String filterQuery;
       if (!in.getString(filterQuery))
           return 0;
   
       AutoPtr<CIMOpenAssociatorInstancePathsRequestMessage> request(
           new CIMOpenAssociatorInstancePathsRequestMessage(
               messageId,
               nameSpace,
               objectName,
               assocClass,
               resultClass,
               role,
               resultRole,
               filterQueryLanguage,
               filterQuery,
               operationTimeout,
               continueOnError,
               maxObjectCount,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   
   static void _encodeOpenAssociatorInstancePathsResponseBody(
       CIMBuffer& out,
       CIMOpenAssociatorInstancePathsResponseMessage* msg,
       CIMResponseData& data,
       CIMName& name)
   {
       /* See ../Server/CIMOperationResponseEncoder.cpp */
   
       static const CIMName NAME("OpenAssociatorInstancePaths");
       name = NAME;
   
       // [endOfSequence]
       out.putBoolean(msg->endOfSequence);
   
       // [enumerationContext]
       out.putString(msg->enumerationContext);
   
       data.encodeBinaryResponse(out);
   }
   
   static CIMOpenAssociatorInstancePathsResponseMessage*
       _decodeOpenAssociatorInstancePathsResponse(
       CIMBuffer& in,
       const String& messageId)
   {
       CIMException cimException;
   
       Boolean endOfSequence;
       if (!in.getBoolean(endOfSequence))
           return 0;
   
       String enumerationContext;
       if (!in.getString(enumerationContext))
           return 0;
   
       CIMOpenAssociatorInstancePathsResponseMessage* msg =
           new CIMOpenAssociatorInstancePathsResponseMessage(
               messageId,
               cimException,
               endOfSequence,
               enumerationContext,
               QueueIdStack());
   
       // 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;
       return msg;
   }
   
   //==============================================================================
   //
   // PullInstancesWithPath
   //
   //==============================================================================
   
   static void _encodePullInstancesWithPathRequest(
       CIMBuffer& buf,
       CIMPullInstancesWithPathRequestMessage* msg,
       CIMName& name)
   {
       /* See ../Client/CIMOperationRequestEncoder.cpp */
   
       static const CIMName NAME("PullInstancesWithPath");
       name = NAME;
   
       // [HEADER]
   
       Uint32 flags = 0;
   
       _putHeader(buf, flags, msg->messageId, OP_PullInstancesWithPath);
   
       // [NAMESPACE]
       buf.putNamespaceName(msg->nameSpace);
   
       // [EnumerationContext]
       buf.putString(msg->enumerationContext);
   
       buf.putUint32Arg(msg->maxObjectCount);
   }
   
   static CIMPullInstancesWithPathRequestMessage*
       _decodePullInstancesWithPathRequest(
       CIMBuffer& in,
       Uint32 queueId,
       Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
   {
       /* See ../Server/CIMOperationRequestDecoder.cpp */
   
       STAT_GETSTARTTIME
   
       // [NAMESPACE]
   
       CIMNamespaceName nameSpace;
       if (!in.getNamespaceName(nameSpace))
           return 0;
   
       // [EnumerationContext]
       String enumerationContext;
       if (!in.getString(enumerationContext))
       {
           return 0;
       }
   
       // [MACTCOUNT]
       Uint32Arg maxObjectCount;
       if (!in.getUint32Arg(maxObjectCount))
          return 0;
   
       AutoPtr<CIMPullInstancesWithPathRequestMessage> request(
           new CIMPullInstancesWithPathRequestMessage(
               messageId,
               nameSpace,
               enumerationContext,
               maxObjectCount,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   
   // For the pull Response messages the interface is the message and the,
   // not just the responseData.
   static void _encodePullInstancesWithPathResponseBody(
       CIMBuffer& out,
       CIMPullInstancesWithPathResponseMessage* msg,
       CIMResponseData& data,
       CIMName& name)
   {
       /* See ../Server/CIMOperationResponseEncoder.cpp */
   
       static const CIMName NAME("PullInstancesWithPath");
       name = NAME;
       // [endOfSequence]
       out.putBoolean(msg->endOfSequence);
   
       // [enumerationContext]
       out.putString(msg->enumerationContext);
   
       data.encodeBinaryResponse(out);
   }
   
   static CIMPullInstancesWithPathResponseMessage*
       _decodePullInstancesWithPathResponse(
       CIMBuffer& in,
       const String& messageId)
   {
       CIMException cimException;
   
       Boolean endOfSequence;
       if (!in.getBoolean(endOfSequence))
           return 0;
   
       String enumerationContext;
       if (!in.getString(enumerationContext))
           return 0;
   
       CIMPullInstancesWithPathResponseMessage* msg =
           new CIMPullInstancesWithPathResponseMessage(
               messageId,
               cimException,
               endOfSequence,
               enumerationContext,
               QueueIdStack());
   
       // 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;
       return msg;
   }
   //==============================================================================
   //
   // PullInstancePaths
   //
   //==============================================================================
   
   static void _encodePullInstancePathsRequest(
       CIMBuffer& buf,
       CIMPullInstancePathsRequestMessage* msg,
       CIMName& name)
   {
       /* See ../Client/CIMOperationRequestEncoder.cpp */
   
       static const CIMName NAME("PullInstancePaths");
       name = NAME;
   
       // [HEADER]
   
       Uint32 flags = 0;
   
       _putHeader(buf, flags, msg->messageId, OP_PullInstancePaths);
   
       // [NAMESPACE]
       buf.putNamespaceName(msg->nameSpace);
   
       // [EnumerationContext]
       buf.putString(msg->enumerationContext);
   
       buf.putUint32Arg(msg->maxObjectCount);
   }
   
   static CIMPullInstancePathsRequestMessage*
       _decodePullInstancePathsRequest(
       CIMBuffer& in,
       Uint32 queueId,
       Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
   {
       /* See ../Server/CIMOperationRequestDecoder.cpp */
   
       STAT_GETSTARTTIME
   
       // [NAMESPACE]
   
       CIMNamespaceName nameSpace;
       if (!in.getNamespaceName(nameSpace))
           return 0;
   
       // [EnumerationContext]
       String enumerationContext;
       if (!in.getString(enumerationContext))
       {
           return 0;
       }
   
       // [MAXOBJECTCOUNT]
       Uint32Arg maxObjectCount;
       if (!in.getUint32Arg(maxObjectCount))
          return 0;
   
       AutoPtr<CIMPullInstancePathsRequestMessage> request(
           new CIMPullInstancePathsRequestMessage(
               messageId,
               nameSpace,
               enumerationContext,
               maxObjectCount,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   
   // For the pull Response messages the interface is the message and the,
   // not just the responseData.
   static void _encodePullInstancePathsResponseBody(
       CIMBuffer& out,
       CIMPullInstancePathsResponseMessage* msg,
       CIMResponseData& data,
       CIMName& name)
   {
       /* See ../Server/CIMOperationResponseEncoder.cpp */
   
       static const CIMName NAME("PullInstancePaths");
       name = NAME;
   
       // [endOfSequence]
       out.putBoolean(msg->endOfSequence);
   
       // [enumerationContext]
       out.putString(msg->enumerationContext);
   
       data.encodeBinaryResponse(out);
   }
   
   static CIMPullInstancePathsResponseMessage*
       _decodePullInstancePathsResponse(
       CIMBuffer& in,
       const String& messageId)
   {
       CIMException cimException;
   
       Boolean endOfSequence;
       if (!in.getBoolean(endOfSequence))
           return 0;
   
       String enumerationContext;
       if (!in.getString(enumerationContext))
           return 0;
   
       CIMPullInstancePathsResponseMessage* msg =
           new CIMPullInstancePathsResponseMessage(
               messageId,
               cimException,
               endOfSequence,
               enumerationContext,
               QueueIdStack());
   
       // 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;
       return msg;
   }
   //==============================================================================
   //
   // CloseEnumeration
   //
   //==============================================================================
   
   static void _encodeCloseEnumerationRequest(
       CIMBuffer& buf,
       CIMCloseEnumerationRequestMessage* msg,
       CIMName& name)
   {
       /* See ../Client/CIMOperationRequestEncoder.cpp */
   
       static const CIMName NAME("CloseEnumeration");
       name = NAME;
   
       // [HEADER]
   
       Uint32 flags = 0;
   
       _putHeader(buf, flags, msg->messageId, OP_CloseEnumeration);
   
       // [NAMESPACE]
       buf.putNamespaceName(msg->nameSpace);
   
       // [EnumerationContext]
       buf.putString(msg->enumerationContext);
   }
   
   static CIMCloseEnumerationRequestMessage* _decodeCloseEnumerationRequest(
       CIMBuffer& in,
       Uint32 queueId,
       Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
   {
       /* See ../Server/CIMOperationRequestDecoder.cpp */
   
       STAT_GETSTARTTIME
   
       // [NAMESPACE]
   
       CIMNamespaceName nameSpace;
       if (!in.getNamespaceName(nameSpace))
           return 0;
   
       // [EnumerationContext]
       String enumerationContext;
       if (!in.getString(enumerationContext))
       {
           return 0;
       }
   
       AutoPtr<CIMCloseEnumerationRequestMessage> request(
           new CIMCloseEnumerationRequestMessage(
               messageId,
               nameSpace,
               enumerationContext,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   
   static void _encodeCloseEnumerationResponseBody(
       CIMBuffer& out,
       CIMCloseEnumerationResponseMessage* msg,
       CIMName& name)
   {
       /* See ../Server/CIMOperationResponseEncoder.cpp */
   
       static const CIMName NAME("CloseEnumeration");
       name = NAME;
   }
   
   static CIMCloseEnumerationResponseMessage*
       _decodeCloseEnumerationResponse(
       CIMBuffer& in,
       const String& messageId)
   {
       CIMException cimException;
   
       CIMCloseEnumerationResponseMessage* msg =
           new CIMCloseEnumerationResponseMessage(
               messageId,
               cimException,
               QueueIdStack());
   
       msg->binaryRequest=true;
       return msg;
   }
   //==============================================================================
   //
   // EnumerationCount
   //
   //==============================================================================
   
   static void _encodeEnumerationCountRequest(
       CIMBuffer& buf,
       CIMEnumerationCountRequestMessage* msg,
       CIMName& name)
   {
       /* See ../Client/CIMOperationRequestEncoder.cpp */
   
       static const CIMName NAME("EnumerationCount");
       name = NAME;
   
       // [HEADER]
       Uint32 flags = 0;
   
       _putHeader(buf, flags, msg->messageId, OP_EnumerationCount);
   
       // [NAMESPACE]
       buf.putNamespaceName(msg->nameSpace);
   
       // [EnumerationContext]
       buf.putString(msg->enumerationContext);
   }
   
   static CIMEnumerationCountRequestMessage* _decodeEnumerationCountRequest(
       CIMBuffer& in,
       Uint32 queueId,
       Uint32 returnQueueId,
       Uint32 flags,
       const String& messageId)
   {
       /* See ../Server/CIMOperationRequestDecoder.cpp */
   
       STAT_GETSTARTTIME
   
       // [NAMESPACE]
   
       CIMNamespaceName nameSpace;
       if (!in.getNamespaceName(nameSpace))
           return 0;
   
       // [EnumerationContext]
       String enumerationContext;
       if (!in.getString(enumerationContext))
       {
           return 0;
       }
   
       AutoPtr<CIMEnumerationCountRequestMessage> request(
           new CIMEnumerationCountRequestMessage(
               messageId,
               nameSpace,
               enumerationContext,
               QueueIdStack(queueId, returnQueueId)));
   
       request->binaryRequest = true;
   
       STAT_SERVERSTART
   
       return request.release();
   }
   
   static void _encodeEnumerationCountResponseBody(
       CIMBuffer& out,
       CIMEnumerationCountResponseMessage* msg,
       CIMName& name)
   {
       /* See ../Server/CIMOperationResponseEncoder.cpp */
   
       static const CIMName NAME("EnumerationCount");
       name = NAME;
   
       // [count]
       out.putUint64Arg(msg->count);
   }
   
   static CIMEnumerationCountResponseMessage*
       _decodeEnumerationCountResponse(
       CIMBuffer& in,
       const String& messageId)
   {
       CIMException cimException;
       Uint64 count;
       if (!in.getUint64(count))
           return 0;
   
       CIMEnumerationCountResponseMessage* msg =
           new CIMEnumerationCountResponseMessage(
               messageId,
               cimException,
               QueueIdStack(),
               count);
   
       msg->binaryRequest=true;
       return msg;
   }
   
   // KS_PULL_END
   
   
   //==============================================================================
   //
   // BinaryCodec::hexDump()
   //
   //==============================================================================
   
   #if defined(PEGASUS_DEBUG)
   
   void BinaryCodec::hexDump(const void* data, size_t size)
   {
       unsigned char* p = (unsigned char*)data;
       unsigned char buf[16];
       size_t n = 0;
   
       for (size_t i = 0, col = 0; i < size; i++)
       {
           unsigned char c = p[i];
           buf[n++] = c;
   
           if (col == 0)
               printf("%06X ", (unsigned int)i);
   
           printf("%02X ", c);
   
           if (col + 1 == sizeof(buf) || i + 1 == size)
           {
               for (size_t j = col + 1; j < sizeof(buf); j++)
                   printf("   ");
   
               for (size_t j = 0; j < n; j++)
               {
                   c = buf[j];
   
                   if (c >= ' ' && c <= '~')
                       printf("%c", buf[j]);
                   else
                       printf(".");
               }
   
               printf("\n");
               n = 0;
           }
   
           if (col + 1 == sizeof(buf))
               col = 0;
           else
               col++;
       }
   
       printf("\n");
   }
   
   #endif /* defined(PEGASUS_DEBUG) */
   
   //==============================================================================
   //
   // BinaryCodec::decodeRequest()
   //
   //==============================================================================
   
   CIMOperationRequestMessage* BinaryCodec::decodeRequest(
       const Buffer& in,
       Uint32 queueId,
       Uint32 returnQueueId)
   {
       CIMBuffer buf((char*)in.getData(), in.size());
       CIMBufferReleaser buf_(buf);
   
       // Turn on validation:
   #if defined(ENABLE_VALIDATION)
       buf.setValidate(true);
   #endif
   
       Uint32 flags;
       String messageId;
       Operation operation;
   
       if (!_getHeader(buf, flags, messageId, operation))
       {
           return 0;
       }
   
       switch (operation)
       {
           case OP_EnumerateInstances:
               return _decodeEnumerateInstancesRequest(
                   buf, queueId, returnQueueId, flags, messageId);
           case OP_EnumerateInstanceNames:
               return _decodeEnumerateInstanceNamesRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_GetInstance:
               return _decodeGetInstanceRequest(
                   buf, queueId, returnQueueId, flags, messageId);
           case OP_CreateInstance:
               return _decodeCreateInstanceRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_ModifyInstance:
               return _decodeModifyInstanceRequest(
                   buf, queueId, returnQueueId, flags, messageId);
           case OP_DeleteInstance:
               return _decodeDeleteInstanceRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_Associators:
               return _decodeAssociatorsRequest(
                   buf, queueId, returnQueueId, flags, messageId);
           case OP_AssociatorNames:
               return _decodeAssociatorNamesRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_References:
               return _decodeReferencesRequest(
                   buf, queueId, returnQueueId, flags, messageId);
           case OP_ReferenceNames:
               return _decodeReferenceNamesRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_GetClass:
               return _decodeGetClassRequest(
                   buf, queueId, returnQueueId, flags, messageId);
           case OP_EnumerateClasses:
               return _decodeEnumerateClassesRequest(
                   buf, queueId, returnQueueId, flags, messageId);
           case OP_EnumerateClassNames:
               return _decodeEnumerateClassNamesRequest(
                   buf, queueId, returnQueueId, flags, messageId);
           case OP_CreateClass:
               return _decodeCreateClassRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_DeleteClass:
               return _decodeDeleteClassRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_ModifyClass:
               return _decodeModifyClassRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_SetQualifier:
               return _decodeSetQualifierRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_GetQualifier:
               return _decodeGetQualifierRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_DeleteQualifier:
               return _decodeDeleteQualifierRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_EnumerateQualifiers:
               return _decodeEnumerateQualifiersRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_GetProperty:
              return _decodeGetPropertyRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_SetProperty:
              return _decodeSetPropertyRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_InvokeMethod:
              return _decodeInvokeMethodRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_ExecQuery:
              return _decodeExecQueryRequest(
                   buf, queueId, returnQueueId, messageId);
           case OP_OpenEnumerateInstances:
               return _decodeOpenEnumerateInstancesRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
           case OP_OpenEnumerateInstancePaths:
               return _decodeOpenEnumerateInstancePathsRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
           case OP_OpenReferenceInstances:
               return _decodeOpenReferenceInstancesRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
           case OP_OpenReferenceInstancePaths:
               return _decodeOpenReferenceInstancePathsRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
           case OP_OpenAssociatorInstances:
               return _decodeOpenAssociatorInstancesRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
           case OP_OpenAssociatorInstancePaths:
               return _decodeOpenAssociatorInstancePathsRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
           case OP_PullInstancesWithPath:
               return _decodePullInstancesWithPathRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
           case OP_PullInstancePaths:
               return _decodePullInstancePathsRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
           case OP_CloseEnumeration:
               return _decodeCloseEnumerationRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
           case OP_EnumerationCount:
               return _decodeEnumerationCountRequest(
                   buf, queueId, returnQueueId, flags, messageId);
               break;
   
           default:
               // Unexpected message type
               PEGASUS_ASSERT(0);
               return 0;
       }
   }
   
   //==============================================================================
   //
   // BinaryCodec::decodeResponse()
   //
   //==============================================================================
   
   CIMResponseMessage* BinaryCodec::decodeResponse(
       const Buffer& in)
   {
       CIMBuffer buf((char*)in.getData(), in.size());
       CIMBufferReleaser buf_(buf);
   
       return decodeResponse(buf);
   }
   
   CIMResponseMessage* BinaryCodec::decodeResponse(
       CIMBuffer& buf)
   {
       // Turn on validation:
   #if defined(ENABLE_VALIDATION)
       buf.setValidate(true);
   #endif
       Uint32 flags;
       String messageId;
       Operation operation;
   
       if (!_getHeader(buf, flags, messageId, operation))
       {
           throw CIMException(CIM_ERR_FAILED, "Corrupt binary message header");
           return 0;
       }
   
       CIMResponseMessage* msg = 0;
   
       switch (operation)
       {
           case OP_EnumerateInstances:
               msg = _decodeEnumerateInstancesResponse(buf, messageId);
               break;
           case OP_EnumerateInstanceNames:
               msg = _decodeEnumerateInstanceNamesResponse(buf, messageId);
             break;             break;
         case OP_GetInstance:         case OP_GetInstance:
             msg = _decodeGetInstanceResponse(buf, messageId);             msg = _decodeGetInstanceResponse(buf, messageId);
Line 3292 
Line 4930 
         case OP_ExecQuery:         case OP_ExecQuery:
             msg = _decodeExecQueryResponse(buf, messageId);             msg = _decodeExecQueryResponse(buf, messageId);
             break;             break;
           case OP_OpenEnumerateInstances:
               msg = _decodeOpenEnumerateInstancesResponse(buf, messageId);
               break;
           case OP_OpenEnumerateInstancePaths:
               msg = _decodeOpenEnumerateInstancePathsResponse(buf, messageId);
               break;
           case OP_OpenReferenceInstances:
               msg = _decodeOpenReferenceInstancesResponse(buf, messageId);
               break;
           case OP_OpenReferenceInstancePaths:
               msg = _decodeOpenReferenceInstancePathsResponse(buf, messageId);
               break;
           case OP_OpenAssociatorInstances:
               msg = _decodeOpenAssociatorInstancesResponse(buf, messageId);
               break;
           case OP_OpenAssociatorInstancePaths:
               msg = _decodeOpenAssociatorInstancePathsResponse(buf, messageId);
               break;
           case OP_PullInstancesWithPath:
               msg = _decodePullInstancesWithPathResponse(buf, messageId);
               break;
           case OP_PullInstancePaths:
               msg = _decodePullInstancePathsResponse(buf, messageId);
               break;
           case OP_CloseEnumeration:
               msg = _decodeCloseEnumerationResponse(buf, messageId);
               break;
   
         default:         default:
             // Unexpected message type             // Unexpected message type
             PEGASUS_ASSERT(0);             PEGASUS_ASSERT(0);
Line 3299 
Line 4965 
     }     }
  
     if (!msg)     if (!msg)
         throw CIMException(CIM_ERR_FAILED, "Received corrupted binary message");          throw CIMException(CIM_ERR_FAILED,
               "Received corrupted binary message");
  
     return msg;     return msg;
 } }
Line 3315 
Line 4982 
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguageList& httpContentLanguages,     const ContentLanguageList& httpContentLanguages,
       const Buffer& rtnParams,
     const Buffer& body,     const Buffer& body,
     Uint64 serverResponseTime,     Uint64 serverResponseTime,
     Boolean isFirst,     Boolean isFirst,
     Boolean isLast)     Boolean isLast)
 { {
     Buffer out;     Buffer out;
   
     if (isFirst == true)     if (isFirst == true)
     {     {
         // Write HTTP header:         // Write HTTP header:
Line 3338 
Line 5005 
     {     {
         out.append(body.getData(), body.size());         out.append(body.getData(), body.size());
     }     }
       // EXP_PULL TODO - TBD Review this.
       // If there are any parameters include them here.
       // Assumes that it is prebuilt with all components
       //
       if (rtnParams.size() != 0)
       {
           out << rtnParams;
       }
       //
       // //EXP_PULL_END
  
     return out;     return out;
 } }
Line 3527 
Line 5204 
                 (CIMExecQueryRequestMessage*)msg, name);                 (CIMExecQueryRequestMessage*)msg, name);
             break;             break;
         }         }
           case CIM_OPEN_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
           {
               _encodeOpenEnumerateInstancesRequest(buf,
                   (CIMOpenEnumerateInstancesRequestMessage*)msg, name);
               break;
           }
   
           case CIM_OPEN_ENUMERATE_INSTANCE_PATHS_REQUEST_MESSAGE:
           {
               _encodeOpenEnumerateInstancePathsRequest(buf,
                   (CIMOpenEnumerateInstancePathsRequestMessage*)msg, name);
               break;
           }
           case CIM_OPEN_ASSOCIATOR_INSTANCES_REQUEST_MESSAGE:
           {
               _encodeOpenAssociatorInstancesRequest(buf,
                   (CIMOpenAssociatorInstancesRequestMessage*)msg, name);
               break;
           }
           case CIM_OPEN_ASSOCIATOR_INSTANCE_PATHS_REQUEST_MESSAGE:
           {
               _encodeOpenAssociatorInstancePathsRequest(buf,
                   (CIMOpenAssociatorInstancePathsRequestMessage*)msg, name);
               break;
           }
           case CIM_OPEN_REFERENCE_INSTANCES_REQUEST_MESSAGE:
           {
               _encodeOpenReferenceInstancesRequest(buf,
                   (CIMOpenReferenceInstancesRequestMessage*)msg, name);
               break;
           }
           case CIM_OPEN_REFERENCE_INSTANCE_PATHS_REQUEST_MESSAGE:
           {
               _encodeOpenReferenceInstancePathsRequest(buf,
                   (CIMOpenReferenceInstancePathsRequestMessage*)msg, name);
               break;
           }
           case CIM_PULL_INSTANCES_WITH_PATH_REQUEST_MESSAGE:
           {
               _encodePullInstancesWithPathRequest(buf,
                   (CIMPullInstancesWithPathRequestMessage*)msg, name);
               break;
           }
           case CIM_PULL_INSTANCE_PATHS_REQUEST_MESSAGE:
           {
               _encodePullInstancePathsRequest(buf,
                   (CIMPullInstancePathsRequestMessage*)msg, name);
               break;
           }
           case CIM_CLOSE_ENUMERATION_REQUEST_MESSAGE:
           {
               _encodeCloseEnumerationRequest(buf,
                   (CIMCloseEnumerationRequestMessage*)msg, name);
               break;
           }
           // KS_TODO Implement these functions.
           case CIM_ENUMERATION_COUNT_REQUEST_MESSAGE:
           {
               _encodeEnumerationCountRequest(buf,
                   (CIMEnumerationCountRequestMessage*)msg, name);
               break;
           }
  
         default:         default:
             // Unexpected message type             // Unexpected message type
Line 3739 
Line 5478 
  
         case CIM_EXEC_QUERY_RESPONSE_MESSAGE:         case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
         {         {
             _encodeExecQueryResponseBody(              _encodeExecQueryResponseBody(buf,
                 buf,  
                 ((CIMExecQueryResponseMessage*)msg)->getResponseData(),                 ((CIMExecQueryResponseMessage*)msg)->getResponseData(),
                 name);                 name);
             break;             break;
         }         }
  
           case CIM_OPEN_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
           {
               _encodeOpenEnumerateInstancesResponseBody(buf,
                   (CIMOpenEnumerateInstancesResponseMessage*)msg,
                   ((CIMOpenEnumerateInstancesResponseMessage*)msg)->
                                                         getResponseData(),
                   name);
               break;
           }
   
           case CIM_OPEN_ENUMERATE_INSTANCE_PATHS_RESPONSE_MESSAGE:
           {
               _encodeOpenEnumerateInstancePathsResponseBody(buf,
                   (CIMOpenEnumerateInstancePathsResponseMessage*)msg,
                   ((CIMOpenEnumerateInstancePathsResponseMessage*)msg)->
                                                             getResponseData(),
                   name);
               break;
           }
   
           case CIM_OPEN_REFERENCE_INSTANCES_RESPONSE_MESSAGE:
           {
               _encodeOpenReferenceInstancesResponseBody(buf,
                   (CIMOpenReferenceInstancesResponseMessage*)msg,
                   ((CIMOpenReferenceInstancesResponseMessage*)msg)->
                                                         getResponseData(),
                   name);
               break;
           }
   
           case CIM_OPEN_REFERENCE_INSTANCE_PATHS_RESPONSE_MESSAGE:
           {
               _encodeOpenReferenceInstancePathsResponseBody(buf,
                   (CIMOpenReferenceInstancePathsResponseMessage*)msg,
                   ((CIMOpenReferenceInstancePathsResponseMessage*)msg)->
                                                             getResponseData(),
                   name);
               break;
           }
           case CIM_OPEN_ASSOCIATOR_INSTANCES_RESPONSE_MESSAGE:
           {
               _encodeOpenAssociatorInstancesResponseBody(buf,
                   (CIMOpenAssociatorInstancesResponseMessage*)msg,
                   ((CIMOpenAssociatorInstancesResponseMessage*)msg)->
                                                         getResponseData(),
                   name);
               break;
           }
   
           case CIM_OPEN_ASSOCIATOR_INSTANCE_PATHS_RESPONSE_MESSAGE:
           {
               _encodeOpenAssociatorInstancePathsResponseBody(buf,
                   (CIMOpenAssociatorInstancePathsResponseMessage*)msg,
                   ((CIMOpenAssociatorInstancePathsResponseMessage*)msg)->
                                                             getResponseData(),
                   name);
               break;
           }
   
           case CIM_PULL_INSTANCES_WITH_PATH_RESPONSE_MESSAGE:
           {
               _encodePullInstancesWithPathResponseBody(buf,
                   (CIMPullInstancesWithPathResponseMessage*)msg,
                   ((CIMPullInstancesWithPathResponseMessage*)msg)->
                                                         getResponseData(),
                   name);
               break;
           }
   
           case CIM_PULL_INSTANCE_PATHS_RESPONSE_MESSAGE:
           {
               _encodePullInstancePathsResponseBody(buf,
                   (CIMPullInstancePathsResponseMessage*)msg,
                   ((CIMPullInstancePathsResponseMessage*)msg)->
                                                         getResponseData(),
                   name);
               break;
           }
           case CIM_CLOSE_ENUMERATION_RESPONSE_MESSAGE:
           {
               _encodeCloseEnumerationResponseBody(buf,
                   (CIMCloseEnumerationResponseMessage*)msg,
                   name);
               break;
           }
           case CIM_ENUMERATION_COUNT_RESPONSE_MESSAGE:
           {
               _encodeEnumerationCountResponseBody(buf,
                   (CIMEnumerationCountResponseMessage*)msg,
                   name);
               break;
           }
   
         default:         default:
             // Unexpected message type             // Unexpected message type
             PEGASUS_ASSERT(0);             PEGASUS_ASSERT(0);

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