(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.8 and 1.2.2.11

version 1.2.2.8, 2009/10/15 11:47:35 version 1.2.2.11, 2009/10/20 16:20:51
Line 48 
Line 48 
     PEGASUS_DEBUG_ASSERT(     PEGASUS_DEBUG_ASSERT(
     (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));     (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));
     _resolveToCIM();     _resolveToCIM();
     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);      PEGASUS_DEBUG_ASSERT(_encoding==RESP_ENC_CIM || _encoding == 0);
     return _instanceNames;     return _instanceNames;
 } }
  
Line 57 
Line 57 
 { {
     PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);     PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);
     _resolveToCIM();     _resolveToCIM();
     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);  
     return _instances[0];     return _instances[0];
 } }
  
Line 66 
Line 65 
 { {
     PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES);     PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES);
     _resolveToCIM();     _resolveToCIM();
     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);  
     return _instances;     return _instances;
 } }
  
Line 75 
Line 73 
 { {
     PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);     PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);
     _resolveToCIM();     _resolveToCIM();
     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);  
     return _objects;     return _objects;
 } }
  
Line 84 
Line 81 
 Array<SCMOInstance>& CIMResponseData::getSCMO() Array<SCMOInstance>& CIMResponseData::getSCMO()
 { {
     _resolveToSCMO();     _resolveToSCMO();
     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO);  
     return _scmoInstances;     return _scmoInstances;
 } }
  
Line 107 
Line 103 
 // Binary data is just a data stream // Binary data is just a data stream
 Array<Uint8>& CIMResponseData::getBinary() Array<Uint8>& CIMResponseData::getBinary()
 { {
     // TODO: Check if the following condition might come true      PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_BINARY || _encoding == 0);
     // One actually should resolve everything down to binary in here ...  
     return _binaryData;     return _binaryData;
 } }
  
Line 292 
Line 287 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
 void CIMResponseData::encodeXmlResponse(Buffer& out)  void CIMResponseData::completeHostNameAndNamespace(
       const String & hn,
       const CIMNamespaceName & ns)
   {
       // Internal XML always has host name and namespace
       // binary data shhould not ever be present here
       PEGASUS_DEBUG_ASSERT((RESP_ENC_BINARY != (_encoding & RESP_ENC_BINARY)));
   
       if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
 { {
     PEG_METHOD_ENTER(TRC_DISPATCHER,          switch (_dataType)
         "CIMResponseData::encodeXmlResponse");          {
               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())
                       {
                           scmoInst.setNameSpace_l(nsChars,nsLen);
                       }
                   }
                   break;
               }
               default:
               {
                   PEGASUS_DEBUG_ASSERT(false);
               }
           }
       }
   }
  
     fprintf(  void CIMResponseData::encodeXmlResponse(Buffer& out)
         stderr,  {
         "encodeXmlResponse(encoding=%X,content=%X)\n",      PEG_TRACE((TRC_XML, Tracer::LEVEL3,
           "CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)\n",
         _encoding,         _encoding,
         _dataType);          _dataType));
     fflush(stderr);  
  
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
     {     {
Line 375 
Line 448 
  
     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))     if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
     {     {
         fprintf(stderr,"Got CIM data...\n");  
         fflush(stderr);  
         // TODO: Set Marker for C++ data  
         switch (_dataType)         switch (_dataType)
         {         {
             case RESP_INSTNAMES:             case RESP_INSTNAMES:
Line 436 
Line 506 
     }     }
     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))     if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
     {     {
         /*SCMODump dmp;  
         dmp.dumpSCMOInstanceKeyBindings(_scmoInstances[i]);  
         dmp.dumpInstanceProperties(_scmoInstances[i]);*/  
         fprintf(  
             stderr,"encodeXmlResponse(SCMO)=%d instances...\n",  
             _scmoInstances.size());  
         fflush(stderr);  
   
         switch (_dataType)         switch (_dataType)
         {         {
             case RESP_INSTNAMES:             case RESP_INSTNAMES:
Line 503 
Line 565 
             }             }
         }         }
     }     }
     fprintf(  
         stderr,  
         "After XmlWrite()\n%s",  
         out.getData());  
     fflush(stderr);  
 } }
  
 // contrary to encodeXmlResponse this function encodes the Xml in a format // contrary to encodeXmlResponse this function encodes the Xml in a format
Line 524 
Line 581 
  
 void CIMResponseData::_resolveToCIM() void CIMResponseData::_resolveToCIM()
 { {
     fprintf(      PEG_TRACE((TRC_XML, Tracer::LEVEL2,
         stderr,          "CIMResponseData::_resolveToCIM(encoding=%X,content=%X)\n",
         "_resolveToCIM(encoding=%X,content=%X)\n",  
         _encoding,         _encoding,
         _dataType);          _dataType));
     fflush(stderr);  
  
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
     {     {
Line 543 
Line 598 
     {     {
         _resolveSCMOToCIM();         _resolveSCMOToCIM();
     }     }
     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM);      PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM || _encoding == 0);
 } }
  
 void CIMResponseData::_resolveToSCMO() void CIMResponseData::_resolveToSCMO()
 { {
     fprintf(      PEG_TRACE((TRC_XML, Tracer::LEVEL2,
         stderr,          "CIMResponseData::_resolveToSCMO(encoding=%X,content=%X)\n",
         "_resolveToSCMO(encoding=%X,content=%X)\n",  
         _encoding,         _encoding,
         _dataType);          _dataType));
     fflush(stderr);  
  
     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))     if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
     {     {
Line 567 
Line 620 
     {     {
         _resolveCIMToSCMO();         _resolveCIMToSCMO();
     }     }
     PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO);      PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO || _encoding == 0);
 } }
  
 // helper functions to transform different formats into one-another // helper functions to transform different formats into one-another
Line 612 
Line 665 
 { {
     switch (_dataType)     switch (_dataType)
     {     {
           // same encoding for instance names and object paths
           case RESP_OBJECTPATHS:
         case RESP_INSTNAMES:         case RESP_INSTNAMES:
         {         {
             for (Uint32 i = 0; i < _referencesData.size(); i++)             for (Uint32 i = 0; i < _referencesData.size(); i++)
Line 760 
Line 815 
             }             }
             break;             break;
         }         }
         case RESP_OBJECTPATHS:  
         {  
             // TODO: ????  
         }  
         default:         default:
         {         {
             PEGASUS_DEBUG_ASSERT(false);             PEGASUS_DEBUG_ASSERT(false);
Line 851 
Line 902 
     switch (_dataType)     switch (_dataType)
     {     {
         case RESP_INSTNAMES:         case RESP_INSTNAMES:
         case RESP_OBJECTPATHS:  
         {         {
             for (Uint32 i=0,n=_instanceNames.size();i<n;i++)             for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
             {             {
Line 887 
Line 937 
         {         {
             for (Uint32 i=0,n=_objects.size();i<n;i++)             for (Uint32 i=0,n=_objects.size();i<n;i++)
             {             {
                 // TODO: Use a new constructor here                  SCMOInstance addme= _getSCMOFromCIMObject(_objects[i]);
                 // SCMOInstance(CIMObject)  
                 SCMOInstance addme=  
                     _getSCMOFromCIMInstance(CIMInstance(_objects[i]));  
                 _scmoInstances.append(addme);                 _scmoInstances.append(addme);
             }             }
             _objects.clear();             _objects.clear();
             break;             break;
         }         }
           case RESP_OBJECTPATHS:
           {
               for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
               {
                   SCMOInstance addme =
                       _getSCMOFromCIMObjectPath(_instanceNames[i]);
                   if (0 == _instanceNames[i].getKeyBindings().size())
                   {
                       // if there is no keybinding, this is a class
                       addme.setIsClassOnly(true);
                   }
                   _scmoInstances.append(addme);
               }
               _instanceNames.clear();
               break;
           }
         default:         default:
         {         {
             PEGASUS_DEBUG_ASSERT(false);             PEGASUS_DEBUG_ASSERT(false);
Line 913 
Line 976 
 SCMOInstance CIMResponseData::_getSCMOFromCIMInstance( SCMOInstance CIMResponseData::_getSCMOFromCIMInstance(
     const CIMInstance& cimInst)     const CIMInstance& cimInst)
 { {
       bool isDirty=false;
     const CIMObjectPath& cimPath = cimInst.getPath();     const CIMObjectPath& cimPath = cimInst.getPath();
  
     const CString nameSpace = cimPath.getNameSpace().getString().getCString();     const CString nameSpace = cimPath.getNameSpace().getString().getCString();
     const CString className = cimPath.getClassName().getString().getCString();     const CString className = cimPath.getClassName().getString().getCString();
     // TODO: What do when either or both are 0 ?  
  
     SCMOClass * scmoClass = _getSCMOClass(     SCMOClass * scmoClass = _getSCMOClass(
         (const char*)nameSpace,         (const char*)nameSpace,
         (const char*)className);         (const char*)className);
     // TODO: What do when there is no such class ?      // 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);     SCMOInstance scmoInst = SCMOInstance(*scmoClass, cimInst);
  
       if (isDirty)
       {
           scmoInst.markAsCompromised();
       }
     return scmoInst;     return scmoInst;
 } }
  
   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 // Function to convert a CIMObjectPath into an SCMOInstance
 SCMOInstance CIMResponseData::_getSCMOFromCIMObjectPath( SCMOInstance CIMResponseData::_getSCMOFromCIMObjectPath(
     const CIMObjectPath& cimPath)     const CIMObjectPath& cimPath)
 { {
       bool isDirty=false;
     CString nameSpace = cimPath.getNameSpace().getString().getCString();     CString nameSpace = cimPath.getNameSpace().getString().getCString();
     CString className = cimPath.getClassName().getString().getCString();     CString className = cimPath.getClassName().getString().getCString();
  
     // TODO: What do when either or both are 0 ?  
   
     SCMOClass * scmoClass = _getSCMOClass(     SCMOClass * scmoClass = _getSCMOClass(
         (const char*)nameSpace,         (const char*)nameSpace,
         (const char*)className);         (const char*)className);
  
     // TODO: What do when there is no such class ?      // 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));
  
     // TODO: Interrogate Thilo about need to call new          isDirty=true;
           scmoClass = new SCMOClass("","");
       }
     SCMOInstance scmoRef = SCMOInstance(*scmoClass, cimPath);     SCMOInstance scmoRef = SCMOInstance(*scmoClass, cimPath);
       if (isDirty)
       {
           scmoRef.markAsCompromised();
       }
     return scmoRef;     return scmoRef;
 } }
  

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