(file) Return to CMPI_ObjectPath.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI

Diff for /pegasus/src/Pegasus/ProviderManager2/CMPI/CMPI_ObjectPath.cpp between version 1.28 and 1.28.4.1

version 1.28, 2008/12/02 09:01:49 version 1.28.4.1, 2009/08/17 13:47:48
Line 36 
Line 36 
 #include "CMPI_Ftabs.h" #include "CMPI_Ftabs.h"
 #include "CMPI_Value.h" #include "CMPI_Value.h"
 #include "CMPI_String.h" #include "CMPI_String.h"
   #include "CMPISCMOUtilities.h"
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
Line 45 
Line 46 
 { {
     static CMPIStatus refRelease(CMPIObjectPath* eRef)     static CMPIStatus refRelease(CMPIObjectPath* eRef)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
           //fprintf(stderr, "refRelease(%p)\n",ref);
         if (ref)         if (ref)
         {         {
             delete ref;             delete ref;
Line 62 
Line 64 
  
     static CMPIObjectPath* refClone(const CMPIObjectPath* eRef, CMPIStatus* rc)     static CMPIObjectPath* refClone(const CMPIObjectPath* eRef, CMPIStatus* rc)
     {     {
         CIMObjectPath *ref=(CIMObjectPath*)eRef->hdl;          SCMOInstance *ref=(SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 72 
Line 74 
             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
             return NULL;             return NULL;
         }         }
         CIMObjectPath *nRef = new CIMObjectPath(  
             ref->getHost(),          try
             ref->getNameSpace(),          {
             ref->getClassName());              // Since we make no difference between ObjectPath and Instance,
               // we simply clone using the ObjectPathOnly option.
         Array<CIMKeyBinding> kb = ref->getKeyBindings();              SCMOInstance* nRef = new SCMOInstance(ref->clone(true));
         nRef->setKeyBindings(kb);              CMPIObjectPath* cmpiObjPath =
         CMPI_Object* obj = new CMPI_Object(nRef);                  reinterpret_cast<CMPIObjectPath *>(new CMPI_Object(nRef));
         obj->unlink();  
         CMPIObjectPath* neRef = reinterpret_cast<CMPIObjectPath*>(obj);  
         CMSetStatus(rc, CMPI_RC_OK);         CMSetStatus(rc, CMPI_RC_OK);
         return neRef;              return cmpiObjPath;
           }
           catch (const PEGASUS_STD(bad_alloc)&)
           {
               CMSetStatus(rc, CMPI_RC_ERROR_SYSTEM);
               return NULL;
           }
     }     }
  
     static CMPIStatus refSetNameSpace(CMPIObjectPath* eRef, const char *ns)     static CMPIStatus refSetNameSpace(CMPIObjectPath* eRef, const char *ns)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 97 
Line 103 
                 "Received invalid handle in CMPIObjectPath:refSetNameSpace");                 "Received invalid handle in CMPIObjectPath:refSetNameSpace");
             CMReturn(CMPI_RC_ERR_INVALID_HANDLE);             CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
         }         }
   
         if (!ns)         if (!ns)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 106 
Line 113 
                 CMPIObjectPath:refSetNameSpace");                 CMPIObjectPath:refSetNameSpace");
             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
         }         }
         ref->setNameSpace(String(ns));  
           // --rk-->TBD: Implement this
           /*const char* prevNamespace = ref->getNameSpace();
           const char* className = ref->getClassName();
   
           if (prevNamespace &&
               0==strcasecmp(prevNamespace,ns)
           {
           }
   
   
           ref->setNameSpace(String(ns));*/
         CMReturn(CMPI_RC_OK);         CMReturn(CMPI_RC_OK);
     }     }
  
Line 114 
Line 132 
         const CMPIObjectPath* eRef,         const CMPIObjectPath* eRef,
         CMPIStatus* rc)         CMPIStatus* rc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 124 
Line 142 
             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
             return NULL;             return NULL;
         }         }
         const CIMNamespaceName &ns = ref->getNameSpace();          const char *ns = ref->getNameSpace();
         CMPIString *eNs = (CMPIString*)string2CMPIString(ns.getString());          CMPIString *eNs = string2CMPIString(ns);
         CMSetStatus(rc, CMPI_RC_OK);         CMSetStatus(rc, CMPI_RC_OK);
         return eNs;         return eNs;
     }     }
  
     static CMPIStatus refSetHostname(CMPIObjectPath* eRef, const char *hn)     static CMPIStatus refSetHostname(CMPIObjectPath* eRef, const char *hn)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 150 
Line 168 
                 CMPIObjectPath:refSetHostName", hn));                 CMPIObjectPath:refSetHostName", hn));
             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
         }         }
         ref->setHost(String(hn));          ref->setHostName(hn);
         CMReturn(CMPI_RC_OK);         CMReturn(CMPI_RC_OK);
     }     }
  
Line 158 
Line 176 
         const CMPIObjectPath* eRef,         const CMPIObjectPath* eRef,
         CMPIStatus* rc)         CMPIStatus* rc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 168 
Line 186 
             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
             return NULL;             return NULL;
         }         }
         const String &hn = ref->getHost();          const char* hn = ref->getHostName();
         CMPIString *eHn = (CMPIString*)string2CMPIString(hn);          CMPIString *eHn = string2CMPIString(hn);
         CMSetStatus(rc, CMPI_RC_OK);         CMSetStatus(rc, CMPI_RC_OK);
         return eHn;         return eHn;
     }     }
  
     static CMPIStatus refSetClassName(CMPIObjectPath* eRef, const char *cn)     static CMPIStatus refSetClassName(CMPIObjectPath* eRef, const char *cn)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 194 
Line 212 
                 CMPIObjectPath:refSetClassName", cn));                 CMPIObjectPath:refSetClassName", cn));
             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
         }         }
         ref->setClassName(String(cn));          // --rk-->TBD: Implement this
           //ref->setClassName(String(cn));
         CMReturn(CMPI_RC_OK);         CMReturn(CMPI_RC_OK);
     }     }
  
Line 202 
Line 221 
         const CMPIObjectPath* eRef,         const CMPIObjectPath* eRef,
         CMPIStatus* rc)         CMPIStatus* rc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 212 
Line 231 
             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
             return NULL;             return NULL;
         }         }
         const CIMName &cn = ref->getClassName();          const char* cn = ref->getClassName();
         CMPIString* eCn = (CMPIString*)string2CMPIString(cn.getString());          CMPIString* eCn = string2CMPIString(cn);
         CMSetStatus(rc, CMPI_RC_OK);         CMSetStatus(rc, CMPI_RC_OK);
         return eCn;         return eCn;
     }     }
  
  
     static long locateKey(const Array<CIMKeyBinding> &kb, const CIMName &eName)  
     {  
         for (unsigned long i=0,s=kb.size(); i<s; i++)  
         {  
             const String &n = kb[i].getName().getString();  
             if (String::equalNoCase(n,eName.getString()))  
             {  
                 return i;  
             }  
         }  
         return -1;  
     }  
   
     static CMPIStatus refAddKey(     static CMPIStatus refAddKey(
         CMPIObjectPath* eRef,         CMPIObjectPath* eRef,
         const char *name,         const char *name,
         const CMPIValue* data,         const CMPIValue* data,
         const CMPIType type)         const CMPIType type)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 247 
Line 253 
                 "Received invalid handle in CMPIObjectPath:refAddKey");                 "Received invalid handle in CMPIObjectPath:refAddKey");
             CMReturn(CMPI_RC_ERR_INVALID_HANDLE);             CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
         }         }
   
         if (!name)         if (!name)
         {         {
             PEG_TRACE((             PEG_TRACE((
Line 256 
Line 263 
                 CMPIObjectPath:refAddKey", name));                 CMPIObjectPath:refAddKey", name));
             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
         }         }
         Array<CIMKeyBinding> keyBindings = ref->getKeyBindings();  
         CIMName key(name);  
         CMPIrc rc;  
  
         long i = locateKey(keyBindings,key);  
         if (i >= 0)          if ((type & CMPI_ARRAY) || (type == CMPI_instance))
           {
               PEG_TRACE((
                   TRC_CMPIPROVIDERINTERFACE,
                   Tracer::LEVEL1,
                   "Received invalid type %X for parameter %s in \
                   CMPIObjectPath:refAddKey", type, name));
               CMReturn(CMPI_RC_ERR_INVALID_DATA_TYPE);
           }
   
           void* scmoData = (void*)data;
           if (type == CMPI_dateTime)
           {
               scmoData = CMPISCMOUtilities::scmoDateTimeFromCMPI(
                   data->dateTime);
           }
   
           CIMType cimType=type2CIMType(type);
   
           // The value structure of CMPIValue matches that of
           // SCMO Values as long as not an array.
           SCMO_RC rc = ref->setKeyBinding(name,
                                           cimType,
                                           scmoData);
   
           switch (rc)
         {         {
             keyBindings.remove(i);              case SCMO_OK:
                   // Just fall through to the end
                   break;
               case SCMO_TYPE_MISSMATCH:
                   PEG_TRACE((
                       TRC_CMPIPROVIDERINTERFACE,
                       Tracer::LEVEL1,
                       "Received invalid type %d in \
                       CMPIObjectPath:refAddKey", type));
                   CMReturn(CMPI_RC_ERR_INVALID_DATA_TYPE);
                   break;
               case SCMO_NOT_FOUND:
                   PEG_TRACE((
                       TRC_CMPIPROVIDERINTERFACE,
                       Tracer::LEVEL1,
                       "Received invalid parameter %s in \
                       CMPIObjectPath:refAddKey", name));
                   CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
                   break;
               default:
                   PEG_TRACE((
                       TRC_CMPIPROVIDERINTERFACE,
                       Tracer::LEVEL1,
                       "Unknow error %d in \
                       CMPIObjectPath:refAddKey", rc));
                   CMReturn(CMPI_RC_ERR_FAILED);
                   break;
         }         }
  
         CIMValue val = value2CIMValue(data,type,&rc);  
         keyBindings.append(CIMKeyBinding(key,val));  
         ref->setKeyBindings(Array<CIMKeyBinding>(keyBindings));  
         CMReturn(CMPI_RC_OK);         CMReturn(CMPI_RC_OK);
     }     }
  
Line 277 
Line 329 
         const char *name,         const char *name,
         CMPIStatus* rc)         CMPIStatus* rc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         CMPIData data = {0, CMPI_nullValue | CMPI_notFound, {0}};         CMPIData data = {0, CMPI_nullValue | CMPI_notFound, {0}};
  
         if (!ref)         if (!ref)
Line 299 
Line 351 
             CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);             CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
             return data;             return data;
         }         }
         const CIMName eName(name);  
         const Array<CIMKeyBinding> &akb = ref->getKeyBindings();  
         CMSetStatus(rc, CMPI_RC_OK);  
  
         long i = locateKey(akb,eName);          const char* keyValue=0;
         if (i >= 0)          CIMKeyBinding::Type type = (CIMKeyBinding::Type)0;
   
           SCMO_RC src = ref->getKeyBinding(name, type, &keyValue);
           if (src == SCMO_OK)
         {         {
             key2CMPIData(akb[i].getValue(),akb[i].getType(),&data);              scmoKey2CMPIData(keyValue, type, &data);
             return data;              CMSetStatus(rc, CMPI_RC_OK);
         }         }
           else
           {
               // Either SCMO_NULL_VALUE or SCMO_NOT_FOUND
         CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND);         CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND);
           }
   
         return data;         return data;
     }     }
  
Line 319 
Line 376 
         CMPIString** name,         CMPIString** name,
         CMPIStatus* rc)         CMPIStatus* rc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         CMPIData data = {0, CMPI_nullValue | CMPI_notFound, {0}};         CMPIData data = {0, CMPI_nullValue | CMPI_notFound, {0}};
  
         if (!ref)         if (!ref)
Line 332 
Line 389 
             return data;             return data;
         }         }
  
         const Array<CIMKeyBinding> &akb = ref->getKeyBindings();  
         CMSetStatus(rc, CMPI_RC_OK);  
  
         if (pos >= akb.size())          const char* keyValue=0;
           const char* keyName=0;
           CIMKeyBinding::Type type = (CIMKeyBinding::Type)0;
   
           SCMO_RC src = ref->getKeyBindingAt(pos, &keyName, type, &keyValue);
           if (src == SCMO_OK)
         {         {
               scmoKey2CMPIData(keyValue, type, &data);
               CMSetStatus(rc, CMPI_RC_OK);
           }
           else
           {
               // Either SCMO_NULL_VALUE or SCMO_INDEX_OUT_OF_BOUND
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
                 TRC_CMPIPROVIDERINTERFACE,                 TRC_CMPIPROVIDERINTERFACE,
                 Tracer::LEVEL1,                 Tracer::LEVEL1,
                 "Property Not Found - CMPIObjectPath:refGetKeyAt");                 "Property Not Found - CMPIObjectPath:refGetKeyAt");
             CMSetStatus(rc, CMPI_RC_ERR_NO_SUCH_PROPERTY);             CMSetStatus(rc, CMPI_RC_ERR_NO_SUCH_PROPERTY);
             return data;  
         }         }
  
         key2CMPIData(akb[pos].getValue(),akb[pos].getType(),&data);          if (keyName)
   
         if (name)  
         {         {
             const String &n = akb[pos].getName().getString();              *name = (CMPIString*)string2CMPIString(keyName);
             *name = (CMPIString*)string2CMPIString(n);  
         }         }
   
         return data;         return data;
     }     }
  
     static CMPICount refGetKeyCount(const CMPIObjectPath* eRef, CMPIStatus* rc)     static CMPICount refGetKeyCount(const CMPIObjectPath* eRef, CMPIStatus* rc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 367 
Line 430 
             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
             return 0;             return 0;
         }         }
         const Array<CIMKeyBinding> &akb = ref->getKeyBindings();  
         CMSetStatus(rc, CMPI_RC_OK);         CMSetStatus(rc, CMPI_RC_OK);
         return akb.size();          return ref->getKeyBindingCount();
     }     }
  
     static CMPIStatus refSetNameSpaceFromObjectPath(     static CMPIStatus refSetNameSpaceFromObjectPath(
Line 413 
Line 475 
  
     static CMPIString *refToString(const CMPIObjectPath* eRef, CMPIStatus* rc)     static CMPIString *refToString(const CMPIObjectPath* eRef, CMPIStatus* rc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         if (!ref)         if (!ref)
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
Line 423 
Line 485 
             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);             CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
             return NULL;             return NULL;
         }         }
         String str = ref->toString();  
           // Convert to string using CIMObjectPath to guarantee same string
           // represenation for ObjectPaths.
           CIMObjectPath cimObjPath;
           ref->getCIMObjectPath(cimObjPath);
           String str = cimObjPath.toString();
   
         CMSetStatus(rc, CMPI_RC_OK);         CMSetStatus(rc, CMPI_RC_OK);
         return reinterpret_cast<CMPIString*>(new CMPI_Object(str));          return string2CMPIString(str);
     }     }
  
 } }
Line 483 
Line 551 
 CMPIObjectPathFT *CMPI_ObjectPathOnStack_Ftab = &objectPathOnStack_FT; CMPIObjectPathFT *CMPI_ObjectPathOnStack_Ftab = &objectPathOnStack_FT;
  
  
   CMPI_ObjectPathOnStack::CMPI_ObjectPathOnStack(const SCMOInstance& cop)
   {
       hdl = (void*)&cop;
       ft = CMPI_ObjectPathOnStack_Ftab;
   }
   
 CMPI_ObjectPathOnStack::CMPI_ObjectPathOnStack(const CIMObjectPath& cop) CMPI_ObjectPathOnStack::CMPI_ObjectPathOnStack(const CIMObjectPath& cop)
 { {
       fprintf(stderr,"Using non SCMO CMPI_ObjectPathOnStack!!!!\n");
     hdl = (void*)&cop;     hdl = (void*)&cop;
     ft = CMPI_ObjectPathOnStack_Ftab;     ft = CMPI_ObjectPathOnStack_Ftab;
 } }

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