(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.9

version 1.28, 2008/12/02 09:01:49 version 1.28.4.9, 2009/10/24 23:34:49
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 "CMPI_Broker.h"
   #include "CMPISCMOUtilities.h"
 #include <Pegasus/Common/Tracer.h> #include <Pegasus/Common/Tracer.h>
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
Line 45 
Line 47 
 { {
     static CMPIStatus refRelease(CMPIObjectPath* eRef)     static CMPIStatus refRelease(CMPIObjectPath* eRef)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
         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 *>
         obj->unlink();                  (new CMPI_Object(nRef,CMPI_Object::ObjectTypeObjectPath));
         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 104 
                 "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 114 
                 CMPIObjectPath:refSetNameSpace");                 CMPIObjectPath:refSetNameSpace");
             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);             CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
         }         }
         ref->setNameSpace(String(ns));  
   
           // Check if the namespace is at all different from the one already set
           const char* prevNamespace = ref->getNameSpace();
           if (prevNamespace && 0==strcasecmp(prevNamespace,ns))
           {
               CMReturn(CMPI_RC_OK);
           }
   
           ref->setNameSpace(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));  
           // Check if the classname is at all different from the one already set
           const char* prevCls = ref->getClassName();
           if (prevCls && 0==strcasecmp(prevCls,cn))
           {
               CMReturn(CMPI_RC_OK);
           }
   
           ref->setClassName(cn);
   
         CMReturn(CMPI_RC_OK);         CMReturn(CMPI_RC_OK);
     }     }
  
Line 202 
Line 229 
         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 239 
             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 261 
                 "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 271 
                 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);
           }
   
           CIMType cimType=type2CIMType(type);
   
           CMPIrc cmpiRC = CMPI_RC_OK;
           SCMBUnion scmoData = value2SCMOValue(data, type);
           if (cmpiRC != CMPI_RC_OK)
           {
               PEG_TRACE((
                   TRC_CMPIPROVIDERINTERFACE,
                   Tracer::LEVEL1,
                   "Failed to convert CMPIData to SCMOValue in \
                   CMPIObjectPath:refAddKey(%d,%s)", type, name));
               CMReturn(cmpiRC);
           }
   
           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 340 
         const char *name,         const char *name,
         CMPIStatus* rc)         CMPIStatus* rc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
           // Attn: According to CMPI 2.0 specification CMPIData.state
           //       shall be set to CMPI_noValue in case of an error.
           //       But this is not yet defined in cmpidt.h
         CMPIData data = {0, CMPI_nullValue | CMPI_notFound, {0}};         CMPIData data = {0, CMPI_nullValue | CMPI_notFound, {0}};
  
         if (!ref)         if (!ref)
Line 299 
Line 365 
             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);  
         if (i >= 0)          const SCMBUnion* keyValue=0;
           CIMType type;
   
           SCMO_RC src = ref->getKeyBinding(name, type, &keyValue);
           if (src == SCMO_OK)
         {         {
             key2CMPIData(akb[i].getValue(),akb[i].getType(),&data);              CMPIType ct=type2CMPIType(type, false);
             return data;              CMPISCMOUtilities::scmoValue2CMPIData( keyValue, ct, &data );
   
               if ((ct&~CMPI_ARRAY) == CMPI_string)
               {
                   // We always receive strings as an array of pointers
                   // with at least one element, which needs to be released
                   // after it was converted to CMPIData
                   free((void*)keyValue);
               }
   
               data.state |= CMPI_keyValue;
   
               //TODO: Convert all types to keytypes
               //      datetime->string
               //      real->string
               switch (ct)
               {
               case CMPI_uint8:
                   data.value.uint64=(CMPIUint64)data.value.uint8;
                   break;
               case CMPI_uint16:
                   data.value.uint64=(CMPIUint64)data.value.uint16;
                   break;
               case CMPI_uint32:
                   data.value.uint64=(CMPIUint64)data.value.uint32;
                   break;
               case CMPI_sint8:
                   data.value.sint64=(CMPISint64)data.value.sint8;
                   break;
               case CMPI_sint16:
                   data.value.sint64=(CMPISint64)data.value.sint16;
                   break;
               case CMPI_sint32:
                   data.value.sint64=(CMPISint64)data.value.sint32;
                   break;
         }         }
   
               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);
               // TODO: According to the CMPI Specification this should be
               //       really CMPI_RC_ERR_NO_SUCH_PROPERTY
           }
   
         return data;         return data;
     }     }
  
Line 319 
Line 430 
         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 443 
             return data;             return data;
         }         }
  
         const Array<CIMKeyBinding> &akb = ref->getKeyBindings();  
         CMSetStatus(rc, CMPI_RC_OK);  
  
         if (pos >= akb.size())          const SCMBUnion* keyValue=0;
           const char* keyName=0;
           CIMType type;
   
           SCMO_RC src = ref->getKeyBindingAt(pos, &keyName, type, &keyValue);
           if (src == SCMO_OK)
           {
               CMPIType ct=type2CMPIType(type, false);
               CMPISCMOUtilities::scmoValue2CMPIData( keyValue, ct, &data );
               if ((ct&~CMPI_ARRAY) == CMPI_string)
               {
                   // We always receive strings as an array of pointers
                   // with at least one element, which needs to be released
                   // after it was converted to CMPIData
                   free((void*)keyValue);
               }
               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 && name)
   
         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 492 
             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(
         CMPIObjectPath* eRef,         CMPIObjectPath* eRef,
         const CMPIObjectPath* eSrc)         const CMPIObjectPath* eSrc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* src = (SCMOInstance*)eSrc->hdl;
         CIMObjectPath* src = (CIMObjectPath*)eSrc->hdl;          if (!src)
         if (!ref || !src)  
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
                 TRC_CMPIPROVIDERINTERFACE,                 TRC_CMPIPROVIDERINTERFACE,
Line 387 
Line 510 
                 CMPIObjectPath:refSetNameSpaceFromObjectPath");                 CMPIObjectPath:refSetNameSpaceFromObjectPath");
             CMReturn(CMPI_RC_ERR_INVALID_HANDLE);             CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
         }         }
         ref->setNameSpace(src->getNameSpace());  
         CMReturn(CMPI_RC_OK);          return refSetNameSpace(eRef, src->getNameSpace());
     }     }
  
     static CMPIStatus refSetHostAndNameSpaceFromObjectPath(     static CMPIStatus refSetHostAndNameSpaceFromObjectPath(
         CMPIObjectPath* eRef,         CMPIObjectPath* eRef,
         const CMPIObjectPath* eSrc)         const CMPIObjectPath* eSrc)
     {     {
         CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;          SCMOInstance* src = (SCMOInstance*)eSrc->hdl;
         CIMObjectPath* src = (CIMObjectPath*)eSrc->hdl;          if (!src)
         if (!ref || !src)  
         {         {
             PEG_TRACE_CSTRING(             PEG_TRACE_CSTRING(
                 TRC_CMPIPROVIDERINTERFACE,                 TRC_CMPIPROVIDERINTERFACE,
Line 406 
Line 528 
                 CMPIObjectPath:refSetHostAndNameSpaceFromObjectPath");                 CMPIObjectPath:refSetHostAndNameSpaceFromObjectPath");
             CMReturn(CMPI_RC_ERR_INVALID_HANDLE);             CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
         }         }
         ref->setNameSpace(src->getNameSpace());  
         ref->setHost(src->getHost());          CMPIStatus rc = refSetNameSpace(eRef, src->getNameSpace());
   
           if (rc.rc != CMPI_RC_OK)
           {
               return rc;
           }
   
           SCMOInstance* ref = (SCMOInstance*)eRef->hdl;
           if (ref)
           {
               ref->setHostName(src->getHostName());
           }
   
         CMReturn(CMPI_RC_OK);         CMReturn(CMPI_RC_OK);
     }     }
  
     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 557 
             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 623 
 CMPIObjectPathFT *CMPI_ObjectPathOnStack_Ftab = &objectPathOnStack_FT; CMPIObjectPathFT *CMPI_ObjectPathOnStack_Ftab = &objectPathOnStack_FT;
  
  
 CMPI_ObjectPathOnStack::CMPI_ObjectPathOnStack(const CIMObjectPath& cop)  CMPI_ObjectPathOnStack::CMPI_ObjectPathOnStack(const SCMOInstance& cop)
 { {
     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.9
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2