(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.2.2.11 and 1.13

version 1.2.2.11, 2009/10/20 16:20:51 version 1.13, 2013/03/28 19:54:32
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 34 
Line 41 
 #include <Pegasus/Common/XmlWriter.h> #include <Pegasus/Common/XmlWriter.h>
 #include <Pegasus/Common/SCMOXmlWriter.h> #include <Pegasus/Common/SCMOXmlWriter.h>
 #include <Pegasus/Common/XmlReader.h> #include <Pegasus/Common/XmlReader.h>
 #include <Pegasus/Common/SCMOClassCache.h>  #include <Pegasus/Common/CIMInternalXmlEncoder.h>
   #include <Pegasus/Common/SCMOInternalXmlEncoder.h>
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 57 
Line 65 
 { {
     PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);     PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);
     _resolveToCIM();     _resolveToCIM();
       if (0 == _instances.size())
       {
           _instances.append(CIMInstance());
       }
     return _instances[0];     return _instances[0];
 } }
  
Line 86 
Line 98 
  
 void CIMResponseData::setSCMO(const Array<SCMOInstance>& x) void CIMResponseData::setSCMO(const Array<SCMOInstance>& x)
 { {
     // Just assignment bears danger of us being dependent on the original array  
     // content staying valid  
     _scmoInstances=x;     _scmoInstances=x;
 /*  
     for (Uint32 loop=0, max=x.size(); loop<max; loop++)  
     {  
         _scmoInstances.append(x[loop]);  
     }  
 */  
     // _scmoInstances.appendArray(x);  
     _encoding |= RESP_ENC_SCMO;     _encoding |= RESP_ENC_SCMO;
 } }
  
Line 107 
Line 110 
     return _binaryData;     return _binaryData;
 } }
  
 bool CIMResponseData::setBinary(CIMBuffer& in, bool hasLen)  bool CIMResponseData::setBinary(CIMBuffer& in)
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,      PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setBinary");
         "CIMResponseData::setBinary");  
  
     if (hasLen)      // Append all serial data from the CIMBuffer to the local data store.
     {      // Returns error if input not a serialized Uint8A
         if (!in.getUint8A(_binaryData))         if (!in.getUint8A(_binaryData))
         {         {
             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,             PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                 "Failed to get binary object path data!");              "Failed to get binary input data!");
             PEG_METHOD_EXIT();             PEG_METHOD_EXIT();
             return false;             return false;
         }         }
       _encoding |= RESP_ENC_BINARY;
       PEG_METHOD_EXIT();
       return true;
     }     }
     else  
   bool CIMResponseData::setRemainingBinaryData(CIMBuffer& in)
     {     {
         size_t remainingDataLength = in.capacity() - in.size();      PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setRemainingBinaryData");
   
       // Append any data that has not been deserialized already from
       // the CIMBuffer.
       size_t remainingDataLength = in.remainingDataLength();
         _binaryData.append((Uint8*)in.getPtr(), remainingDataLength);         _binaryData.append((Uint8*)in.getPtr(), remainingDataLength);
     }  
     _encoding |= RESP_ENC_BINARY;     _encoding |= RESP_ENC_BINARY;
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return true;     return true;
Line 134 
Line 144 
  
 bool CIMResponseData::setXml(CIMBuffer& in) bool CIMResponseData::setXml(CIMBuffer& in)
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,      switch (_dataType)
         "CIMResponseData::setXml");      {
           case RESP_INSTANCE:
     if (_dataType == RESP_INSTNAMES)          {
               Array<Sint8> inst;
               Array<Sint8> ref;
               CIMNamespaceName ns;
               String host;
               if (!in.getSint8A(inst))
               {
                   PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                       "Failed to get XML instance data!");
                   return false;
               }
               _instanceData.insert(0,inst);
               if (!in.getSint8A(ref))
               {
                   PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                       "Failed to get XML instance data (reference)!");
                   return false;
               }
               _referencesData.insert(0,ref);
               if (!in.getString(host))
               {
                   PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                       "Failed to get XML instance data (host)!");
                   return false;
               }
               _hostsData.insert(0,host);
               if (!in.getNamespaceName(ns))
               {
                   PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                       "Failed to get XML instance data (namespace)!");
                   return false;
               }
               _nameSpacesData.insert(0,ns);
               break;
           }
           case RESP_INSTANCES:
     {     {
         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 objectpath data (number of paths)!");                      "Failed to get XML instance data (number of instance)!");
             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)!");
                       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 objectpath data (references)!");                          "Failed to get XML instance data (references)!");
                 PEG_METHOD_EXIT();  
                 return false;                 return false;
             }             }
   
             if (!in.getString(host))             if (!in.getString(host))
             {             {
                 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,                 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                     "Failed to get XML instance data (host)!");                     "Failed to get XML instance data (host)!");
                 PEG_METHOD_EXIT();  
                 return false;                 return false;
             }             }
   
             if (!in.getNamespaceName(ns))             if (!in.getNamespaceName(ns))
             {             {
                 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,                 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                     "Failed to get XML instance data (namespace)!");                     "Failed to get XML instance data (namespace)!");
                 PEG_METHOD_EXIT();  
                 return false;                 return false;
             }             }
                   _instanceData.append(inst);
             _referencesData.append(ref);             _referencesData.append(ref);
             _hostsData.append(host);             _hostsData.append(host);
             _nameSpacesData.append(ns);             _nameSpacesData.append(ns);
         }         }
               break;
           }
           case RESP_OBJECTS:
           {
               Uint32 count;
               if (!in.getUint32(count))
               {
                   PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                       "Failed to get XML object data (number of objects)!");
                   return false;
               }
               for (Uint32 i = 0; i < count; i++)
               {
                   Array<Sint8> obj;
                   Array<Sint8> ref;
                   CIMNamespaceName ns;
                   String host;
                   if (!in.getSint8A(obj))
                   {
                       PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                           "Failed to get XML object data (object)!");
                       return false;
                   }
                   if (!in.getSint8A(ref))
                   {
                       PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                           "Failed to get XML object data (reference)!");
                       return false;
                   }
                   if (!in.getString(host))
                   {
                       PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                           "Failed to get XML object data (host)!");
                       return false;
                   }
                   if (!in.getNamespaceName(ns))
                   {
                       PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                           "Failed to get XML object data (namespace)!");
                       return false;
                   }
                   _instanceData.append(obj);
                   _referencesData.append(ref);
                   _hostsData.append(host);
                   _nameSpacesData.append(ns);
               }
               break;
           }
           // internal xml encoding of instance names and object paths not
           // done today
           case RESP_INSTNAMES:
           case RESP_OBJECTPATHS:
           default:
           {
               PEGASUS_DEBUG_ASSERT(false);
           }
     }     }
     // TODO: Code the left out types  
   
     _encoding |= RESP_ENC_XML;     _encoding |= RESP_ENC_XML;
     PEG_METHOD_EXIT();  
     return true;     return true;
 } }
  
Line 222 
Line 318 
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,     PEG_METHOD_ENTER(TRC_DISPATCHER,
         "CIMResponseData::encodeBinaryResponse");         "CIMResponseData::encodeBinaryResponse");
   
     // 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
     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))     if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
Line 233 
Line 328 
     }     }
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
     {     {
         // TODO: Set Marker for C++ data          out.putTypeMarker(BIN_TYPE_MARKER_CPPD);
         switch (_dataType)         switch (_dataType)
         {         {
             case RESP_INSTNAMES:             case RESP_INSTNAMES:
             {             {
                 out.putObjectPathA(_instanceNames, false);                  out.putObjectPathA(_instanceNames);
                 break;                 break;
             }             }
             case RESP_INSTANCE:             case RESP_INSTANCE:
             {             {
                 if (0 != _instances.size())                  if (0 == _instances.size())
                 {                 {
                     out.putInstance(_instances[0], false, false);                      _instances.append(CIMInstance());
                 }                 }
                   out.putInstance(_instances[0], true, true);
                 break;                 break;
             }             }
             case RESP_INSTANCES:             case RESP_INSTANCES:
             {             {
                 out.putInstanceA(_instances, false);                  out.putInstanceA(_instances);
                 break;                 break;
             }             }
             case RESP_OBJECTS:             case RESP_OBJECTS:
Line 261 
Line 357 
             }             }
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
             {             {
                 // TODO: Determine what to do here                  out.putObjectPathA(_instanceNames);
                 break;                 break;
             }             }
             default:             default:
Line 272 
Line 368 
     }     }
     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
     {     {
         // TODO: Set Marker for SCMO data          out.putTypeMarker(BIN_TYPE_MARKER_SCMO);
           out.putSCMOInstanceA(_scmoInstances);
         // 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))     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
     {     {
Line 287 
Line 380 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
   void CIMResponseData::completeNamespace(const SCMOInstance * x)
   {
       const char * ns;
       Uint32 len;
       ns = x->getNameSpace_l(len);
       // Both internal XML as well as binary always contain a namespace
       // don't have to do anything for those two encodings
       if ((RESP_ENC_BINARY == (_encoding&RESP_ENC_BINARY)) && (len != 0))
       {
           _defaultNamespace = CIMNamespaceName(ns);
       }
       if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
       {
           CIMNamespaceName nsName(ns);
           switch (_dataType)
           {
               case RESP_INSTANCE:
               {
                   if (_instances.size() > 0)
                   {
                       const CIMInstance& inst = _instances[0];
                       CIMObjectPath& p =
                           const_cast<CIMObjectPath&>(inst.getPath());
                       if (p.getNameSpace().isNull())
                       {
                           p.setNameSpace(nsName);
                       }
                   }
                   break;
               }
               case RESP_INSTANCES:
               {
                   for (Uint32 j = 0, n = _instances.size(); j < n; j++)
                   {
                       const CIMInstance& inst = _instances[j];
                       CIMObjectPath& p =
                           const_cast<CIMObjectPath&>(inst.getPath());
                       if (p.getNameSpace().isNull())
                       {
                           p.setNameSpace(nsName);
                       }
                   }
                   break;
               }
               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.getNameSpace().isNull())
                       {
                           p.setNameSpace(nsName);
                       }
                   }
                   break;
               }
               case RESP_INSTNAMES:
               case RESP_OBJECTPATHS:
               {
                   for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)
                   {
                       CIMObjectPath& p = _instanceNames[j];
                       if (p.getNameSpace().isNull())
                       {
                           p.setNameSpace(nsName);
                       }
                   }
                   break;
               }
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
       if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
       {
           for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
           {
               SCMOInstance & scmoInst=_scmoInstances[j];
               if (0 == scmoInst.getNameSpace())
               {
                   scmoInst.setNameSpace_l(ns,len);
               }
           }
       }
   }
   
   
 void CIMResponseData::completeHostNameAndNamespace( void CIMResponseData::completeHostNameAndNamespace(
     const String & hn,     const String & hn,
     const CIMNamespaceName & ns)     const CIMNamespaceName & ns)
 { {
     // Internal XML always has host name and namespace      if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
     // binary data shhould not ever be present here      {
     PEGASUS_DEBUG_ASSERT((RESP_ENC_BINARY != (_encoding & RESP_ENC_BINARY)));          // On binary need remember hostname and namespace in case someone
           // builds C++ default objects or Xml types from it later on
           // -> usage: See resolveBinary()
           _defaultNamespace=ns;
           _defaultHostname=hn;
       }
       // InternalXml does not support objectPath calls
       if ((RESP_ENC_XML == (_encoding & RESP_ENC_XML)) &&
               (RESP_OBJECTS == _dataType))
       {
           for (Uint32 j = 0, n = _referencesData.size(); j < n; j++)
           {
               if (0 == _hostsData[j].size())
               {
                   _hostsData[j]=hn;
               }
               if (_nameSpacesData[j].isNull())
               {
                   _nameSpacesData[j]=ns;
               }
           }
       }
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
     {     {
         switch (_dataType)         switch (_dataType)
Line 351 
Line 555 
                 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)                 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
                 {                 {
                     SCMOInstance & scmoInst=_scmoInstances[j];                     SCMOInstance & scmoInst=_scmoInstances[j];
                     if (0 == scmoInst.getHostName())                      scmoInst.completeHostNameAndNamespace(
                     {                          hnChars,
                         scmoInst.setHostName_l(hnChars,hnLen);                          hnLen,
                     }                          nsChars,
                     if (0 == scmoInst.getNameSpace())                          nsLen);
                     {  
                         scmoInst.setNameSpace_l(nsChars,nsLen);  
                     }  
                 }                 }
                 break;                 break;
             }             }
Line 373 
Line 574 
 void CIMResponseData::encodeXmlResponse(Buffer& out) void CIMResponseData::encodeXmlResponse(Buffer& out)
 { {
     PEG_TRACE((TRC_XML, Tracer::LEVEL3,     PEG_TRACE((TRC_XML, Tracer::LEVEL3,
         "CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)\n",          "CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)",
         _encoding,         _encoding,
         _dataType));         _dataType));
  
       // already existing Internal XML does not need to be encoded further
       // binary input is not actually impossible here, but we have an established
       // fallback
       if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
       {
           _resolveBinary();
       }
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
     {     {
         switch (_dataType)         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:             case RESP_INSTANCE:
             {             {
                 out.append(                  const Array<ArraySint8>& a = _instanceData;
                     (char*)_instanceData.getData(),                  out.append((char*)a[0].getData(), a[0].size() - 1);
                     _instanceData.size()-1);  
                 break;                 break;
             }             }
             case RESP_INSTANCES:             case RESP_INSTANCES:
Line 415 
Line 613 
             {             {
                 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");
                     out.append((char*)b[i].getData(), b[i].size() - 1);                      out << STRLIT("<INSTANCEPATH>\n");
                       XmlWriter::appendNameSpacePathElement(
                               out,
                               _hostsData[i],
                               _nameSpacesData[i]);
                       // Leave out the surrounding tags "<VALUE.REFERENCE>\n"
                       // and "</VALUE.REFERENCE>\n" which are 18 and 19 characters
                       // long
                       out.append(
                           ((char*)b[i].getData())+18,
                           b[i].size() - 1 - 18 -19);
                       out << STRLIT("</INSTANCEPATH>\n");
                       // append instance body
                     out.append((char*)a[i].getData(), a[i].size() - 1);                     out.append((char*)a[i].getData(), a[i].size() - 1);
                     out << STRLIT("</VALUE.OBJECTWITHPATH>\n");                     out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
                 }                 }
                 break;                 break;
             }             }
               // internal xml encoding of instance names and object paths not
               // done today
               case RESP_INSTNAMES:
             case RESP_OBJECTPATHS:             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++)  
                 {  
                     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");  
                 }  
             }  
             default:             default:
             {             {
                 PEGASUS_DEBUG_ASSERT(false);                 PEGASUS_DEBUG_ASSERT(false);
Line 462 
Line 661 
             {             {
                 if (_instances.size()>0)                 if (_instances.size()>0)
                 {                 {
                     XmlWriter::appendInstanceElement(out, _instances[0]);                      XmlWriter::appendInstanceElement(
                           out,
                           _instances[0],
                           _includeQualifiers,
                           _includeClassOrigin,
                           _propertyList);
                 }                 }
                 break;                 break;
             }             }
Line 471 
Line 675 
                 for (Uint32 i = 0, n = _instances.size(); i < n; i++)                 for (Uint32 i = 0, n = _instances.size(); i < n; i++)
                 {                 {
                     XmlWriter::appendValueNamedInstanceElement(                     XmlWriter::appendValueNamedInstanceElement(
                         out, _instances[i]);                          out,
                           _instances[i],
                           _includeQualifiers,
                           _includeClassOrigin,
                           _propertyList);
                 }                 }
                 break;                 break;
             }             }
Line 481 
Line 689 
                 {                 {
                     XmlWriter::appendValueObjectWithPathElement(                     XmlWriter::appendValueObjectWithPathElement(
                         out,                         out,
                         _objects[i]);                          _objects[i],
                           _includeQualifiers,
                           _includeClassOrigin,
                           _isClassOperation,
                           _propertyList);
                 }                 }
                 break;                 break;
             }             }
Line 493 
Line 705 
                     XmlWriter::appendValueReferenceElement(                     XmlWriter::appendValueReferenceElement(
                         out,                         out,
                         _instanceNames[i],                         _instanceNames[i],
                           _isClassOperation,
                         false);                         false);
                     out << "</OBJECTPATH>\n";                     out << "</OBJECTPATH>\n";
                 }                 }
Line 515 
Line 728 
                     SCMOXmlWriter::appendInstanceNameElement(                     SCMOXmlWriter::appendInstanceNameElement(
                         out,                         out,
                         _scmoInstances[i]);                         _scmoInstances[i]);
   
                 }                 }
                 break;                 break;
             }             }
Line 522 
Line 736 
             {             {
                 if (_scmoInstances.size() > 0)                 if (_scmoInstances.size() > 0)
                 {                 {
                     SCMOXmlWriter::appendInstanceElement(out,_scmoInstances[0]);                      if(_propertyList.isNull())
                       {
                           Array<Uint32> emptyNodes;
                           SCMOXmlWriter::appendInstanceElement(
                               out,
                               _scmoInstances[0],
                               false,
                               emptyNodes);
                       }
                       else
                       {
                           Array<propertyFilterNodesArray_t> propFilterNodesArrays;
                           // This searches for an already created array of nodes,
                           //if not found, creates it inside propFilterNodesArrays
                           const Array<Uint32> & nodes=
                               SCMOXmlWriter::getFilteredNodesArray(
                                   propFilterNodesArrays,
                                   _scmoInstances[0],
                                   _propertyList);
                           SCMOXmlWriter::appendInstanceElement(
                               out,
                               _scmoInstances[0],
                               true,
                               nodes);
                       }
                 }                 }
                 break;                 break;
             }             }
             case RESP_INSTANCES:             case RESP_INSTANCES:
             {             {
                 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)                  SCMOXmlWriter::appendValueSCMOInstanceElements(
                 {  
                     SCMOXmlWriter::appendValueSCMOInstanceElement(  
                         out,                         out,
                         _scmoInstances[i]);                      _scmoInstances,
                 }                      _propertyList);
                 break;                 break;
             }             }
             case RESP_OBJECTS:             case RESP_OBJECTS:
             {             {
                 for (Uint32 i = 0; i < _scmoInstances.size(); i++)  
                 {  
                     SCMOXmlWriter::appendValueObjectWithPathElement(                     SCMOXmlWriter::appendValueObjectWithPathElement(
                         out,                         out,
                         _scmoInstances[i]);                     _scmoInstances,
                 }                    _propertyList);
                 break;                 break;
             }             }
             case RESP_OBJECTPATHS:             case RESP_OBJECTPATHS:
Line 571 
Line 805 
 // not usable by clients // not usable by clients
 void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out) void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out)
 { {
     // TODO: Implement      PEG_TRACE((TRC_XML, Tracer::LEVEL3,
     // Need the full switch here again          "CIMResponseData::encodeInternalXmlResponse(encoding=%X,content=%X)",
     // Should use the internal data available SCMO, C++ and InternalXML          _encoding,
     // to generate the InternalXML by CIMInternalEncoder and SCMOInternalEncoder          _dataType));
     fprintf(stderr, "Watch wat ya do'n! SCMO to InternalXml ? NO OOP yet.\n");      // For mixed (CIM+SCMO) responses, we need to tell the receiver the
     fflush(stderr);      // total number of instances. The totalSize variable is used to keep track
       // of this.
       Uint32 totalSize = 0;
   
       // already existing Internal XML does not need to be encoded further
       // binary input is not actually impossible here, but we have an established
       // fallback
       if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
       {
           _resolveBinary();
       }
       if ((0 == _encoding) ||
           (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM)))
       {
           switch (_dataType)
           {
               case RESP_INSTANCE:
               {
                   if (0 == _instances.size())
                   {
                       _instances.append(CIMInstance());
                       CIMInternalXmlEncoder::_putXMLInstance(
                           out,
                           _instances[0]);
                       break;
                   }
                   CIMInternalXmlEncoder::_putXMLInstance(
                       out,
                       _instances[0],
                       _includeQualifiers,
                       _includeClassOrigin,
                       _propertyList);
                   break;
               }
               case RESP_INSTANCES:
               {
                   Uint32 n = _instances.size();
                   totalSize = n + _scmoInstances.size();
                   out.putUint32(totalSize);
                   for (Uint32 i = 0; i < n; i++)
                   {
                       CIMInternalXmlEncoder::_putXMLNamedInstance(
                           out,
                           _instances[i],
                           _includeQualifiers,
                           _includeClassOrigin,
                           _propertyList);
                   }
                   break;
               }
               case RESP_OBJECTS:
               {
                   Uint32 n = _objects.size();
                   totalSize = n + _scmoInstances.size();
                   out.putUint32(totalSize);
                   for (Uint32 i = 0; i < n; i++)
                   {
                       CIMInternalXmlEncoder::_putXMLObject(
                           out,
                           _objects[i],
                           _includeQualifiers,
                           _includeClassOrigin,
                           _propertyList);
                   }
                   break;
               }
               // internal xml encoding of instance names and object paths not
               // done today
               case RESP_INSTNAMES:
               case RESP_OBJECTPATHS:
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
       if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
       {
           switch (_dataType)
           {
               case RESP_INSTANCE:
               {
                   if (0 == _scmoInstances.size())
                   {
                       _scmoInstances.append(SCMOInstance());
                   }
                   SCMOInternalXmlEncoder::_putXMLInstance(
                       out,
                       _scmoInstances[0],
                       _propertyList);
                   break;
               }
               case RESP_INSTANCES:
               {
                   Uint32 n = _scmoInstances.size();
                   // Only put the size when not already done above
                   if (0==totalSize)
                   {
                       out.putUint32(n);
                   }
                   SCMOInternalXmlEncoder::_putXMLNamedInstance(
                       out,
                       _scmoInstances,
                       _propertyList);
                   break;
               }
               case RESP_OBJECTS:
               {
                   Uint32 n = _scmoInstances.size();
                   // Only put the size when not already done above
                   if (0==totalSize)
                   {
                       out.putUint32(n);
                   }
                   SCMOInternalXmlEncoder::_putXMLObject(
                       out,
                       _scmoInstances,
                       _propertyList);
                   break;
               }
               // internal xml encoding of instance names and object paths not
               // done today
               case RESP_INSTNAMES:
               case RESP_OBJECTPATHS:
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
   
 } }
  
 void CIMResponseData::_resolveToCIM() void CIMResponseData::_resolveToCIM()
 { {
     PEG_TRACE((TRC_XML, Tracer::LEVEL2,      PEG_TRACE((TRC_XML, Tracer::LEVEL3,
         "CIMResponseData::_resolveToCIM(encoding=%X,content=%X)\n",          "CIMResponseData::_resolveToCIM(encoding=%X,content=%X)",
         _encoding,         _encoding,
         _dataType));         _dataType));
  
Line 598 
Line 962 
     {     {
         _resolveSCMOToCIM();         _resolveSCMOToCIM();
     }     }
   
     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM || _encoding == 0);     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM || _encoding == 0);
 } }
  
 void CIMResponseData::_resolveToSCMO() void CIMResponseData::_resolveToSCMO()
 { {
     PEG_TRACE((TRC_XML, Tracer::LEVEL2,      PEG_TRACE((TRC_XML, Tracer::LEVEL3,
         "CIMResponseData::_resolveToSCMO(encoding=%X,content=%X)\n",          "CIMResponseData::_resolveToSCMO(encoding=%X,content=%X)",
         _encoding,         _encoding,
         _dataType));         _dataType));
  
Line 628 
Line 993 
 // avoided whenever possible // avoided whenever possible
 void CIMResponseData::_resolveBinary() void CIMResponseData::_resolveBinary()
 { {
     // Call magic here to resolve binary format      PEG_METHOD_ENTER(TRC_DISPATCHER,
     fprintf(stderr, "Watch wat ya do'n! binary ? NO OOP yet.\n");          "CIMResponseData::_resolveBinary");
     fflush(stderr);  
       CIMBuffer in((char*)_binaryData.getData(), _binaryData.size());
  
       while (in.more())
       {
           Uint32 binaryTypeMarker=0;
           if(!in.getTypeMarker(binaryTypeMarker))
           {
               PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                   "Failed to get type marker for binary objects!");
               PEG_METHOD_EXIT();
               in.release();
               return;
           }
   
           if (BIN_TYPE_MARKER_SCMO==binaryTypeMarker)
           {
               if (!in.getSCMOInstanceA(_scmoInstances))
               {
                   _encoding &=(~RESP_ENC_BINARY);
                   in.release();
                   PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                       "Failed to resolve binary SCMOInstances!");
                   PEG_METHOD_EXIT();
                   return;
               }
   
               _encoding |= RESP_ENC_SCMO;
           }
           else
           {
     switch (_dataType)     switch (_dataType)
     {     {
         case RESP_INSTNAMES:         case RESP_INSTNAMES:
                   case RESP_OBJECTPATHS:
         {         {
                       if (!in.getObjectPathA(_instanceNames))
                       {
                           _encoding &=(~RESP_ENC_BINARY);
                           in.release();
                           PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                               "Failed to resolve binary CIMObjectPaths!");
                           PEG_METHOD_EXIT();
                           return;
                       }
             break;             break;
         }         }
         case RESP_INSTANCE:         case RESP_INSTANCE:
         {         {
                       CIMInstance instance;
                       if (!in.getInstance(instance))
                       {
                           _encoding &=(~RESP_ENC_BINARY);
                           _encoding |= RESP_ENC_CIM;
                           _instances.append(instance);
                           in.release();
                           PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                               "Failed to resolve binary instance!");
                           PEG_METHOD_EXIT();
                           return;
                       }
   
                       _instances.append(instance);
             break;             break;
         }         }
         case RESP_INSTANCES:         case RESP_INSTANCES:
         {         {
                       if (!in.getInstanceA(_instances))
                       {
                           _encoding &=(~RESP_ENC_BINARY);
                           in.release();
                           PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                               "Failed to resolve binary CIMInstances!");
                           PEG_METHOD_EXIT();
                           return;
                       }
             break;             break;
         }         }
         case RESP_OBJECTS:         case RESP_OBJECTS:
         {         {
             break;                      if (!in.getObjectA(_objects))
         }  
         case RESP_OBJECTPATHS:  
         {         {
                           in.release();
                           _encoding &=(~RESP_ENC_BINARY);
                           PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
                               "Failed to resolve binary CIMObjects!");
                           PEG_METHOD_EXIT();
                           return;
                       }
             break;             break;
         }         }
         default:         default:
         {         {
             PEGASUS_DEBUG_ASSERT(false);             PEGASUS_DEBUG_ASSERT(false);
         }         }
               } // switch
               _encoding |= RESP_ENC_CIM;
           } // else SCMO
     }     }
       _encoding &=(~RESP_ENC_BINARY);
       // fix up the hostname and namespace for objects if defaults
       // were set
       if (_defaultHostname.size() > 0 && !_defaultNamespace.isNull())
       {
           completeHostNameAndNamespace(_defaultHostname, _defaultNamespace);
       }
       in.release();
       PEG_METHOD_EXIT();
 } }
  
 void CIMResponseData::_resolveXmlToCIM()  
 {  void CIMResponseData::_deserializeObject(Uint32 idx,CIMObject& cimObject)
     switch (_dataType)  
     {  
         // same encoding for instance names and object paths  
         case RESP_OBJECTPATHS:  
         case RESP_INSTNAMES:  
         {  
             for (Uint32 i = 0; i < _referencesData.size(); i++)  
             {             {
                 CIMObjectPath cop;      // Only start the parser when instance data is present.
                 // Deserialize path:      if (0 != _instanceData[idx].size())
                 {                 {
                     XmlParser parser((char*)_referencesData[i].getData());          CIMInstance cimInstance;
           CIMClass cimClass;
  
                     if (XmlReader::getInstanceNameElement(parser, cop))          XmlParser parser((char*)_instanceData[idx].getData());
                     {  
                         if (!_nameSpacesData[i].isNull())  
                             cop.setNameSpace(_nameSpacesData[i]);  
  
                         if (_hostsData[i].size())          if (XmlReader::getInstanceElement(parser, cimInstance))
                             cop.setHost(_hostsData[i]);          {
               cimObject = CIMObject(cimInstance);
               return;
                     }                     }
   
           if (XmlReader::getClassElement(parser, cimClass))
           {
               cimObject = CIMObject(cimClass);
               return;
                 }                 }
                 _instanceNames.append(cop);          PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
               "Failed to resolve XML object data, parser error!");
             }             }
             break;  
         }         }
         case RESP_INSTANCE:  
   void CIMResponseData::_deserializeInstance(Uint32 idx,CIMInstance& cimInstance)
         {         {
             CIMInstance cimInstance;      // Only start the parser when instance data is present.
             // Deserialize instance:      if (0 != _instanceData[idx].size())
             {             {
                 XmlParser parser((char*)_instanceData[0].getData());          XmlParser parser((char*)_instanceData[idx].getData());
           if (XmlReader::getInstanceElement(parser, cimInstance))
                 if (!XmlReader::getInstanceElement(parser, cimInstance))  
                 {                 {
                     cimInstance = CIMInstance();              return;
           }
                     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();
             }             }
             // Deserialize path:  
             {  
                 XmlParser parser((char*)_referencesData[0].getData());  
                 CIMObjectPath cimObjectPath;  
  
   Boolean CIMResponseData::_deserializeReference(
       Uint32 idx,
       CIMObjectPath& cimObjectPath)
   {
       // Only start the parser when reference data is present.
       if (0 != _referencesData[idx].size())
       {
           XmlParser parser((char*)_referencesData[idx].getData());
                 if (XmlReader::getValueReferenceElement(parser, cimObjectPath))                 if (XmlReader::getValueReferenceElement(parser, cimObjectPath))
                 {                 {
                     if (_hostsData.size())              if (_hostsData[idx].size())
                     {                     {
                         cimObjectPath.setHost(_hostsData[0]);                  cimObjectPath.setHost(_hostsData[idx]);
                     }                     }
                     if (!_nameSpacesData[0].isNull())              if (!_nameSpacesData[idx].isNull())
                     {                     {
                         cimObjectPath.setNameSpace(_nameSpacesData[0]);                  cimObjectPath.setNameSpace(_nameSpacesData[idx]);
                     }                     }
                     cimInstance.setPath(cimObjectPath);              return true;
                     // 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!");
   
             }             }
             break;      return false;
         }         }
         case RESP_INSTANCES:  
   Boolean CIMResponseData::_deserializeInstanceName(
       Uint32 idx,
       CIMObjectPath& cimObjectPath)
         {         {
             for (Uint32 i = 0; i < _instanceData.size(); i++)      // Only start the parser when instance name data is present.
       if (0 != _referencesData[idx].size())
             {             {
                 CIMInstance cimInstance;          XmlParser parser((char*)_referencesData[idx].getData());
                 // Deserialize instance:          if (XmlReader::getInstanceNameElement(parser, cimObjectPath))
                 {                 {
                     XmlParser parser((char*)_instanceData[i].getData());              if (_hostsData[idx].size())
               {
                     if (!XmlReader::getInstanceElement(parser, cimInstance))                  cimObjectPath.setHost(_hostsData[idx]);
               }
               if (!_nameSpacesData[idx].isNull())
                     {                     {
                   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."              "Failed to resolve XML instance name, parser error!");
                                 " Creating empty instance!");  
                         cimInstance = CIMInstance();  
                     }                     }
       return false;
                 }                 }
  
                 // Deserialize path:  void CIMResponseData::_resolveXmlToCIM()
                 {                 {
                     XmlParser parser((char*)_referencesData[i].getData());      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;
  
                     if (XmlReader::getInstanceNameElement(parser,cimObjectPath))              _deserializeInstance(0,cimInstance);
               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_OBJECTS:          case RESP_INSTANCES:
         {  
             for (Uint32 i=0, n=_instanceData.size(); i<n; i++)  
             {             {
                 CIMObject cimObject;              for (Uint32 i = 0; i < _instanceData.size(); i++)
   
                 // Deserialize Objects:  
                 {                 {
                     XmlParser parser((char*)_instanceData[i].getData());  
   
                     CIMInstance cimInstance;                     CIMInstance cimInstance;
                     CIMClass cimClass;                  CIMObjectPath cimObjectPath;
  
                     if (XmlReader::getInstanceElement(parser, cimInstance))                  _deserializeInstance(i,cimInstance);
                   if (_deserializeInstanceName(i,cimObjectPath))
                     {                     {
                         cimObject = CIMObject(cimInstance);                      cimInstance.setPath(cimObjectPath);
                     }  
                     else if (XmlReader::getClassElement(parser, cimClass))  
                     {  
                         cimObject = CIMObject(cimClass);  
                     }                     }
                     else                  // enumarate instances can be without name
                     {                  _instances.append(cimInstance);
                         PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,  
                             "Failed to get XML object data!");  
                     }                     }
               break;
                 }                 }
           case RESP_OBJECTS:
                 // Deserialize paths:  
                 {                 {
                     XmlParser parser((char*)_referencesData[i].getData());              for (Uint32 i=0, n=_instanceData.size(); i<n; i++)
               {
                   CIMObject cimObject;
                     CIMObjectPath cimObjectPath;                     CIMObjectPath cimObjectPath;
  
                     if (XmlReader::getValueReferenceElement(                  _deserializeObject(i,cimObject);
                             parser,                  if (_deserializeReference(i,cimObjectPath))
                             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;
Line 899 
Line 1346 
  
 void CIMResponseData::_resolveCIMToSCMO() void CIMResponseData::_resolveCIMToSCMO()
 { {
       CString nsCString=_defaultNamespace.getString().getCString();
       const char* _defNamespace = nsCString;
       Uint32 _defNamespaceLen;
       if (_defaultNamespace.isNull())
       {
           _defNamespaceLen=0;
       }
       else
       {
           _defNamespaceLen=strlen(_defNamespace);
       }
     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++)
             {             {
                 SCMOInstance addme =                  SCMOInstance addme(
                     _getSCMOFromCIMObjectPath(_instanceNames[i]);                      _instanceNames[i],
                       _defNamespace,
                       _defNamespaceLen);
                 _scmoInstances.append(addme);                 _scmoInstances.append(addme);
             }             }
             _instanceNames.clear();             _instanceNames.clear();
Line 916 
Line 1376 
         {         {
             if (_instances.size() > 0)             if (_instances.size() > 0)
             {             {
                 SCMOInstance addme =                  SCMOInstance addme(
                     _getSCMOFromCIMInstance(_instances[0]);                      _instances[0],
                       _defNamespace,
                       _defNamespaceLen);
                   _scmoInstances.clear();
                 _scmoInstances.append(addme);                 _scmoInstances.append(addme);
                 _instances.clear();                 _instances.clear();
             }             }
Line 927 
Line 1390 
         {         {
             for (Uint32 i=0,n=_instances.size();i<n;i++)             for (Uint32 i=0,n=_instances.size();i<n;i++)
             {             {
                 SCMOInstance addme = _getSCMOFromCIMInstance(_instances[i]);                  SCMOInstance addme(
                       _instances[i],
                       _defNamespace,
                       _defNamespaceLen);
                 _scmoInstances.append(addme);                 _scmoInstances.append(addme);
             }             }
             _instances.clear();             _instances.clear();
Line 937 
Line 1403 
         {         {
             for (Uint32 i=0,n=_objects.size();i<n;i++)             for (Uint32 i=0,n=_objects.size();i<n;i++)
             {             {
                 SCMOInstance addme= _getSCMOFromCIMObject(_objects[i]);                  SCMOInstance addme(
                       _objects[i],
                       _defNamespace,
                       _defNamespaceLen);
                 _scmoInstances.append(addme);                 _scmoInstances.append(addme);
             }             }
             _objects.clear();             _objects.clear();
Line 947 
Line 1416 
         {         {
             for (Uint32 i=0,n=_instanceNames.size();i<n;i++)             for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
             {             {
                 SCMOInstance addme =                  SCMOInstance addme(
                     _getSCMOFromCIMObjectPath(_instanceNames[i]);                      _instanceNames[i],
                       _defNamespace,
                       _defNamespaceLen);
                   // TODO: More description about this.
                 if (0 == _instanceNames[i].getKeyBindings().size())                 if (0 == _instanceNames[i].getKeyBindings().size())
                 {                 {
                     // if there is no keybinding, this is a class                     // if there is no keybinding, this is a class
Line 971 
Line 1443 
     _encoding |=RESP_ENC_SCMO;     _encoding |=RESP_ENC_SCMO;
 } }
  
   void CIMResponseData::setRequestProperties(
 // Function to convert a CIMInstance into an SCMOInstance      const Boolean includeQualifiers,
 SCMOInstance CIMResponseData::_getSCMOFromCIMInstance(      const Boolean includeClassOrigin,
     const CIMInstance& cimInst)      const CIMPropertyList& propertyList)
 {  
     bool isDirty=false;  
     const CIMObjectPath& cimPath = cimInst.getPath();  
   
     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)  
     {  
         PEG_TRACE((TRC_XML, Tracer::LEVEL2,  
             "In _getSCMOFromCIMInstance() could not resolve class for "  
                 "nameSpace=\"%s\", className=\"%s\"\n",  
             (const char*) nameSpace,  
             (const char*) className));  
   
         isDirty=true;  
         scmoClass = new SCMOClass("","");  
     }  
     SCMOInstance scmoInst = SCMOInstance(*scmoClass, cimInst);  
   
     if (isDirty)  
     {     {
         scmoInst.markAsCompromised();      _includeQualifiers = includeQualifiers;
     }      _includeClassOrigin = includeClassOrigin;
     return scmoInst;      _propertyList = propertyList;
 }  
   
 SCMOInstance CIMResponseData::_getSCMOFromCIMObject(  
     const CIMObject& cimObj)  
 {  
     if (cimObj.isClass())  
     {  
         CIMClass retClass(cimObj);  
         SCMOInstance theInstance(retClass);  
         theInstance.setIsClassOnly(true);  
         return theInstance;  
     }  
     return _getSCMOFromCIMInstance(CIMInstance(cimObj));  
 }  
   
 // Function to convert a CIMObjectPath into an SCMOInstance  
 SCMOInstance CIMResponseData::_getSCMOFromCIMObjectPath(  
     const CIMObjectPath& cimPath)  
 {  
     bool isDirty=false;  
     CString nameSpace = cimPath.getNameSpace().getString().getCString();  
     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)  
     {  
         PEG_TRACE((TRC_XML, Tracer::LEVEL2,  
             "In _getSCMOFromCIMObjectPath() could not resolve class for "  
                 "nameSpace=\"%s\", className=\"%s\"\n",  
             (const char*) nameSpace,  
             (const char*) className));  
   
         isDirty=true;  
         scmoClass = new SCMOClass("","");  
     }  
     SCMOInstance scmoRef = SCMOInstance(*scmoClass, cimPath);  
     if (isDirty)  
     {  
         scmoRef.markAsCompromised();  
     }  
     return scmoRef;  
 } }
  
 SCMOClass* CIMResponseData::_getSCMOClass(  void CIMResponseData::setIsClassOperation(Boolean b)
     const char* nameSpace,  
     const char* cls)  
 { {
     SCMOClassCache* local = SCMOClassCache::getInstance();      _isClassOperation = b;
     return local->getSCMOClass(  
         nameSpace,  
         strlen(nameSpace),  
         cls,  
         strlen(cls));  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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