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

Diff for /pegasus/src/Pegasus/Common/CIMResponseData.cpp between version 1.5.2.13 and 1.7

version 1.5.2.13, 2013/10/13 21:31:59 version 1.7, 2011/02/02 05:43:48
Line 27 
Line 27 
 // //
 ////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
 // //
 // Class CIMResponseData encapsulates the possible types of response data  
 // representations and supplies conversion methods between these types.  
 // PEP#348 - The CMPI infrastructure using SCMO (Single Chunk Memory Objects)  
 // describes its usage in the server flow.  
 // The design document can be found on the OpenPegasus website openpegasus.org  
 // at https://collaboration.opengroup.org/pegasus/pp/documents/21210/PEP_348.pdf  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "CIMResponseData.h" #include "CIMResponseData.h"
Line 44 
Line 37 
 #include <Pegasus/Common/CIMInternalXmlEncoder.h> #include <Pegasus/Common/CIMInternalXmlEncoder.h>
 #include <Pegasus/Common/SCMOInternalXmlEncoder.h> #include <Pegasus/Common/SCMOInternalXmlEncoder.h>
  
 // KS_TODO_DELETE  
 #include <Pegasus/Common/Print.h>  
   
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 // Defines debug code in CIMResponseData.  This under this  
 // special compile flag so that it can be compiled independent of  
 // PEGASUS_DEBUG flags.  
 #define CIMRESPONSEDATA_DEBUG  
   
 #define LOCAL_MIN(a, b) ((a < b) ? a : b)  
 // C++ objects interface handling // C++ objects interface handling
  
 // KS_TODO Remove this completely when finished testing.  
 bool CIMResponseData::sizeValid()  
 {  
     PEGASUS_DEBUG_ASSERT(valid());  
 #ifdef CIMRESPONSEDATA_DEBUG  
     if (_size > 1000000)  
     {  
         cout << "CIMResponseData::PSVALID _size too big " << _size << endl;  
         PEG_TRACE((TRC_XML, Tracer::LEVEL4,  
                    "CIMResponseData::PSVALID _size too big %u",_size ));  
         return false;  
     }  
 #endif  
     PEG_TRACE((TRC_XML, Tracer::LEVEL4,  
         "CIMResponseData Size _size=%u", _size));  
     return true;  
 }  
 // Instance Names handling // Instance Names handling
 Array<CIMObjectPath>& CIMResponseData::getInstanceNames() Array<CIMObjectPath>& CIMResponseData::getInstanceNames()
 { {
     PSVALID;  
     PEGASUS_DEBUG_ASSERT(     PEGASUS_DEBUG_ASSERT(
     (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));     (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));
     _resolveToCIM();     _resolveToCIM();
Line 87 
Line 53 
     return _instanceNames;     return _instanceNames;
 } }
  
 // Get a single instance as a CIM instance.  // Instance handling
 // This converts all of the objects in the response data to  
 // CIM form as part of the conversion.  
 // If there are no instances in the object, returns CIMInstance(),  
 // an empty instance.  
 CIMInstance& CIMResponseData::getInstance() CIMInstance& CIMResponseData::getInstance()
 { {
     PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);     PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);
Line 111 
Line 73 
     return _instances;     return _instances;
 } }
  
 // Instances handling specifically for the client where the call may  
 // get either instances or objects and must convert them to instances  
 // NOTE: This is a temporary solution to satisfy the BinaryCodec passing  
 // of data to the client where the data could be either instances or  
 // objects.  The correct solution is to convert back when the provider, etc.  
 // returns the data to the server.  We must convert to that solution but  
 // this keeps it working for the moment.  
 Array<CIMInstance>& CIMResponseData::getInstancesFromInstancesOrObjects()  
 {  
     if (_dataType == RESP_INSTANCES)  
     {  
         _resolveToCIM();  
         return _instances;  
     }  
     else if (_dataType == RESP_OBJECTS)  
     {  
         _resolveToCIM();  
         for (Uint32 i = 0 ; i < _objects.size() ; i++)  
         {  
             _instances.append((CIMInstance)_objects[i]);  
         }  
         return _instances;  
   
     }  
     PEGASUS_ASSERT(false);  
 }  
   
 // Objects handling // Objects handling
 Array<CIMObject>& CIMResponseData::getObjects() Array<CIMObject>& CIMResponseData::getObjects()
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::getObjects");  
     PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);     PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);
     _resolveToCIM();     _resolveToCIM();
     PEG_METHOD_EXIT();  
     return _objects;     return _objects;
 } }
  
 // SCMO representation, single instance stored as one element array // SCMO representation, single instance stored as one element array
 // object paths are represented as SCMOInstance // object paths are represented as SCMOInstance
 // Resolve all of the information in the CIMResponseData container to  
 // SCMO  and return all scmoInstances.  
 // Note that since the SCMO representation,  
 // a is single instance stored as one element array and object paths are  
 // represented as SCMOInstance this returns array of SCMOInstance.  
 Array<SCMOInstance>& CIMResponseData::getSCMO() Array<SCMOInstance>& CIMResponseData::getSCMO()
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::getSCMO");  
     // This function resolves to instances and so cannot handle responses to  
     // the associators,etc.requests that return classes (input object path with  
     // no keys). That issue is resolved however, since CIMResponseData uses the  
     // _isClassOperation variable (set by the request) to determine whether  
     // the responses are classpaths or instancepaths and the default is  
     // false(instancePaths) so that this should always produce instance paths.  
   
     _resolveToSCMO();     _resolveToSCMO();
     PEG_METHOD_EXIT();  
     return _scmoInstances;     return _scmoInstances;
 } }
  
 // set an array of SCMOInstances into the response data object  
 void CIMResponseData::setSCMO(const Array<SCMOInstance>& x) void CIMResponseData::setSCMO(const Array<SCMOInstance>& x)
 { {
   
     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setSCMO");  
     //// AutoMutex autoMut(testLock);  
     PSVALID;  
     _scmoInstances=x;     _scmoInstances=x;
     _encoding |= RESP_ENC_SCMO;     _encoding |= RESP_ENC_SCMO;
     _size += x.size();  
     PEG_METHOD_EXIT();  
 } }
  
   
 // Binary data is just a data stream // Binary data is just a data stream
 Array<Uint8>& CIMResponseData::getBinary() Array<Uint8>& CIMResponseData::getBinary()
 { {
Line 193 
Line 106 
 bool CIMResponseData::setBinary(CIMBuffer& in) bool CIMResponseData::setBinary(CIMBuffer& in)
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setBinary");     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setBinary");
     //// AutoMutex autoMut(testLock);  
  
     // Append all serial data from the CIMBuffer to the local data store.     // Append all serial data from the CIMBuffer to the local data store.
     // Returns error if input not a serialized Uint8A     // Returns error if input not a serialized Uint8A
Line 211 
Line 123 
  
 bool CIMResponseData::setRemainingBinaryData(CIMBuffer& in) bool CIMResponseData::setRemainingBinaryData(CIMBuffer& in)
 { {
     //// AutoMutex autoMut(testLock);  
     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setRemainingBinaryData");     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setRemainingBinaryData");
  
     // Append any data that has not been deserialized already from     // Append any data that has not been deserialized already from
Line 226 
Line 137 
  
 bool CIMResponseData::setXml(CIMBuffer& in) bool CIMResponseData::setXml(CIMBuffer& in)
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setXml");  
   
     switch (_dataType)     switch (_dataType)
     {     {
         case RESP_INSTANCE:         case RESP_INSTANCE:
Line 264 
Line 173 
                 return false;                 return false;
             }             }
             _nameSpacesData.insert(0,ns);             _nameSpacesData.insert(0,ns);
             _size++;  
             break;             break;
         }         }
         case RESP_INSTANCES:         case RESP_INSTANCES:
Line 311 
Line 219 
                 _hostsData.append(host);                 _hostsData.append(host);
                 _nameSpacesData.append(ns);                 _nameSpacesData.append(ns);
             }             }
             _size += count;  
             break;             break;
         }         }
         case RESP_OBJECTS:         case RESP_OBJECTS:
Line 358 
Line 265 
                 _hostsData.append(host);                 _hostsData.append(host);
                 _nameSpacesData.append(ns);                 _nameSpacesData.append(ns);
             }             }
             _size += count;  
             break;             break;
         }         }
         // internal xml encoding of instance names and object paths not         // internal xml encoding of instance names and object paths not
Line 367 
Line 273 
         case RESP_OBJECTPATHS:         case RESP_OBJECTPATHS:
         default:         default:
         {         {
             PEGASUS_ASSERT(false);              PEGASUS_DEBUG_ASSERT(false);
         }         }
     }     }
     _encoding |= RESP_ENC_XML;     _encoding |= RESP_ENC_XML;
   
     PEG_METHOD_EXIT();  
     return true;     return true;
 } }
  
 // Move the number of objects defined by the input parameter from  
 // one CIMResponse Object to another CIMResponse Object.  
 // Returns the new size of the CIMResponseData object.  
 // NOTE: This is not protected by a mutex so the user must be certain  
 // that the from object is not used during the move.  
 Uint32 CIMResponseData::moveObjects(CIMResponseData & from, Uint32 count)  
 {  
     PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::moveObjects");  
   
     //// AutoMutex autoMut(testLock);  
   
     PEG_TRACE((TRC_XML, Tracer::LEVEL3,  
         "CIMResponseData::move(%u)", count));  
   
     PEGASUS_DEBUG_ASSERT(valid());                 // KS_TEMP  
     PEGASUS_DEBUG_ASSERT(_size == 0);    // Validate size == 0 or fix below  
     PEGASUS_DEBUG_ASSERT(_dataType == from._dataType);  
   
     Uint32 rtnSize = 0;  
     Uint32 toMove = count;  
   
     if (RESP_ENC_XML == (from._encoding & RESP_ENC_XML))  
     {  
         switch (_dataType)  
         {  
             case RESP_OBJECTPATHS:  
             case RESP_INSTNAMES:  
                 break;  
             case RESP_INSTANCE:  
                 {  
                     if (from._instanceData.size() > 0)  
                     {  
                         // temp test to assure all sizes are the same.  
                         PEGASUS_DEBUG_ASSERT(from._hostsData.size() ==  
                                         from._instanceData.size());  
                         PEGASUS_DEBUG_ASSERT(from._referencesData.size() ==  
                                         from._instanceData.size());  
                         PEGASUS_DEBUG_ASSERT(from._nameSpacesData.size() ==  
                                         from._instanceData.size());  
                         _instanceData.append(from._instanceData.getData(),1);  
                         from._instanceData.remove(0, 1);  
                         _referencesData.append(  
                             from._referencesData.getData(),1);  
                         from._referencesData.remove(0, 1);  
                         if (_hostsData.size())  
                         {  
                             _hostsData.append(from._hostsData.getData(),1);  
                             from._hostsData.remove(0, 1);  
                         }  
                         if (_nameSpacesData.size())  
                         {  
                             _nameSpacesData.append(  
                                 from._nameSpacesData.getData(),1);  
                             from._nameSpacesData.remove(0, 1);  
                         }  
                         rtnSize += 1;  
                         toMove--;  
                         _encoding |= RESP_ENC_XML;  
                     }  
                 }  
                 break;  
   
             // KS-TODO The above could probably be folded into the following.  
             // Need something like an assert if there is ever more than  
             // one instance in _instanceData for type RESP_INSTANCE  
             case RESP_INSTANCES:  
             case RESP_OBJECTS:  
                 {  
                     Uint32 moveCount = LOCAL_MIN(toMove,  
                                                  from._instanceData.size());  
   
                     PEGASUS_DEBUG_ASSERT(from._referencesData.size() ==  
                                     from._instanceData.size());  
                     _instanceData.append(from._instanceData.getData(),  
                                          moveCount);  
                     from._instanceData.remove(0, moveCount);  
                     _referencesData.append(from._referencesData.getData(),  
                                            moveCount);  
                     from._referencesData.remove(0, moveCount);  
                     _hostsData.append(from._hostsData.getData(),  
                                          moveCount);  
                     from._hostsData.remove(0, moveCount);  
                     _nameSpacesData.append(from._nameSpacesData.getData(),  
                                          moveCount);  
                     from._nameSpacesData.remove(0, moveCount);  
                     rtnSize += moveCount;  
                     toMove -= moveCount;  
                     _encoding |= RESP_ENC_XML;  
                 }  
                 break;  
         }  
     }  
     if (RESP_ENC_BINARY == (from._encoding & RESP_ENC_BINARY))  
     {  
         // Cannot resolve this one without actually processing  
         // the data since it is a stream. Concluded that we do not  
         // want to do that since cost higher than gain.  Therefore we do  
         // not allow this option.  Should only mean that provider agent  
         // cannot generate binary for pull operations.  
         rtnSize += 0;  
         PEGASUS_ASSERT(false);  
     }  
   
     if (RESP_ENC_SCMO == (from._encoding & RESP_ENC_SCMO))  
     {  
         Uint32 moveCount = LOCAL_MIN(toMove, from._scmoInstances.size());  
   
         _scmoInstances.append(from._scmoInstances.getData(), moveCount);  
         from._scmoInstances.remove(0, moveCount);  
         rtnSize += moveCount;  
         toMove -= moveCount;  
         _encoding |= RESP_ENC_SCMO;  
     }  
   
     if (RESP_ENC_CIM == (from._encoding & RESP_ENC_CIM))  
     {  
         switch (_dataType)  
         {  
             case RESP_OBJECTPATHS:  
             case RESP_INSTNAMES:  
                 {  
                     Uint32 moveCount = LOCAL_MIN(toMove,  
                                                  from._instanceNames.size());  
   
                     _instanceNames.append(  
                         from._instanceNames.getData(), moveCount);  
                     from._instanceNames.remove(0, moveCount);  
                     rtnSize += moveCount;  
                     toMove -= moveCount;  
                     _encoding |= RESP_ENC_CIM;  
                 }  
                 break;  
             case RESP_INSTANCE:  
             case RESP_INSTANCES:  
                 {  
   
                     Uint32 moveCount = LOCAL_MIN(toMove,  
                                                  from._instances.size());  
   
                     _instances.append(from._instances.getData(), moveCount);  
                     from._instances.remove(0, moveCount);  
                     rtnSize += moveCount;  
                     toMove -= moveCount;  
                     _encoding |= RESP_ENC_CIM;  
                 }  
                 break;  
             case RESP_OBJECTS:  
                 {  
                     Uint32 moveCount = LOCAL_MIN(toMove,  
                                                  from._objects.size());  
                     _objects.append(from._objects.getData(), moveCount);  
                     from._objects.remove(0, moveCount);  
                     rtnSize += moveCount;  
                     toMove -= moveCount;  
                     _encoding |= RESP_ENC_CIM;  
                 }  
                 break;  
         }  
     }  
     PEGASUS_ASSERT(rtnSize == (count - toMove));  
   
     _size += rtnSize;  
   
     // insure that _size never goes negative.  This is probably a  
     // diagnostics KS_TODO remove before release  
     if (from._size >= rtnSize)  
     {  
   
         from._size -= rtnSize;  
     }  
     else  
     {  
         from._size = 0;  
         //// KS_TODO Diagnostic since this should never occur  
         PEG_TRACE((TRC_XML, Tracer::LEVEL1,  
             "Size in from set to zero from= %u rtnSize= %u",  
                 from._size, rtnSize));  
     }  
   
     //// KS_TODO diagnostic that we should be able to remove  
     if (rtnSize != _size)  
     {  
         PEG_TRACE((TRC_XML, Tracer::LEVEL1,  
             "Size calc error _size %u rtnSWize = %u", _size, rtnSize));  
     }  
     PEG_METHOD_EXIT();  
     return rtnSize;  
 }  
   
 Boolean CIMResponseData::hasBinaryData() const  
 {  
     return (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY));  
 }  
 // Sets the _size variable based on the internal size counts.  
 void CIMResponseData::setSize()  
 {  
     PEGASUS_DEBUG_ASSERT(valid());            //KS_TEMP KS_TODO  
   
     Uint32 rtnSize = 0;  
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))  
     {  
         switch (_dataType)  
         {  
             case RESP_OBJECTPATHS:  
             case RESP_INSTNAMES:  
                 break;  
             case RESP_INSTANCE:  
                 rtnSize +=1;  
                 break;  
             case RESP_INSTANCES:  
             case RESP_OBJECTS:  
                 rtnSize += _instanceData.size();  
                 break;  
         }  
     }  
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))  
     {  
         // KS_PULL_TODO  
         // Cannot resolve this one without actually processing  
         // the data since it is a stream.  
         rtnSize += 0;  
     }  
   
     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))  
     {  
         rtnSize += _scmoInstances.size();  
     }  
   
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))  
     {  
         switch (_dataType)  
         {  
             case RESP_OBJECTPATHS:  
             case RESP_INSTNAMES:  
                 rtnSize += _instanceNames.size();  
                 break;  
             case RESP_INSTANCE:  
             case RESP_INSTANCES:  
                 rtnSize += _instances.size();  
                 break;  
             case RESP_OBJECTS:  
                 rtnSize += _objects.size();  
                 break;  
         }  
     }  
     _size = rtnSize;  
 }  
   
 // Return the number of CIM objects in the CIM Response data object  
 //  
 #define TEMPLOG PEG_TRACE((TRC_XML, Tracer::LEVEL4, \  
  "rtnSize %u size %u line %u", rtnSize, _size, __LINE__))  
 //#define TEMPLOG cout << "rtnSize " << rtnSize << " _size " << _size  
 //<< " line " << __LINE__ << endl  
   
 Uint32 CIMResponseData::size()  
 {  
     AutoMutex autoMut(testLock);  
     PEG_METHOD_ENTER(TRC_XML,"CIMResponseData::size()");  
     PSVALID;  
 // If debug mode, add up all the individual size components to  
 // determine overall size of this object.  Then compare this with  
 // the _size variable.  this is a good check on the completeness of the  
 // size computations.  We should be able to remove this at some point  
 // but there are many sources of size info and we need to be sure we  
 // have covered them all.  
 #ifdef PEGASUS_DEBUG  
     PEGASUS_DEBUG_ASSERT(valid());            //KS_TEMP KS_TODO  
   
     Uint32 rtnSize = 0;  
     TEMPLOG;  
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))  
     {  
         TEMPLOG;  
         switch (_dataType)  
         {  
             case RESP_OBJECTPATHS:  
             case RESP_INSTNAMES:  
                 break;  
             case RESP_INSTANCE:  
                 rtnSize +=1;  
                 break;  
             case RESP_INSTANCES:  
             case RESP_OBJECTS:  
                 rtnSize += _instanceData.size();  
                 break;  
         }  
         PSVALID;  
         TEMPLOG;  
     }  
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))  
     {  
         TEMPLOG;  
         // KS_PULL_TODO  
         // Cannot resolve this one without actually processing  
         // the data since it is a stream.  
         rtnSize += 0;  
         //  KS_TODO flag on this one  
         //// PEGASUS_ASSERT(false);  
         TEMPLOG;  
     }  
   
     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))  
     {  
         PSVALID;  
         TEMPLOG;  
         rtnSize += _scmoInstances.size();  
         TEMPLOG;  
     }  
   
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))  
     {  
         PSVALID;  
         TEMPLOG;  
         switch (_dataType)  
         {  
             case RESP_OBJECTPATHS:  
             case RESP_INSTNAMES:  
                 rtnSize += _instanceNames.size();  
                 break;  
             case RESP_INSTANCE:  
             case RESP_INSTANCES:  
                 rtnSize += _instances.size();  
                 break;  
             case RESP_OBJECTS:  
                 rtnSize += _objects.size();  
                 break;  
         }  
         PSVALID;  
         TEMPLOG;  
     }  
     // Test of actual count against _size variable. KS_TODO diagnostic  
     if (rtnSize != _size)  
     {  
         TEMPLOG;  
         PSVALID;  
         PEG_TRACE((TRC_XML, Tracer::LEVEL1,  
         "CIMResponseData::size ERROR. debug size mismatch."  
             "Computed = %u. variable = %u",rtnSize, _size ));  
         // KS_TEMP  
         cout << "Size err Computed(rtnsize)=" << rtnSize << " _size=" << _size  
              << " diff=" << (rtnSize - _size) << endl;  
         TEMPLOG;  
     }  
     PEG_TRACE((TRC_XML, Tracer::LEVEL1, "ReturnSize=%u", _size ));  
 #endif  
     PEG_METHOD_EXIT();  
     return _size;  
 }  
   
 // function used by OperationAggregator to aggregate response data in a // function used by OperationAggregator to aggregate response data in a
 // single ResponseData object. Adds all data in the from ResponseData object  // single ResponseData object
 // input variable to the target ResponseData object  
 // target array  
 void CIMResponseData::appendResponseData(const CIMResponseData & x) void CIMResponseData::appendResponseData(const CIMResponseData & x)
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,      // as the Messages set the data types, this should be impossible
         "CIMResponseData::appendResponseData");  
     //// AutoMutex autoMut(testLock);  
     // Confirm that the CIMResponseData type matches the type  
     // of the data being appended  
   
     PEGASUS_DEBUG_ASSERT(valid());            // KS_TEMP  
     PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);     PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);
     _encoding |= x._encoding;     _encoding |= x._encoding;
  
     // add all binary data     // add all binary data
     _binaryData.appendArray(x._binaryData);     _binaryData.appendArray(x._binaryData);
     // KS_TBD TODO PULL Add the counter incrementer for binary  
  
     // add all the C++ stuff     // add all the C++ stuff
     _instanceNames.appendArray(x._instanceNames);     _instanceNames.appendArray(x._instanceNames);
     _size += x._instanceNames.size();  
     _instances.appendArray(x._instances);     _instances.appendArray(x._instances);
     _size += x._instances.size();  
     _objects.appendArray(x._objects);     _objects.appendArray(x._objects);
     _size += x._objects.size();  
  
     // add the SCMO instances     // add the SCMO instances
     _scmoInstances.appendArray(x._scmoInstances);     _scmoInstances.appendArray(x._scmoInstances);
     _size += x._scmoInstances.size();  
   
     // add Xml encodings  
     // KS_TODO these are temporary. delete before release  
     PEGASUS_ASSERT(x._referencesData.size() == x._instanceData.size());  
     PEGASUS_ASSERT(x._instanceData.size() == x._hostsData.size());  
     PEGASUS_ASSERT(x._instanceData.size() == x._nameSpacesData.size());  
  
       // add Xml encodings too
     _referencesData.appendArray(x._referencesData);     _referencesData.appendArray(x._referencesData);
     _instanceData.appendArray(x._instanceData);     _instanceData.appendArray(x._instanceData);
     _hostsData.appendArray(x._hostsData);     _hostsData.appendArray(x._hostsData);
     _nameSpacesData.appendArray(x._nameSpacesData);     _nameSpacesData.appendArray(x._nameSpacesData);
     _size += x._instanceData.size();  
   
   
   
     // transfer property list  
     _propertyList = x._propertyList;  
   
     PEG_METHOD_EXIT();  
 } }
  
 // Encoding responses into output format // Encoding responses into output format
Line 783 
Line 311 
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,     PEG_METHOD_ENTER(TRC_DISPATCHER,
         "CIMResponseData::encodeBinaryResponse");         "CIMResponseData::encodeBinaryResponse");
   
     PSVALID;  
   
     // Need to do a complete job here by transferring all contained data     // Need to do a complete job here by transferring all contained data
     // into binary format and handing it out in the CIMBuffer     // into binary format and handing it out in the CIMBuffer
     // KS_TODO  
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
         PEGASUS_ASSERT(false);   // KS_TEMP  
   
         // Binary does NOT need a marker as it consists of C++ and SCMO         // Binary does NOT need a marker as it consists of C++ and SCMO
         const Array<Uint8>& data = _binaryData;         const Array<Uint8>& data = _binaryData;
         out.putBytes(data.getData(), data.size());         out.putBytes(data.getData(), data.size());
     }     }
   
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
     {     {
         out.putTypeMarker(BIN_TYPE_MARKER_CPPD);         out.putTypeMarker(BIN_TYPE_MARKER_CPPD);
Line 834 
Line 355 
             }             }
             default:             default:
             {             {
                 PEGASUS_ASSERT(false);                  PEGASUS_DEBUG_ASSERT(false);
             }             }
         }         }
     }     }
Line 846 
Line 367 
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
     {     {
         // This actually should not happen following general code logic         // This actually should not happen following general code logic
         PEGASUS_ASSERT(false);          PEGASUS_DEBUG_ASSERT(false);
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 929 
Line 450 
             }             }
         }         }
     }     }
   
     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
     {     {
         for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)         for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
Line 943 
Line 463 
     }     }
 } }
  
   
 void CIMResponseData::completeHostNameAndNamespace( void CIMResponseData::completeHostNameAndNamespace(
     const String & hn,     const String & hn,
     const CIMNamespaceName & ns,      const CIMNamespaceName & ns)
     Boolean isPullOperation)  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMResponseData::completeHostNameAndNamespace");  
   
     PEGASUS_DEBUG_ASSERT(valid());            // KS_TEMP  
   
     Uint32 count = 0;      //// KS_TODO this counter is just diagnostic  
   
         PEG_TRACE(( TRC_DISPATCHER, Tracer::LEVEL4,   // KS_TODO TEMP  
           "completeHostNameAndNamespace Setting hostName, etc "  
           "host %s ns %s set for dataType=%u encoding=%u isPull=%s",  
               (const char *)hn.getCString(),  
               (const char *)ns.getString().getCString(),  
               _dataType, _encoding, boolToString(isPullOperation) ));  
   
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
         // On binary need to remember hostname and namespace in case someone          // On binary need remember hostname and namespace in case someone
         // builds C++ default objects or Xml types later i.e.          // builds C++ default objects or Xml types from it later on
         // -> usage: See resolveBinary()         // -> usage: See resolveBinary()
         _defaultNamespace=ns;         _defaultNamespace=ns;
         _defaultHostname=hn;         _defaultHostname=hn;
         count++;  
     }     }
     // InternalXml does not support objectPath calls     // InternalXml does not support objectPath calls
     if ((RESP_ENC_XML == (_encoding & RESP_ENC_XML)) &&     if ((RESP_ENC_XML == (_encoding & RESP_ENC_XML)) &&
Line 980 
Line 485 
             if (0 == _hostsData[j].size())             if (0 == _hostsData[j].size())
             {             {
                 _hostsData[j]=hn;                 _hostsData[j]=hn;
                 count++;  
             }  
             if (_nameSpacesData[j].isNull())  
             {  
                 _nameSpacesData[j]=ns;  
             }  
         }  
     }  
     // Need to set for Pull Enumeration operations  
     if ((RESP_ENC_XML == (_encoding & RESP_ENC_XML)) &&  
             ((RESP_INSTANCES == _dataType) || isPullOperation))  
     {  
         for (Uint32 j = 0, n = _referencesData.size(); j < n; j++)  
         {  
             if (0 == _hostsData[j].size())  
             {  
                 count++;  
                 _hostsData[j]=hn;  
             }             }
             if (_nameSpacesData[j].isNull())             if (_nameSpacesData[j].isNull())
             {             {
                 _nameSpacesData[j]=ns;                 _nameSpacesData[j]=ns;
             }             }
   
             // KS_TODO Remove Diagnostic  
             PEG_TRACE(( TRC_DISPATCHER, Tracer::LEVEL4,  
               "completeHostNameAndNamespace Setting hostName, etc "  
               "host %s ns %s set to _hostData %s _namespaceData %s",  
                   (const char *)hn.getCString(),  
                   (const char *)ns.getString().getCString(),  
                   (const char *)_hostsData[j].getCString(),  
                   (const char *)_nameSpacesData[j].getString().getCString() ));  
         }         }
     }     }
   
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
     {     {
         switch (_dataType)         switch (_dataType)
         {         {
             // Instances added to account for namedInstance in Pull operations.  
             case RESP_INSTANCES:  
   
                 for (Uint32 j = 0, n = _instances.size(); j < n; j++)  
                 {  
                     const CIMInstance& instance = _instances[j];  
                     CIMObjectPath& p =  
                         const_cast<CIMObjectPath&>(instance.getPath());  
                     if (p.getHost().size()==0)  
                     {  
                         count++;  
                         p.setHost(hn);  
                     }  
                     if (p.getNameSpace().isNull())  
                     {  
                         p.setNameSpace(ns);  
                     }  
                 }  
             case RESP_OBJECTS:             case RESP_OBJECTS:
             {             {
                 for (Uint32 j = 0, n = _objects.size(); j < n; j++)                 for (Uint32 j = 0, n = _objects.size(); j < n; j++)
Line 1046 
Line 505 
                         const_cast<CIMObjectPath&>(object.getPath());                         const_cast<CIMObjectPath&>(object.getPath());
                     if (p.getHost().size()==0)                     if (p.getHost().size()==0)
                     {                     {
                         count++;  
                         p.setHost(hn);                         p.setHost(hn);
                     }                     }
                     if (p.getNameSpace().isNull())                     if (p.getNameSpace().isNull())
Line 1056 
Line 514 
                 }                 }
                 break;                 break;
             }             }
             // INSTNAMES added to account for instance paths in pull name  
             // operations  
             case RESP_INSTNAMES:  
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
             {             {
                 for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)                 for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)
                 {                 {
                     CIMObjectPath& p = _instanceNames[j];                     CIMObjectPath& p = _instanceNames[j];
                     if (p.getHost().size() == 0)                     if (p.getHost().size() == 0)
                     {  
                         count++;  
                         p.setHost(hn);                         p.setHost(hn);
                     }  
                     if (p.getNameSpace().isNull())                     if (p.getNameSpace().isNull())
                     {  
                         p.setNameSpace(ns);                         p.setNameSpace(ns);
                     }                     }
                 }  
                 break;                 break;
             }             }
             default:             default:
             {             {
                 PEGASUS_ASSERT(false);                  PEGASUS_DEBUG_ASSERT(false);
             }             }
         }         }
     }     }
Line 1092 
Line 542 
         Uint32 nsLen = strlen(nsChars);         Uint32 nsLen = strlen(nsChars);
         switch (_dataType)         switch (_dataType)
         {         {
             // KS_PULL add Instances and InstNames to cover pull operations  
             // KS_PULL - Confirm that this OK.  
             case RESP_INSTNAMES:  
             case RESP_INSTANCES:  
             case RESP_OBJECTS:             case RESP_OBJECTS:
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
             {             {
                 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)                 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
                 {                 {
                     count++;  
                     SCMOInstance & scmoInst=_scmoInstances[j];                     SCMOInstance & scmoInst=_scmoInstances[j];
                     scmoInst.completeHostNameAndNamespace(                      if (0 == scmoInst.getHostName())
                         hnChars,                      {
                         hnLen,                          scmoInst.setHostName_l(hnChars,hnLen);
                         nsChars,                      }
                         nsLen);                      if (0 == scmoInst.getNameSpace())
                       {
                           scmoInst.setNameSpace_l(nsChars,nsLen);
                       }
                 }                 }
                 break;                 break;
             }             }
             default:             default:
             {             {
                 PEGASUS_ASSERT(false);                  PEGASUS_DEBUG_ASSERT(false);
             }             }
         }         }
     }     }
     PEG_TRACE(( TRC_DISPATCHER, Tracer::LEVEL4,   // KS_TODO TEMP  
       "completeHostNameAndNamespace Set hostName, etc count %u"  
       "host %s ns %s set for dataType=%u encoding=%u isPull=%s",  
           count,  
           (const char *)hn.getCString(),  
           (const char *)ns.getString().getCString(),  
           _dataType, _encoding, boolToString(isPullOperation) ));  
   
   
     PEG_METHOD_EXIT();  
 } }
  
 // NOTE: The reason for the isPullResponse variable is that there are  void CIMResponseData::encodeXmlResponse(Buffer& out)
 // some variations in ouput to Xml depending on whether the responses  
 // are one of the pull responses or not  
 void CIMResponseData::encodeXmlResponse(Buffer& out, Boolean isPullResponse)  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMResponseData::encodeXmlResponse");  
   
     PEG_TRACE((TRC_XML, Tracer::LEVEL3,     PEG_TRACE((TRC_XML, Tracer::LEVEL3,
         "CIMResponseData::encodeXmlResponse(encoding=%X,dataType=%X, pull= %s)",          "CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)",
         _encoding,         _encoding,
         _dataType,          _dataType));
         (isPullResponse? "true" : "false")));  
  
     // already existing Internal XML does not need to be encoded further     // already existing Internal XML does not need to be encoded further
     // binary input is not actually impossible here, but we have an established     // binary input is not actually impossible here, but we have an established
     // fallback     // fallback
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
         _resolveBinaryToSCMO();          _resolveBinary();
     }     }
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
     {     {
Line 1167 
Line 598 
  
                 for (Uint32 i = 0, n = a.size(); i < n; i++)                 for (Uint32 i = 0, n = a.size(); i < n; i++)
                 {                 {
                     if (isPullResponse)  
                     {  
                         // KS_TODO these are temporary. delete before release  
                         PEGASUS_ASSERT(a.size() == b.size());  
                         PEGASUS_ASSERT(a.size() == _hostsData.size());  
                         PEGASUS_ASSERT(a.size() == _nameSpacesData.size());  
   
                         out << STRLIT("<VALUE.INSTANCEWITHPATH>\n");  
                         out << STRLIT("<INSTANCEPATH>\n");  
                         XmlWriter::appendNameSpacePathElement(out,  
                             _hostsData[i],  
                             _nameSpacesData[i]);  
                         out.append((char*)b[i].getData(), b[i].size() - 1);  
                         out << STRLIT("</INSTANCEPATH>\n");  
                         out.append((char *)a[i].getData(), a[i].size() - 1);  
                         out << STRLIT("</VALUE.INSTANCEWITHPATH>\n");  
                     }  
                     else  
                     {  
                         out << STRLIT("<VALUE.NAMEDINSTANCE>\n");                         out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
                         out.append((char*)b[i].getData(), b[i].size() - 1);                         out.append((char*)b[i].getData(), b[i].size() - 1);
                         out.append((char *)a[i].getData(), a[i].size() - 1);                         out.append((char *)a[i].getData(), a[i].size() - 1);
                         out << STRLIT("</VALUE.NAMEDINSTANCE>\n");                         out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
                     }                     }
                 }  
                 break;                 break;
             }             }
             case RESP_OBJECTS:             case RESP_OBJECTS:
             {             {
                 const Array<ArraySint8>& a = _instanceData;                 const Array<ArraySint8>& a = _instanceData;
                 const Array<ArraySint8>& b = _referencesData;                 const Array<ArraySint8>& b = _referencesData;
   
                 for (Uint32 i = 0, n = a.size(); i < n; i++)                 for (Uint32 i = 0, n = a.size(); i < n; i++)
                 {                 {
                     out << STRLIT("<VALUE.OBJECTWITHPATH>\n");                     out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
Line 1226 
Line 636 
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
             default:             default:
             {             {
                 PEGASUS_ASSERT(false);                  PEGASUS_DEBUG_ASSERT(false);
             }             }
         }         }
     }     }
  
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
     {     {
           _propertyList.fillCIMNameTags();
         switch (_dataType)         switch (_dataType)
         {         {
             case RESP_INSTNAMES:             case RESP_INSTNAMES:
             {             {
                 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)                 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
                 {                 {
                     // Element type is different for Pull responses                      XmlWriter::appendInstanceNameElement(out,_instanceNames[i]);
                     if (isPullResponse)  
                     {  
                         XmlWriter::appendInstancePathElement(out,  
                             _instanceNames[i]);  
                     }  
                     else  
                     {  
                         XmlWriter::appendInstanceNameElement(out,  
                             _instanceNames[i]);  
                     }  
                 }                 }
                 break;                 break;
             }             }
Line 1270 
Line 671 
             {             {
                 for (Uint32 i = 0, n = _instances.size(); i < n; i++)                 for (Uint32 i = 0, n = _instances.size(); i < n; i++)
                 {                 {
                     if (isPullResponse)  
                     {  
                         XmlWriter::appendValueInstanceWithPathElement(  
                             out,  
                             _instances[i],  
                             _includeQualifiers,  
                             _includeClassOrigin,  
                             _propertyList);  
                     }  
                     else  
                     {  
                         XmlWriter::appendValueNamedInstanceElement(                         XmlWriter::appendValueNamedInstanceElement(
                             out,                             out,
                             _instances[i],                             _instances[i],
Line 1288 
Line 678 
                             _includeClassOrigin,                             _includeClassOrigin,
                             _propertyList);                             _propertyList);
                     }                     }
                 }  
                 break;                 break;
             }             }
             case RESP_OBJECTS:             case RESP_OBJECTS:
             {             {
                 for (Uint32 i = 0; i < _objects.size(); i++)                 for (Uint32 i = 0; i < _objects.size(); i++)
                 {                 {
                     // If pull, map to instances  
                     if (isPullResponse)  
                     {  
                         CIMInstance x = (CIMInstance)_objects[i];  
                         XmlWriter::appendValueInstanceWithPathElement(  
                             out, x,  
                             _includeQualifiers,  
                             _includeClassOrigin,  
                             _propertyList);  
                     }  
                     else  
                     {  
                         XmlWriter::appendValueObjectWithPathElement(                         XmlWriter::appendValueObjectWithPathElement(
                             out,                             out,
                             _objects[i],                             _objects[i],
                             _includeQualifiers,                             _includeQualifiers,
                             _includeClassOrigin,                             _includeClassOrigin,
                             _isClassOperation,  
                             _propertyList);                             _propertyList);
                     }                     }
                 }  
                 break;                 break;
             }             }
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
             {             {
                 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)                 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
                 {                 {
                     // ObjectPaths come from providers for pull operations  
                     // but are encoded as instancePathElements  
                     if (isPullResponse)  
   
                     {  
                         XmlWriter::appendInstancePathElement(out,  
                            _instanceNames[i]);  
                     }  
                     else  
                     {  
                         out << "<OBJECTPATH>\n";                         out << "<OBJECTPATH>\n";
                         XmlWriter::appendValueReferenceElement(                         XmlWriter::appendValueReferenceElement(
                             out,                             out,
                             _instanceNames[i],                             _instanceNames[i],
                         _isClassOperation,  
                             false);                             false);
                         out << "</OBJECTPATH>\n";                         out << "</OBJECTPATH>\n";
                     }                     }
                 }  
                 break;                 break;
             }             }
             default:             default:
             {             {
                 PEGASUS_ASSERT(false);                  PEGASUS_DEBUG_ASSERT(false);
             }             }
         }         }
     }     }
Line 1355 
Line 718 
         {         {
             case RESP_INSTNAMES:             case RESP_INSTNAMES:
             {             {
                 if (isPullResponse)  
                 {  
                     for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)  
                     {  
                         SCMOXmlWriter::appendInstancePathElement(  
                             out,  
                             _scmoInstances[i]);  
   
                     }  
                 }  
                 else  
                 {  
                     for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)                     for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
                     {                     {
                         SCMOXmlWriter::appendInstanceNameElement(                         SCMOXmlWriter::appendInstanceNameElement(
Line 1374 
Line 725 
                             _scmoInstances[i]);                             _scmoInstances[i]);
  
                     }                     }
                 }  
                 break;                 break;
             }             }
             case RESP_INSTANCE:             case RESP_INSTANCE:
Line 1411 
Line 761 
             }             }
             case RESP_INSTANCES:             case RESP_INSTANCES:
             {             {
                 if (isPullResponse)  
                 {  
                     SCMOXmlWriter::appendValueSCMOInstanceWithPathElements(  
                         out, _scmoInstances, _propertyList);  
                 }  
                 else  
                 {  
                     SCMOXmlWriter::appendValueSCMOInstanceElements(                     SCMOXmlWriter::appendValueSCMOInstanceElements(
                         out, _scmoInstances, _propertyList);                      out,
                 }                      _scmoInstances,
                       _propertyList);
                 break;                 break;
             }             }
             case RESP_OBJECTS:             case RESP_OBJECTS:
             {             {
                 if (isPullResponse)  
                 {  
                     SCMOXmlWriter::appendValueSCMOInstanceWithPathElements(  
                         out,_scmoInstances, _propertyList);  
                 }  
                 else  
                 {  
                     // KS_TODO why is this one named element rather than  
                     // elements  
                     SCMOXmlWriter::appendValueObjectWithPathElement(                     SCMOXmlWriter::appendValueObjectWithPathElement(
                         out, _scmoInstances, _propertyList);                      out,
                 }                     _scmoInstances,
                     _propertyList);
                 break;                 break;
             }             }
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
             {             {
                 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)                 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
                 {                 {
                     if (isPullResponse)  
                     {  
                         SCMOXmlWriter::appendInstancePathElement(out,  
                             _scmoInstances[i]);  
                     }  
                     else  
                     {  
                         out << "<OBJECTPATH>\n";                         out << "<OBJECTPATH>\n";
                         SCMOXmlWriter::appendValueReferenceElement(                         SCMOXmlWriter::appendValueReferenceElement(
                             out, _scmoInstances[i],                          out,
                           _scmoInstances[i],
                             false);                             false);
                         out << "</OBJECTPATH>\n";                         out << "</OBJECTPATH>\n";
                     }                     }
                 }  
                 break;                 break;
             }             }
             default:             default:
             {             {
                 PEGASUS_ASSERT(false);                  PEGASUS_DEBUG_ASSERT(false);
             }             }
         }         }
     }     }
   
     PEG_METHOD_EXIT();  
 } }
  
 // contrary to encodeXmlResponse this function encodes the Xml in a format // contrary to encodeXmlResponse this function encodes the Xml in a format
 // not usable by clients // not usable by clients
 void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out) void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out)
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMResponseData::encodeInternalXmlResponse");  
   
     PEG_TRACE((TRC_XML, Tracer::LEVEL3,     PEG_TRACE((TRC_XML, Tracer::LEVEL3,
         "CIMResponseData::encodeInternalXmlResponse(encoding=%X,content=%X)",         "CIMResponseData::encodeInternalXmlResponse(encoding=%X,content=%X)",
         _encoding,         _encoding,
Line 1490 
Line 814 
     // fallback     // fallback
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
         _resolveBinaryToSCMO();          _resolveBinary();
     }     }
     if ((0 == _encoding) ||     if ((0 == _encoding) ||
         (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)))         (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)))
     {     {
           _propertyList.fillCIMNameTags();
         switch (_dataType)         switch (_dataType)
         {         {
             case RESP_INSTANCE:             case RESP_INSTANCE:
Line 1553 
Line 878 
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
             default:             default:
             {             {
                 PEGASUS_ASSERT(false);                  PEGASUS_DEBUG_ASSERT(false);
             }             }
         }         }
     }     }
Line 1607 
Line 932 
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
             default:             default:
             {             {
                 PEGASUS_ASSERT(false);                  PEGASUS_DEBUG_ASSERT(false);
             }             }
         }         }
     }     }
     PEG_METHOD_EXIT();  
 } }
  
 void CIMResponseData::_resolveToCIM() void CIMResponseData::_resolveToCIM()
Line 1627 
Line 952 
     }     }
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
         _resolveBinaryToSCMO();          _resolveBinary();
     }     }
     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
     {     {
Line 1637 
Line 962 
     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM || _encoding == 0);     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM || _encoding == 0);
 } }
  
 // Resolve any binary data to SCMO. This externalfunction added because we  
 // cannot do a move on Binary data so convert it a to movable format  
 void CIMResponseData::resolveBinaryToSCMO()  
 {  
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMResponseData::resolveBinaryToSCMO");  
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))  
     {  
         _resolveBinaryToSCMO();  
     }  
     PEG_METHOD_EXIT();  
 }  
   
 void CIMResponseData::_resolveToSCMO() void CIMResponseData::_resolveToSCMO()
 { {
     PEG_TRACE((TRC_XML, Tracer::LEVEL3,     PEG_TRACE((TRC_XML, Tracer::LEVEL3,
Line 1663 
Line 975 
     }     }
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
         _resolveBinaryToSCMO();          _resolveBinary();
     }     }
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
     {     {
Line 1675 
Line 987 
 // helper functions to transform different formats into one-another // helper functions to transform different formats into one-another
 // functions work on the internal data and calling of them should be // functions work on the internal data and calling of them should be
 // avoided whenever possible // avoided whenever possible
 void CIMResponseData::_resolveBinaryToSCMO()  void CIMResponseData::_resolveBinary()
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,     PEG_METHOD_ENTER(TRC_DISPATCHER,
         "CIMResponseData::_resolveBinaryToSCMO");          "CIMResponseData::_resolveBinary");
  
     CIMBuffer in((char*)_binaryData.getData(), _binaryData.size());     CIMBuffer in((char*)_binaryData.getData(), _binaryData.size());
  
Line 1772 
Line 1084 
                 }                 }
                 default:                 default:
                 {                 {
                     PEGASUS_ASSERT(false);                      PEGASUS_DEBUG_ASSERT(false);
                 }                 }
             } // switch             } // switch
             _encoding |= RESP_ENC_CIM;             _encoding |= RESP_ENC_CIM;
Line 1789 
Line 1101 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
   void CIMResponseData::_resolveXmlToCIM()
 void CIMResponseData::_deserializeObject(Uint32 idx,CIMObject& cimObject)  
 {  
   
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMResponseData::_deserializeObject");  
     // Only start the parser when instance data is present.  
     if (0 != _instanceData[idx].size())  
     {     {
         CIMInstance cimInstance;      switch (_dataType)
         CIMClass cimClass;  
   
         XmlParser parser((char*)_instanceData[idx].getData());  
   
         if (XmlReader::getInstanceElement(parser, cimInstance))  
         {         {
             cimObject = CIMObject(cimInstance);          // Xml encoding for instance names and object paths not used
             return;          case RESP_OBJECTPATHS:
         }          case RESP_INSTNAMES:
   
         if (XmlReader::getClassElement(parser, cimClass))  
         {         {
             cimObject = CIMObject(cimClass);              break;
             return;  
         }  
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,  
             "Failed to resolve XML object data, parser error!");  
     }  
     PEG_METHOD_EXIT();  
 } }
           case RESP_INSTANCE:
 void CIMResponseData::_deserializeInstance(Uint32 idx,CIMInstance& cimInstance)  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,              CIMInstance cimInstance;
         "CIMResponseData::_deserializeInstance");              // Deserialize instance:
     // Only start the parser when instance data is present.  
     if (0 != _instanceData[idx].size())  
     {     {
         XmlParser parser((char*)_instanceData[idx].getData());                  XmlParser parser((char*)_instanceData[0].getData());
         if (XmlReader::getInstanceElement(parser, cimInstance))  
                   if (!XmlReader::getInstanceElement(parser, cimInstance))
         {         {
             return;                      cimInstance = CIMInstance();
         }  
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "Failed to resolve XML instance, parser error!");             "Failed to resolve XML instance, parser error!");
     }     }
     // reset instance when parsing may not be successfull or  
     // no instance is present.  
     cimInstance = CIMInstance();  
   
     PEG_METHOD_EXIT();  
 } }
               // Deserialize path:
 Boolean CIMResponseData::_deserializeReference(  
     Uint32 idx,  
     CIMObjectPath& cimObjectPath)  
 { {
     // Only start the parser when reference data is present.                  XmlParser parser((char*)_referencesData[0].getData());
     if (0 != _referencesData[idx].size())                  CIMObjectPath cimObjectPath;
     {  
         XmlParser parser((char*)_referencesData[idx].getData());  
         if (XmlReader::getValueReferenceElement(parser, cimObjectPath))         if (XmlReader::getValueReferenceElement(parser, cimObjectPath))
         {         {
             if (_hostsData[idx].size())                      if (_hostsData.size())
             {             {
                 cimObjectPath.setHost(_hostsData[idx]);                          cimObjectPath.setHost(_hostsData[0]);
             }             }
             if (!_nameSpacesData[idx].isNull())                      if (!_nameSpacesData[0].isNull())
             {             {
                 cimObjectPath.setNameSpace(_nameSpacesData[idx]);                          cimObjectPath.setNameSpace(_nameSpacesData[0]);
             }             }
             return true;                      cimInstance.setPath(cimObjectPath);
                       // only if everything works we add the CIMInstance to the
                       // array
                       _instances.append(cimInstance);
         }         }
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,  
             "Failed to resolve XML reference, parser error!");  
   
     }     }
     return false;              break;
 } }
           case RESP_INSTANCES:
 Boolean CIMResponseData::_deserializeInstanceName(  
     Uint32 idx,  
     CIMObjectPath& cimObjectPath)  
 {  
     // Only start the parser when instance name data is present.  
     if (0 != _referencesData[idx].size())  
     {     {
         XmlParser parser((char*)_referencesData[idx].getData());              for (Uint32 i = 0; i < _instanceData.size(); i++)
         if (XmlReader::getInstanceNameElement(parser, cimObjectPath))  
         {         {
             if (_hostsData[idx].size())                  CIMInstance cimInstance;
                   // Deserialize instance:
             {             {
                 cimObjectPath.setHost(_hostsData[idx]);                      XmlParser parser((char*)_instanceData[i].getData());
             }  
             if (!_nameSpacesData[idx].isNull())                      if (!XmlReader::getInstanceElement(parser, cimInstance))
             {             {
                 cimObjectPath.setNameSpace(_nameSpacesData[idx]);  
             }  
             return true;  
         }  
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "Failed to resolve XML instance name, parser error!");                              "Failed to resolve XML instance."
                                   " Creating empty instance!");
                           cimInstance = CIMInstance();
     }     }
     return false;  
 } }
  
 void CIMResponseData::_resolveXmlToCIM()                  // Deserialize path:
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,                      XmlParser parser((char*)_referencesData[i].getData());
         "CIMResponseData::_resolveXmlToCIM");  
   
     switch (_dataType)  
     {  
         // Xml encoding for instance names and object paths not used  
         case RESP_OBJECTPATHS:  
         case RESP_INSTNAMES:  
         {  
             break;  
         }  
         case RESP_INSTANCE:  
         {  
             CIMInstance cimInstance;  
             CIMObjectPath cimObjectPath;             CIMObjectPath cimObjectPath;
  
             _deserializeInstance(0,cimInstance);                      if (XmlReader::getInstanceNameElement(parser,cimObjectPath))
             if (_deserializeReference(0,cimObjectPath))  
             {             {
                           if (!_nameSpacesData[i].isNull())
                               cimObjectPath.setNameSpace(_nameSpacesData[i]);
   
                           if (_hostsData[i].size())
                               cimObjectPath.setHost(_hostsData[i]);
   
                 cimInstance.setPath(cimObjectPath);                 cimInstance.setPath(cimObjectPath);
                 // A single CIMInstance has to have an objectpath.                      }
                 // So only add it when an objectpath exists.                  }
   
                 _instances.append(cimInstance);                 _instances.append(cimInstance);
             }             }
             break;             break;
         }         }
         case RESP_INSTANCES:          case RESP_OBJECTS:
         {         {
             for (Uint32 i = 0; i < _instanceData.size(); i++)              for (Uint32 i=0, n=_instanceData.size(); i<n; i++)
             {             {
                   CIMObject cimObject;
   
                   // Deserialize Objects:
                   {
                       XmlParser parser((char*)_instanceData[i].getData());
   
                 CIMInstance cimInstance;                 CIMInstance cimInstance;
                 CIMObjectPath cimObjectPath;                      CIMClass cimClass;
  
                 _deserializeInstance(i,cimInstance);                      if (XmlReader::getInstanceElement(parser, cimInstance))
                 if (_deserializeInstanceName(i,cimObjectPath))  
                 {                 {
                     cimInstance.setPath(cimObjectPath);                          cimObject = CIMObject(cimInstance);
                 }  
                 // enumarate instances can be without name  
                 _instances.append(cimInstance);  
             }             }
             break;                      else if (XmlReader::getClassElement(parser, cimClass))
                       {
                           cimObject = CIMObject(cimClass);
         }         }
         case RESP_OBJECTS:                      else
         {         {
             for (Uint32 i=0, n=_instanceData.size(); i<n; i++)                          PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                               "Failed to get XML object data!");
                       }
                   }
   
                   // Deserialize paths:
             {             {
                 CIMObject cimObject;                      XmlParser parser((char*)_referencesData[i].getData());
                 CIMObjectPath cimObjectPath;                 CIMObjectPath cimObjectPath;
  
                 _deserializeObject(i,cimObject);                      if (XmlReader::getValueReferenceElement(
                 if (_deserializeReference(i,cimObjectPath))                              parser,
                               cimObjectPath))
                 {                 {
                           if (!_nameSpacesData[i].isNull())
                               cimObjectPath.setNameSpace(_nameSpacesData[i]);
   
                           if (_hostsData[i].size())
                               cimObjectPath.setHost(_hostsData[i]);
   
                     cimObject.setPath(cimObjectPath);                     cimObject.setPath(cimObjectPath);
                 }                 }
                   }
                 _objects.append(cimObject);                 _objects.append(cimObject);
             }             }
             break;             break;
         }         }
         default:         default:
         {         {
             PEGASUS_ASSERT(false);              PEGASUS_DEBUG_ASSERT(false);
         }         }
     }     }
     // Xml was resolved, release Xml content now     // Xml was resolved, release Xml content now
Line 1971 
Line 1251 
     _encoding &=(~RESP_ENC_XML);     _encoding &=(~RESP_ENC_XML);
     // add CIM Encoding flag     // add CIM Encoding flag
     _encoding |=RESP_ENC_CIM;     _encoding |=RESP_ENC_CIM;
   
     PEG_METHOD_EXIT();  
 } }
  
 void CIMResponseData::_resolveXmlToSCMO() void CIMResponseData::_resolveXmlToSCMO()
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMResponseData::_resolveXmlToSCMO");  
     // Not optimal, can probably be improved     // Not optimal, can probably be improved
     // but on the other hand, since using the binary format this case should     // but on the other hand, since using the binary format this case should
     // actually not ever happen.     // actually not ever happen.
     _resolveXmlToCIM();     _resolveXmlToCIM();
     _resolveCIMToSCMO();     _resolveCIMToSCMO();
   
     PEG_METHOD_EXIT();  
 } }
  
 void CIMResponseData::_resolveSCMOToCIM() void CIMResponseData::_resolveSCMOToCIM()
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMResponseData::_resolveSCMOToCIM");  
     switch(_dataType)     switch(_dataType)
     {     {
         case RESP_INSTNAMES:         case RESP_INSTNAMES:
Line 2037 
Line 1309 
         }         }
         default:         default:
         {         {
             PEGASUS_ASSERT(false);              PEGASUS_DEBUG_ASSERT(false);
         }         }
     }     }
     _scmoInstances.clear();     _scmoInstances.clear();
Line 2045 
Line 1317 
     _encoding &=(~RESP_ENC_SCMO);     _encoding &=(~RESP_ENC_SCMO);
     // add SCMO Encoding flag     // add SCMO Encoding flag
     _encoding |=RESP_ENC_CIM;     _encoding |=RESP_ENC_CIM;
   
     PEG_METHOD_EXIT();  
 } }
  
 void CIMResponseData::_resolveCIMToSCMO() void CIMResponseData::_resolveCIMToSCMO()
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMResponseData::_resolveCIMToSCMO");  
     CString nsCString=_defaultNamespace.getString().getCString();     CString nsCString=_defaultNamespace.getString().getCString();
     const char* _defNamespace = nsCString;     const char* _defNamespace = nsCString;
     Uint32 _defNamespaceLen;     Uint32 _defNamespaceLen;
Line 2127 
Line 1395 
                     _instanceNames[i],                     _instanceNames[i],
                     _defNamespace,                     _defNamespace,
                     _defNamespaceLen);                     _defNamespaceLen);
                 if (_isClassOperation)                  // TODO: More description about this.
                   if (0 == _instanceNames[i].getKeyBindings().size())
                 {                 {
                       // if there is no keybinding, this is a class
                     addme.setIsClassOnly(true);                     addme.setIsClassOnly(true);
                 }                 }
                 _scmoInstances.append(addme);                 _scmoInstances.append(addme);
Line 2138 
Line 1408 
         }         }
         default:         default:
         {         {
             PEGASUS_ASSERT(false);              PEGASUS_DEBUG_ASSERT(false);
         }         }
     }     }
  
Line 2146 
Line 1416 
     _encoding &=(~RESP_ENC_CIM);     _encoding &=(~RESP_ENC_CIM);
     // add SCMO Encoding flag     // add SCMO Encoding flag
     _encoding |=RESP_ENC_SCMO;     _encoding |=RESP_ENC_SCMO;
   
     PEG_METHOD_EXIT();  
 }  
   
 /**  
  * Validate the magic object for this CIMResponseData. This  
  * compiles only in debug mode and can be use to validate the  
  * CIMResponseData object  
  *  
  * @return Boolean True if valid object.  
  */  
 Boolean CIMResponseData::valid() const  
 {  
     return _magic;  
 } }
  
 void CIMResponseData::setRequestProperties( void CIMResponseData::setRequestProperties(
Line 2171 
Line 1427 
     _includeClassOrigin = includeClassOrigin;     _includeClassOrigin = includeClassOrigin;
     _propertyList = propertyList;     _propertyList = propertyList;
 } }
   void CIMResponseData::getRequestProperties(
 void CIMResponseData::setIsClassOperation(Boolean b)      Boolean & includeQualifiers,
 {      Boolean & includeClassOrigin,
     _isClassOperation = b;      CIMPropertyList& propertyList)
 }  {
       includeQualifiers = _includeQualifiers;
 //// KS_TODO Remove. Diagnostic Display      includeClassOrigin = _includeClassOrigin;
 void CIMResponseData::traceResponseData()      propertyList = _propertyList;
 {  
     PEG_TRACE((TRC_XML, Tracer::LEVEL3,  
         "CIMResponseData::traceResponseData(encoding=%X,dataType=%X "  
         " size=%u C++instNamecount=%u c++Instances=%u c++Objects=%u "  
         "scomInstances=%u XMLInstData=%u binaryData=%u "  
         "xmlref=%u xmlinst=%u, xmlhost=%u xmlns=%u",  
         _encoding,_dataType, _size,  
         _instanceNames.size(),_instances.size(), _objects.size(),  
         _scmoInstances.size(),_instanceData.size(),_binaryData.size(),  
         _referencesData.size(), _instanceData.size(), _hostsData.size(),  
         _nameSpacesData.size()        ));  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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