(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.1 and 1.2.2.10

version 1.1, 2009/06/30 10:31:30 version 1.2.2.10, 2009/10/20 13:21:19
Line 30 
Line 30 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "CIMResponseData.h" #include "CIMResponseData.h"
 #include "XmlWriter.h"  #include <Pegasus/Common/Tracer.h>
 #include "XmlReader.h"  #include <Pegasus/Common/XmlWriter.h>
 #include "Tracer.h"  #include <Pegasus/Common/SCMOXmlWriter.h>
   #include <Pegasus/Common/XmlReader.h>
   #include <Pegasus/Common/SCMOClassCache.h>
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 //-----------------------------------------------------------------------------  // C++ objects interface handling
 //  
 //  CIMInstanceResponseData  
 //  
 //-----------------------------------------------------------------------------  
  
 bool CIMInstanceResponseData::setBinaryCimInstance(CIMBuffer& in)  // Instance Names handling
   Array<CIMObjectPath>& CIMResponseData::getInstanceNames()
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,      PEGASUS_DEBUG_ASSERT(
         "CIMInstanceResponseData::setBinaryCimInstance");      (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));
       _resolveToCIM();
     if (!in.getUint8A(_binaryData))      PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
     {      return _instanceNames;
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,  
             "Failed to get binary instance data!");  
         PEG_METHOD_EXIT();  
         return false;  
     }     }
  
     _resolveCallback = _resolveBinaryInstance;  // Instance handling
     _binaryEncoding = true;  CIMInstance& CIMResponseData::getInstance()
   
     PEG_METHOD_EXIT();  
     return true;  
 };  
   
 bool CIMInstanceResponseData::setXmlCimInstance(CIMBuffer& in)  
 {  
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMInstanceResponseData::setXmlCimInstance");  
   
     if (!in.getSint8A(_instanceData))  
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,      PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);
             "Failed to get XML instance data!");      _resolveToCIM();
         PEG_METHOD_EXIT();      PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
         return false;      return _instances[0];
     }     }
  
     if (!in.getSint8A(_referenceData))  // Instances handling
   Array<CIMInstance>& CIMResponseData::getInstances()
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,      PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES);
             "Failed to get XML instance data (reference)!");      _resolveToCIM();
         PEG_METHOD_EXIT();      PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
         return false;      return _instances;
     }     }
  
     if (!in.getString(_hostData))  // Objects handling
   Array<CIMObject>& CIMResponseData::getObjects()
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,      PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);
             "Failed to get XML instance data (host)!");      _resolveToCIM();
         PEG_METHOD_EXIT();      PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
         return false;      return _objects;
     }     }
  
     if (!in.getNamespaceName(_nameSpaceData))  // SCMO representation, single instance stored as one element array
   // object paths are represented as SCMOInstance
   Array<SCMOInstance>& CIMResponseData::getSCMO()
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,      _resolveToSCMO();
             "Failed to get XML instance data (namespace)!");      PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO);
         PEG_METHOD_EXIT();      return _scmoInstances;
         return false;  
     }     }
  
     _resolveCallback = _resolveXMLInstance;  void CIMResponseData::setSCMO(const Array<SCMOInstance>& x)
     _binaryEncoding = false;  
   
     PEG_METHOD_EXIT();  
     return true;  
 };  
   
 //------------------------------------------------------------------------------  
 // Encodes the CIMInstance representation contained in the current  
 // CIMResponseData object in binary response message format.  
 // This code corresponds to method _resolveBinaryInstance, which is used  
 // revert a binary instance representation back into a CIMInstance  
 //------------------------------------------------------------------------------  
 void CIMInstanceResponseData::encodeBinaryResponse(CIMBuffer& out) const  
 {  
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMInstanceResponseData::encodeBinaryResponse");  
   
     if (_resolveCallback && _binaryEncoding)  
     {  
         const Array<Uint8>& data = _binaryData;  
         out.putBytes(data.getData(), data.size());  
     }  
     else  
     {  
         out.putInstance(_cimInstance, false, false);  
     }  
     PEG_METHOD_EXIT();  
 }  
   
 //------------------------------------------------------------------------------  
 // Encodes the CIMInstanc representation contained in the current  
 // CIMResponseData object in xml response message format.  
 // This code corresponds to method _resolveXmlInstance, which is used  
 // revert a CIM-XML instance representation back into a CIMInstance.  
 //------------------------------------------------------------------------------  
 void CIMInstanceResponseData::encodeXmlResponse(Buffer& out) const  
 {  
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMInstanceResponseData::encodeXmlResponse");  
   
     if (_resolveCallback && !_binaryEncoding)  
     {     {
         out.append( (char*)_instanceData.getData(),_instanceData.size()-1);      // Just assignment bears danger of us being dependent on the original array
     }      // content staying valid
     else      _scmoInstances=x;
   /*
       for (Uint32 loop=0, max=x.size(); loop<max; loop++)
     {     {
         XmlWriter::appendInstanceElement(out, _cimInstance);          _scmoInstances.append(x[loop]);
     }     }
     PEG_METHOD_EXIT();  */
       // _scmoInstances.appendArray(x);
       _encoding |= RESP_ENC_SCMO;
 } }
  
 //------------------------------------------------------------------------------  
 // Instantiates a CIMInstance from a binary representation created by  
 // the CIMBinMessageSerializer.  
 // Returns true on success.  
 //------------------------------------------------------------------------------  
 Boolean CIMInstanceResponseData::_resolveBinaryInstance(  
     CIMInstanceResponseData* data,  
     CIMInstance& instance)  
 {  
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMInstanceResponseData::_resolveBinaryInstance");  
   
     CIMBuffer in((char*)data->_binaryData.getData(), data->_binaryData.size());  
  
     if (!in.getInstance(instance))  // Binary data is just a data stream
   Array<Uint8>& CIMResponseData::getBinary()
     {     {
         instance = CIMInstance();      PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_BINARY);
         in.release();      return _binaryData;
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,  
             "Failed to resolve binary instance!");  
         PEG_METHOD_EXIT();  
         return false;  
     }  
   
     in.release();  
     PEG_METHOD_EXIT();  
     return true;  
 } }
  
 //------------------------------------------------------------------------------  bool CIMResponseData::setBinary(CIMBuffer& in, bool hasLen)
 // Instantiates a CIMInstance from an xml representation created by  
 // the CIMBinMessageSerializer.  
 // Returns true on success.  
 //------------------------------------------------------------------------------  
 Boolean CIMInstanceResponseData::_resolveXMLInstance(  
     CIMInstanceResponseData* data,  
     CIMInstance& cimInstance)  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,     PEG_METHOD_ENTER(TRC_DISPATCHER,
         "CIMInstanceResponseData::_resolveXMLInstance");          "CIMResponseData::setBinary");
  
     // Deserialize instance:      if (hasLen)
     {     {
         XmlParser parser((char*)data->_instanceData.getData());          if (!in.getUint8A(_binaryData))
   
         if (!XmlReader::getInstanceElement(parser, cimInstance))  
         {         {
             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 get binary object path data!");
             PEG_METHOD_EXIT();             PEG_METHOD_EXIT();
             return false;             return false;
         }         }
     }     }
       else
     // Deserialize path:  
     {  
         XmlParser parser((char*)data->_referenceData.getData());  
         CIMObjectPath cimObjectPath;  
   
         if (XmlReader::getValueReferenceElement(parser, cimObjectPath))  
         {         {
             if (data->_hostData.size())          size_t remainingDataLength = in.capacity() - in.size();
                 cimObjectPath.setHost(data->_hostData);          _binaryData.append((Uint8*)in.getPtr(), remainingDataLength);
   
             if (!data->_nameSpaceData.isNull())  
                 cimObjectPath.setNameSpace(data->_nameSpaceData);  
   
             cimInstance.setPath(cimObjectPath);  
         }         }
     }      _encoding |= RESP_ENC_BINARY;
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return true;     return true;
 } }
  
   bool CIMResponseData::setXml(CIMBuffer& in)
 //-----------------------------------------------------------------------------  
 //  
 //  CIMInstancesResponseData  
 //  
 //-----------------------------------------------------------------------------  
   
 //------------------------------------------------------------------------------  
 // Reverts a binary instance array representation back into an array of  
 // CIMInstance  
 //------------------------------------------------------------------------------  
 bool CIMInstancesResponseData::setBinaryCimInstances(CIMBuffer& in)  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,     PEG_METHOD_ENTER(TRC_DISPATCHER,
         "CIMInstancesResponseData::setBinaryCimInstances");          "CIMResponseData::setXml");
  
     if (!in.getUint8A(_binaryData))      if (_dataType == RESP_INSTNAMES)
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,  
             "Failed to get binary instance data!");  
         PEG_METHOD_EXIT();  
         return false;  
     }  
   
     _resolveCallback = _resolveBinaryInstances;  
     _binaryEncoding = true;  
   
     PEG_METHOD_EXIT();  
     return true;  
 };  
   
 bool CIMInstancesResponseData::setXmlCimInstances(CIMBuffer& in)  
 {  
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMInstancesResponseData::setXmlCimInstances");  
   
     Uint32 count;     Uint32 count;
  
     if (!in.getUint32(count))     if (!in.getUint32(count))
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "Failed to get XML instance data (number of instance)!");                  "Failed to get XML objectpath data (number of paths)!");
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         return false;         return false;
     }     }
  
     for (Uint32 i = 0; i < count; i++)     for (Uint32 i = 0; i < count; i++)
     {     {
         Array<Sint8> inst;  
         Array<Sint8> ref;         Array<Sint8> ref;
         CIMNamespaceName ns;         CIMNamespaceName ns;
         String host;         String host;
  
         if (!in.getSint8A(inst))  
         {  
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,  
                 "Failed to get XML instance data (instances)!");  
             PEG_METHOD_EXIT();  
             return false;  
         }  
   
         if (!in.getSint8A(ref))         if (!in.getSint8A(ref))
         {         {
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                 "Failed to get XML instance data (references)!");                      "Failed to get XML objectpath data (references)!");
             PEG_METHOD_EXIT();             PEG_METHOD_EXIT();
             return false;             return false;
         }         }
Line 314 
Line 183 
             return false;             return false;
         }         }
  
         _instancesData.append(inst);  
         _referencesData.append(ref);         _referencesData.append(ref);
         _hostsData.append(host);         _hostsData.append(host);
         _nameSpacesData.append(ns);         _nameSpacesData.append(ns);
     }     }
       }
       // TODO: Code the left out types
  
     _resolveCallback = _resolveXMLInstances;      _encoding |= RESP_ENC_XML;
     _binaryEncoding = false;  
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return true;     return true;
 };  }
   
   
  
   // function used by OperationAggregator to aggregate response data in a
   // single ResponseData object
   void CIMResponseData::appendResponseData(const CIMResponseData & x)
   {
       // as the Messages set the data types, this should be impossible
       PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);
       _encoding |= x._encoding;
   
       // add all binary data
       _binaryData.appendArray(x._binaryData);
   
       // add all the C++ stuff
       _instanceNames.appendArray(x._instanceNames);
       _instances.appendArray(x._instances);
       _objects.appendArray(x._objects);
   
       // add the SCMO instances
       _scmoInstances.appendArray(x._scmoInstances);
   
       // add Xml encodings too
       _referencesData.appendArray(x._referencesData);
       _instanceData.appendArray(x._instanceData);
       _hostsData.appendArray(x._hostsData);
       _nameSpacesData.appendArray(x._nameSpacesData);
   }
  
 //------------------------------------------------------------------------------  // Encoding responses into output format
 // Encodes the array of CIMInstance representation contained in the current  void CIMResponseData::encodeBinaryResponse(CIMBuffer& out)
 // CIMResponseData object in binary response message format.  
 // This code corresponds to method _resolveBinaryInstances, which is used  
 // revert a binary instance array representation back into an array of  
 // CIMInstance  
 //------------------------------------------------------------------------------  
 void CIMInstancesResponseData::encodeBinaryResponse(CIMBuffer& out) const  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,     PEG_METHOD_ENTER(TRC_DISPATCHER,
         "CIMInstancesResponseData::encodeBinaryResponse");          "CIMResponseData::encodeBinaryResponse");
  
     if (_resolveCallback && _binaryEncoding)      // Need to do a complete job here by transferring all contained data
       // into binary format and handing it out in the CIMBuffer
       if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     {     {
           // 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());
     }     }
     else      if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
       {
           // TODO: Set Marker for C++ data
           switch (_dataType)
           {
               case RESP_INSTNAMES:
               {
                   out.putObjectPathA(_instanceNames, false);
                   break;
               }
               case RESP_INSTANCE:
               {
                   if (0 != _instances.size())
                   {
                       out.putInstance(_instances[0], false, false);
                   }
                   break;
               }
               case RESP_INSTANCES:
               {
                   out.putInstanceA(_instances, false);
                   break;
               }
               case RESP_OBJECTS:
               {
                   out.putObjectA(_objects);
                   break;
               }
               case RESP_OBJECTPATHS:
               {
                   // TODO: Determine what to do here
                   break;
               }
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
       if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
       {
           // TODO: Set Marker for SCMO data
   
           // Call magic here to transform a SCMO object into binary format
           fprintf(stderr, "Watch wat ya do'n! SCMO to binary ? NO OOP yet.\n");
           fflush(stderr);
       }
       if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
     {     {
         out.putInstanceA(_namedInstances, false);          // This actually should not happen following general code logic
           PEGASUS_DEBUG_ASSERT(false);
     }     }
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 //------------------------------------------------------------------------------  void CIMResponseData::completeHostNameAndNamespace(
 // Encodes the array of CIMInstance representation contained in the current      const String & hn,
 // CIMResponseData object in xml response message format.      const CIMNamespaceName & ns)
 // This code corresponds to method _resolveXmlInstances, which is used  
 // revert a CIM-XML object array representation back into an array of  
 // CIMInstance.  
 //------------------------------------------------------------------------------  
 void CIMInstancesResponseData::encodeXmlResponse(Buffer& out) const  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,      // Internal XML always has host name and namespace
         "CIMInstancesResponseData::encodeXmlResponse");      // binary data shhould not ever be present here
       PEGASUS_DEBUG_ASSERT((RESP_ENC_BINARY != (_encoding & RESP_ENC_BINARY)));
  
     if (_resolveCallback && !_binaryEncoding)      if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
       {
           switch (_dataType)
           {
               case RESP_OBJECTS:
               {
                   for (Uint32 j = 0, n = _objects.size(); j < n; j++)
                   {
                       const CIMObject& object = _objects[j];
                       CIMObjectPath& p =
                           const_cast<CIMObjectPath&>(object.getPath());
                       if (p.getHost().size()==0)
                       {
                           p.setHost(hn);
                       }
                       if (p.getNameSpace().isNull())
                       {
                           p.setNameSpace(ns);
                       }
                   }
                   break;
               }
               case RESP_OBJECTPATHS:
               {
                   for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)
                   {
                       CIMObjectPath& p = _instanceNames[j];
                       if (p.getHost().size() == 0)
                           p.setHost(hn);
                       if (p.getNameSpace().isNull())
                           p.setNameSpace(ns);
                   }
                   break;
               }
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
       if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
       {
           CString hnCString=hn.getCString();
           const char* hnChars = hnCString;
           Uint32 hnLen = strlen(hnChars);
           CString nsCString=ns.getString().getCString();
           const char* nsChars=nsCString;
           Uint32 nsLen = strlen(nsChars);
           switch (_dataType)
           {
               case RESP_OBJECTS:
               case RESP_OBJECTPATHS:
               {
                   for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
                   {
                       SCMOInstance & scmoInst=_scmoInstances[j];
                       if (0 == scmoInst.getHostName())
                       {
                           scmoInst.setHostName_l(hnChars,hnLen);
                       }
                       if (0 == scmoInst.getNameSpace())
     {     {
         const Array<ArraySint8>& a = _instancesData;                          scmoInst.setNameSpace_l(nsChars,nsLen);
                       }
                   }
                   break;
               }
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
   }
   
   void CIMResponseData::encodeXmlResponse(Buffer& out)
   {
       PEG_TRACE((TRC_XML, Tracer::LEVEL3,
           "CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)\n",
           _encoding,
           _dataType));
   
       if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
       {
           switch (_dataType)
           {
               case RESP_INSTNAMES:
               {
                   const Array<ArraySint8>& a = _referencesData;
                   for (Uint32 i = 0, n = a.size(); i < n; i++)
                   {
                       out.append((char*)a[i].getData(), a[i].size() - 1);
                   }
                   break;
               }
               case RESP_INSTANCE:
               {
                   out.append(
                       (char*)_instanceData.getData(),
                       _instanceData.size()-1);
                   break;
               }
               case RESP_INSTANCES:
               {
                   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++)
Line 378 
Line 413 
             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;
     }     }
     else              case RESP_OBJECTS:
     {     {
         for (Uint32 i = 0, n = _namedInstances.size(); i < n; i++)                  const Array<ArraySint8>& a = _instanceData;
             XmlWriter::appendValueNamedInstanceElement(                  const Array<ArraySint8>& b = _referencesData;
                 out, _namedInstances[i]);  
                   for (Uint32 i = 0, n = a.size(); i < n; i++)
                   {
                       out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
                       out.append((char*)b[i].getData(), b[i].size() - 1);
                       out.append((char*)a[i].getData(), a[i].size() - 1);
                       out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
     }     }
     PEG_METHOD_EXIT();                  break;
 } }
               case RESP_OBJECTPATHS:
               {
                   // TODO: Check what to do in this case
                   const Array<ArraySint8>& a = _instanceData;
                   const Array<ArraySint8>& b = _referencesData;
  
 //------------------------------------------------------------------------------                  for (Uint32 i = 0, n = a.size(); i < n; i++)
 // Instantiates an array of CIMInstances from a binary representation created by  
 // the CIMBinMessageSerializer.  
 // Returns true on success.  
 //------------------------------------------------------------------------------  
 Boolean CIMInstancesResponseData::_resolveBinaryInstances(  
     CIMInstancesResponseData* data,  
     Array<CIMInstance>& instances)  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,                      out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
         "CIMInstancesResponseData::_resolveBinaryInstances");                      out.append((char*)b[i].getData(), b[i].size() - 1);
                       out.append((char*)a[i].getData(), a[i].size() - 1);
                       out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
                   }
               }
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
  
     instances.clear();      if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
       {
           switch (_dataType)
           {
               case RESP_INSTNAMES:
               {
                   for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
                   {
                       XmlWriter::appendInstanceNameElement(out,_instanceNames[i]);
                   }
                   break;
               }
               case RESP_INSTANCE:
               {
                   if (_instances.size()>0)
                   {
                       XmlWriter::appendInstanceElement(out, _instances[0]);
                   }
                   break;
               }
               case RESP_INSTANCES:
               {
                   for (Uint32 i = 0, n = _instances.size(); i < n; i++)
                   {
                       XmlWriter::appendValueNamedInstanceElement(
                           out, _instances[i]);
                   }
                   break;
               }
               case RESP_OBJECTS:
               {
                   for (Uint32 i = 0; i < _objects.size(); i++)
                   {
                       XmlWriter::appendValueObjectWithPathElement(
                           out,
                           _objects[i]);
                   }
                   break;
               }
               case RESP_OBJECTPATHS:
               {
                   for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
                   {
                       out << "<OBJECTPATH>\n";
                       XmlWriter::appendValueReferenceElement(
                           out,
                           _instanceNames[i],
                           false);
                       out << "</OBJECTPATH>\n";
                   }
                   break;
               }
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
       if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
       {
           switch (_dataType)
           {
               case RESP_INSTNAMES:
               {
                   for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
                   {
                       SCMOXmlWriter::appendInstanceNameElement(
                           out,
                           _scmoInstances[i]);
                   }
                   break;
               }
               case RESP_INSTANCE:
               {
                   if (_scmoInstances.size() > 0)
                   {
                       SCMOXmlWriter::appendInstanceElement(out,_scmoInstances[0]);
                   }
                   break;
               }
               case RESP_INSTANCES:
               {
                   for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
                   {
                       SCMOXmlWriter::appendValueSCMOInstanceElement(
                           out,
                           _scmoInstances[i]);
                   }
                   break;
               }
               case RESP_OBJECTS:
               {
                   for (Uint32 i = 0; i < _scmoInstances.size(); i++)
                   {
                       SCMOXmlWriter::appendValueObjectWithPathElement(
                           out,
                           _scmoInstances[i]);
                   }
                   break;
               }
               case RESP_OBJECTPATHS:
               {
                   for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
                   {
                       out << "<OBJECTPATH>\n";
                       SCMOXmlWriter::appendValueReferenceElement(
                           out,
                           _scmoInstances[i],
                           false);
                       out << "</OBJECTPATH>\n";
                   }
                   break;
               }
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
   }
  
     CIMBuffer in((char*)data->_binaryData.getData(), data->_binaryData.size());  // contrary to encodeXmlResponse this function encodes the Xml in a format
   // not usable by clients
   void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out)
   {
       // TODO: Implement
       // Need the full switch here again
       // Should use the internal data available SCMO, C++ and InternalXML
       // to generate the InternalXML by CIMInternalEncoder and SCMOInternalEncoder
       fprintf(stderr, "Watch wat ya do'n! SCMO to InternalXml ? NO OOP yet.\n");
       fflush(stderr);
   }
  
     if (!in.getInstanceA(instances))  void CIMResponseData::_resolveToCIM()
     {     {
         in.release();      PEG_TRACE((TRC_XML, Tracer::LEVEL2,
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,          "CIMResponseData::_resolveToCIM(encoding=%X,content=%X)\n",
             "Failed to remove binary instance!");          _encoding,
         PEG_METHOD_EXIT();          _dataType));
         return false;  
       if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
       {
           _resolveXmlToCIM();
       }
       if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
       {
           _resolveBinary();
       }
       if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
       {
           _resolveSCMOToCIM();
       }
       PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);
     }     }
  
     in.release();  void CIMResponseData::_resolveToSCMO()
     PEG_METHOD_EXIT();  {
     return true;      PEG_TRACE((TRC_XML, Tracer::LEVEL2,
           "CIMResponseData::_resolveToSCMO(encoding=%X,content=%X)\n",
           _encoding,
           _dataType));
   
       if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
       {
           _resolveXmlToSCMO();
       }
       if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
       {
           _resolveBinary();
       }
       if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
       {
           _resolveCIMToSCMO();
       }
       PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO);
 } }
  
   // helper functions to transform different formats into one-another
   // functions work on the internal data and calling of them should be
   // avoided whenever possible
   void CIMResponseData::_resolveBinary()
   {
       // Call magic here to resolve binary format
       fprintf(stderr, "Watch wat ya do'n! binary ? NO OOP yet.\n");
       fflush(stderr);
  
       switch (_dataType)
       {
           case RESP_INSTNAMES:
           {
               break;
           }
           case RESP_INSTANCE:
           {
               break;
           }
           case RESP_INSTANCES:
           {
               break;
           }
           case RESP_OBJECTS:
           {
               break;
           }
           case RESP_OBJECTPATHS:
           {
               break;
           }
           default:
           {
               PEGASUS_DEBUG_ASSERT(false);
           }
       }
   }
  
 //------------------------------------------------------------------------------  void CIMResponseData::_resolveXmlToCIM()
 // Instantiates an array of CIMInstances from an xml representation created by  
 // the CIMBinMessageSerializer.  
 // Returns true on success.  
 //------------------------------------------------------------------------------  
 Boolean CIMInstancesResponseData::_resolveXMLInstances(  
     CIMInstancesResponseData* data,  
     Array<CIMInstance>& instances)  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,      switch (_dataType)
         "CIMInstancesResponseData::_resolveXMLInstances");      {
           // same encoding for instance names and object paths
           case RESP_OBJECTPATHS:
           case RESP_INSTNAMES:
           {
               for (Uint32 i = 0; i < _referencesData.size(); i++)
               {
                   CIMObjectPath cop;
                   // Deserialize path:
                   {
                       XmlParser parser((char*)_referencesData[i].getData());
  
     instances.clear();                      if (XmlReader::getInstanceNameElement(parser, cop))
                       {
                           if (!_nameSpacesData[i].isNull())
                               cop.setNameSpace(_nameSpacesData[i]);
  
     for (Uint32 i = 0; i < data->_instancesData.size(); i++)                          if (_hostsData[i].size())
                               cop.setHost(_hostsData[i]);
                       }
                   }
                   _instanceNames.append(cop);
               }
               break;
           }
           case RESP_INSTANCE:
     {     {
         CIMInstance cimInstance;         CIMInstance cimInstance;
               // Deserialize instance:
               {
                   XmlParser parser((char*)_instanceData[0].getData());
  
                   if (!XmlReader::getInstanceElement(parser, cimInstance))
                   {
                       cimInstance = CIMInstance();
                       PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                           "Failed to resolve XML instance, parser error!");
                   }
               }
               // Deserialize path:
               {
                   XmlParser parser((char*)_referencesData[0].getData());
                   CIMObjectPath cimObjectPath;
   
                   if (XmlReader::getValueReferenceElement(parser, cimObjectPath))
                   {
                       if (_hostsData.size())
                       {
                           cimObjectPath.setHost(_hostsData[0]);
                       }
                       if (!_nameSpacesData[0].isNull())
                       {
                           cimObjectPath.setNameSpace(_nameSpacesData[0]);
                       }
                       cimInstance.setPath(cimObjectPath);
                       // only if everything works we add the CIMInstance to the
                       // array
                       _instances.append(cimInstance);
                   }
               }
               break;
           }
           case RESP_INSTANCES:
           {
               for (Uint32 i = 0; i < _instanceData.size(); i++)
               {
                   CIMInstance cimInstance;
         // Deserialize instance:         // Deserialize instance:
         {         {
             XmlParser parser((char*)data->_instancesData[i].getData());                      XmlParser parser((char*)_instanceData[i].getData());
  
             if (!XmlReader::getInstanceElement(parser, cimInstance))             if (!XmlReader::getInstanceElement(parser, cimInstance))
             {             {
                 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,                 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                     "Failed to resolve XML instance. Creating empty instance!");                              "Failed to resolve XML instance."
                                   " Creating empty instance!");
                 cimInstance = CIMInstance();                 cimInstance = CIMInstance();
             }             }
         }         }
  
         // Deserialize path:         // Deserialize path:
         {         {
             XmlParser parser((char*)data->_referencesData[i].getData());                      XmlParser parser((char*)_referencesData[i].getData());
             CIMObjectPath cimObjectPath;             CIMObjectPath cimObjectPath;
  
             if (XmlReader::getInstanceNameElement(parser, cimObjectPath))             if (XmlReader::getInstanceNameElement(parser, cimObjectPath))
             {             {
                 if (!data->_nameSpacesData[i].isNull())                          if (!_nameSpacesData[i].isNull())
                     cimObjectPath.setNameSpace(data->_nameSpacesData[i]);                              cimObjectPath.setNameSpace(_nameSpacesData[i]);
  
                 if (data->_hostsData[i].size())                          if (_hostsData[i].size())
                     cimObjectPath.setHost(data->_hostsData[i]);                              cimObjectPath.setHost(_hostsData[i]);
  
                 cimInstance.setPath(cimObjectPath);                 cimInstance.setPath(cimObjectPath);
             }             }
         }         }
  
         instances.append(cimInstance);                  _instances.append(cimInstance);
     }     }
               break;
     PEG_METHOD_EXIT();  
     return true;  
 } }
           case RESP_OBJECTS:
           {
               for (Uint32 i=0, n=_instanceData.size(); i<n; i++)
               {
                   CIMObject cimObject;
  
                   // Deserialize Objects:
                   {
                       XmlParser parser((char*)_instanceData[i].getData());
  
 //-----------------------------------------------------------------------------                      CIMInstance cimInstance;
 //                      CIMClass cimClass;
 //  CIMObjectsResponseData  
 //  
 //-----------------------------------------------------------------------------  
   
  
 bool CIMObjectsResponseData::setBinaryCimObjects(CIMBuffer& in)                      if (XmlReader::getInstanceElement(parser, cimInstance))
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,                          cimObject = CIMObject(cimInstance);
         "CIMObjectsResponseData::setBinaryCimObjects");                      }
                       else if (XmlReader::getClassElement(parser, cimClass))
     if (!in.getUint8A(_binaryData))                      {
                           cimObject = CIMObject(cimClass);
                       }
                       else
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
             "Failed to get binary object data!");                              "Failed to get XML object data!");
         PEG_METHOD_EXIT();                      }
         return false;  
     }     }
  
     _resolveCallback = _resolveBinaryObjects;                  // Deserialize paths:
     _binaryEncoding = true;                  {
                       XmlParser parser((char*)_referencesData[i].getData());
     PEG_METHOD_EXIT();                      CIMObjectPath cimObjectPath;
     return true;  
 };  
  
 bool CIMObjectsResponseData::setXmlCimObjects(CIMBuffer& in)                      if (XmlReader::getValueReferenceElement(
                               parser,
                               cimObjectPath))
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,                          if (!_nameSpacesData[i].isNull())
         "CIMObjectsResponseData::setXmlCimObjects");                              cimObjectPath.setNameSpace(_nameSpacesData[i]);
  
     Uint32 count;                          if (_hostsData[i].size())
                               cimObjectPath.setHost(_hostsData[i]);
  
     if (!in.getUint32(count))                          cimObject.setPath(cimObjectPath);
                       }
                   }
                   _objects.append(cimObject);
               }
               break;
           }
           default:
     {     {
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,              PEGASUS_DEBUG_ASSERT(false);
             "Failed to get XML object data (number of objects)!");          }
         PEG_METHOD_EXIT();      }
         return false;      // Xml was resolved, release Xml content now
       _referencesData.clear();
       _hostsData.clear();
       _nameSpacesData.clear();
       _instanceData.clear();
       // remove Xml Encoding flag
       _encoding &=(~RESP_ENC_XML);
       // add CIM Encoding flag
       _encoding |=RESP_ENC_CIM;
     }     }
  
     for (Uint32 i = 0; i < count; i++)  void CIMResponseData::_resolveXmlToSCMO()
     {     {
         Array<Sint8> obj;      // Not optimal, can probably be improved
         Array<Sint8> ref;      // but on the other hand, since using the binary format this case should
         CIMNamespaceName ns;      // actually not ever happen.
         String host;      _resolveXmlToCIM();
       _resolveCIMToSCMO();
   }
  
         if (!in.getSint8A(obj))  void CIMResponseData::_resolveSCMOToCIM()
         {         {
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,      switch(_dataType)
                 "Failed to get XML object data (object)!");      {
             PEG_METHOD_EXIT();          case RESP_INSTNAMES:
             return false;          case RESP_OBJECTPATHS:
           {
               for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
               {
                   CIMObjectPath newObjectPath;
                   _scmoInstances[x].getCIMObjectPath(newObjectPath);
                   _instanceNames.append(newObjectPath);
         }         }
               break;
         if (!in.getSint8A(ref))          }
           case RESP_INSTANCE:
         {         {
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,              if (_scmoInstances.size() > 0)
                 "Failed to get XML object data (reference)!");              {
             PEG_METHOD_EXIT();                  CIMInstance newInstance;
             return false;                  _scmoInstances[0].getCIMInstance(newInstance);
                   _instances.append(newInstance);
         }         }
               break;
         if (!in.getString(host))          }
           case RESP_INSTANCES:
         {         {
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,              for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
                 "Failed to get XML object data (host)!");              {
             PEG_METHOD_EXIT();                  CIMInstance newInstance;
             return false;                  _scmoInstances[x].getCIMInstance(newInstance);
                   _instances.append(newInstance);
         }         }
               break;
         if (!in.getNamespaceName(ns))          }
           case RESP_OBJECTS:
         {         {
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,              for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
                 "Failed to get XML object data (namespace)!");              {
             PEG_METHOD_EXIT();                  CIMInstance newInstance;
             return false;                  _scmoInstances[x].getCIMInstance(newInstance);
                   _objects.append(CIMObject(newInstance));
         }         }
               break;
         _cimObjectsData.append(obj);          }
         _referencesData.append(ref);          default:
         _hostsData.append(host);          {
         _nameSpacesData.append(ns);              PEGASUS_DEBUG_ASSERT(false);
     }     }
       }
     _resolveCallback = _resolveXMLObjects;      _scmoInstances.clear();
     _binaryEncoding = false;      // remove CIM Encoding flag
       _encoding &=(~RESP_ENC_SCMO);
     PEG_METHOD_EXIT();      // add SCMO Encoding flag
     return true;      _encoding |=RESP_ENC_CIM;
 } }
  
 //------------------------------------------------------------------------------  void CIMResponseData::_resolveCIMToSCMO()
 // Encodes the array of CIMObject representation contained in the current  
 // CIMResponseData object in binary response message format.  
 // This code corresponds to method _resolveBinaryObjects, which is used  
 // revert a binary object array representation back into an array of  
 // CIMObject.  
 //------------------------------------------------------------------------------  
 void CIMObjectsResponseData::encodeBinaryResponse(CIMBuffer& out) const  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,      switch (_dataType)
         "CIMObjectsResponseData::encodeBinaryResponse");  
   
     if (_resolveCallback && _binaryEncoding)  
     {     {
         const Array<Uint8>& data = _binaryData;          case RESP_INSTNAMES:
         out.putBytes(data.getData(), data.size());          {
               for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
               {
                   SCMOInstance addme =
                       _getSCMOFromCIMObjectPath(_instanceNames[i]);
                   _scmoInstances.append(addme);
     }     }
     else              _instanceNames.clear();
               break;
           }
           case RESP_INSTANCE:
           {
               if (_instances.size() > 0)
     {     {
         out.putObjectA(_cimObjects);                  SCMOInstance addme =
                       _getSCMOFromCIMInstance(_instances[0]);
                   _scmoInstances.append(addme);
                   _instances.clear();
     }     }
     PEG_METHOD_EXIT();              break;
 } }
           case RESP_INSTANCES:
 //------------------------------------------------------------------------------  
 // Encodes the array of CIMObject representation contained in the current  
 // CIMResponseData object in xml response message format.  
 // This code corresponds to method _resolveXmlObjects, which is used  
 // revert a CIM-XML object array representation back into an array of  
 // CIMObject.  
 //------------------------------------------------------------------------------  
 void CIMObjectsResponseData::encodeXmlResponse(Buffer& out) const  
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,              for (Uint32 i=0,n=_instances.size();i<n;i++)
         "CIMObjectsResponseData::encodeXmlResponse");  
   
     if (_resolveCallback && !_binaryEncoding)  
     {     {
         const Array<ArraySint8>& a = _cimObjectsData;                  SCMOInstance addme = _getSCMOFromCIMInstance(_instances[i]);
         const Array<ArraySint8>& b = _referencesData;                  _scmoInstances.append(addme);
               }
         for (Uint32 i = 0, n = a.size(); i < n; i++)              _instances.clear();
               break;
           }
           case RESP_OBJECTS:
         {         {
             out << STRLIT("<VALUE.OBJECTWITHPATH>\n");              for (Uint32 i=0,n=_objects.size();i<n;i++)
             out.append((char*)b[i].getData(), b[i].size() - 1);              {
             out.append((char*)a[i].getData(), a[i].size() - 1);                  SCMOInstance addme= _getSCMOFromCIMObject(_objects[i]);
             out << STRLIT("</VALUE.OBJECTWITHPATH>\n");                  _scmoInstances.append(addme);
         }         }
               _objects.clear();
               break;
     }     }
     else          case RESP_OBJECTPATHS:
           {
               for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
     {     {
         for (Uint32 i = 0; i < _cimObjects.size(); i++)                  SCMOInstance addme =
                       _getSCMOFromCIMObjectPath(_instanceNames[i]);
                   if (0 == _instanceNames[i].getKeyBindings().size())
         {         {
             XmlWriter::appendValueObjectWithPathElement(out, _cimObjects[i]);                      // if there is no keybinding, this is a class
                       addme.setIsClassOnly(true);
         }         }
                   _scmoInstances.append(addme);
      }      }
     PEG_METHOD_EXIT();              _instanceNames.clear();
               break;
 } }
           default:
 //------------------------------------------------------------------------------  
 // Instantiates an array of CIMObjects from a binary representation created by  
 // the CIMBinMessageSerializer.  
 // Returns true on success.  
 //------------------------------------------------------------------------------  
 Boolean CIMObjectsResponseData::_resolveBinaryObjects(  
     CIMObjectsResponseData* data,  
     Array<CIMObject>& cimObjects)  
 {  
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMObjectsResponseData::_resolveBinaryObjects");  
   
     cimObjects.clear();  
   
     CIMBuffer in((char*)data->_binaryData.getData(), data->_binaryData.size());  
   
     if (!in.getObjectA(cimObjects))  
     {     {
         in.release();              PEGASUS_DEBUG_ASSERT(false);
   
         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,  
             "Failed to resolve binary data!");  
         PEG_METHOD_EXIT();  
         return false;  
     }     }
   
     in.release();  
     PEG_METHOD_EXIT();  
     return true;  
 } }
  
 //------------------------------------------------------------------------------      // remove CIM Encoding flag
 // Instantiates an array of CIMObjects from an xml representation created by      _encoding &=(~RESP_ENC_CIM);
 // the CIMBinMessageSerializer.      // add SCMO Encoding flag
 // Returns true on success.      _encoding |=RESP_ENC_SCMO;
 //------------------------------------------------------------------------------  }
 Boolean CIMObjectsResponseData::_resolveXMLObjects(  
     CIMObjectsResponseData* data,  
     Array<CIMObject>& cimObjects)  
 {  
     PEG_METHOD_ENTER(TRC_DISPATCHER,  
         "CIMObjectsResponseData::_resolveXMLObjects");  
  
     cimObjects.clear();  
  
     for (Uint32 i=0, n=data->_cimObjectsData.size(); i<n; i++)  // Function to convert a CIMInstance into an SCMOInstance
   SCMOInstance CIMResponseData::_getSCMOFromCIMInstance(
       const CIMInstance& cimInst)
     {     {
         CIMObject cimObject;      bool isDirty=false;
       const CIMObjectPath& cimPath = cimInst.getPath();
  
         // Deserialize Objects:      const CString nameSpace = cimPath.getNameSpace().getString().getCString();
       const CString className = cimPath.getClassName().getString().getCString();
   
       SCMOClass * scmoClass = _getSCMOClass(
           (const char*)nameSpace,
           (const char*)className);
       // if class cannot be found we get 0 back from class cache
       if (0 == scmoClass)
         {         {
             XmlParser parser((char*)data->_cimObjectsData[i].getData());          PEG_TRACE((TRC_XML, Tracer::LEVEL2,
               "In _getSCMOFromCIMInstance() could not resolve class for "
                   "nameSpace=\"%s\", className=\"%s\"\n",
               (const char*) nameSpace,
               (const char*) className));
  
             CIMInstance cimInstance;          isDirty=true;
             CIMClass cimClass;          scmoClass = new SCMOClass("","");
       }
       SCMOInstance scmoInst = SCMOInstance(*scmoClass, cimInst);
  
             if (XmlReader::getInstanceElement(parser, cimInstance))      if (isDirty)
             {             {
                 cimObject = CIMObject(cimInstance);          scmoInst.markAsCompromised();
             }             }
             else if (XmlReader::getClassElement(parser, cimClass))      return scmoInst;
             {  
                 cimObject = CIMObject(cimClass);  
             }             }
             else  
   SCMOInstance CIMResponseData::_getSCMOFromCIMObject(
       const CIMObject& cimObj)
             {             {
                 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,      if (cimObj.isClass())
                     "Failed to get XML object data!");      {
           CIMClass retClass(cimObj);
           SCMOInstance theInstance(retClass);
           theInstance.setIsClassOnly(true);
           return theInstance;
             }             }
       return _getSCMOFromCIMInstance(CIMInstance(cimObj));
         }         }
  
         // Deserialize paths:  // Function to convert a CIMObjectPath into an SCMOInstance
   SCMOInstance CIMResponseData::_getSCMOFromCIMObjectPath(
       const CIMObjectPath& cimPath)
         {         {
             XmlParser parser((char*)data->_referencesData[i].getData());      bool isDirty=false;
             CIMObjectPath cimObjectPath;      CString nameSpace = cimPath.getNameSpace().getString().getCString();
       CString className = cimPath.getClassName().getString().getCString();
  
             if (XmlReader::getValueReferenceElement(parser, cimObjectPath))      SCMOClass * scmoClass = _getSCMOClass(
             {          (const char*)nameSpace,
                 if (!data->_nameSpacesData[i].isNull())          (const char*)className);
                     cimObjectPath.setNameSpace(data->_nameSpacesData[i]);  
  
                 if (data->_hostsData[i].size())      // if class cannot be found we get 0 back from class cache
                     cimObjectPath.setHost(data->_hostsData[i]);      if (0 == scmoClass)
       {
           PEG_TRACE((TRC_XML, Tracer::LEVEL2,
               "In _getSCMOFromCIMObjectPath() could not resolve class for "
                   "nameSpace=\"%s\", className=\"%s\"\n",
               (const char*) nameSpace,
               (const char*) className));
  
                 cimObject.setPath(cimObjectPath);          isDirty=true;
           scmoClass = new SCMOClass("","");
             }             }
       SCMOInstance scmoRef = SCMOInstance(*scmoClass, cimPath);
       if (isDirty)
       {
           scmoRef.markAsCompromised();
         }         }
       return scmoRef;
         cimObjects.append(cimObject);  
     }     }
  
     PEG_METHOD_EXIT();  SCMOClass* CIMResponseData::_getSCMOClass(
     return true;      const char* nameSpace,
       const char* cls)
   {
       SCMOClassCache* local = SCMOClassCache::getInstance();
       return local->getSCMOClass(
           nameSpace,
           strlen(nameSpace),
           cls,
           strlen(cls));
 } }
  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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