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

Diff for /pegasus/src/Pegasus/ProviderManager2/CMPI/CMPI_Value.cpp between version 1.35 and 1.35.4.11

version 1.35, 2008/12/16 18:56:55 version 1.35.4.11, 2009/11/04 09:04:34
Line 31 
Line 31 
  
 #include "CMPI_Version.h" #include "CMPI_Version.h"
  
   #include <Pegasus/Common/Tracer.h>
 #include "CMPI_String.h" #include "CMPI_String.h"
 #include "CMPI_Value.h" #include "CMPI_Value.h"
   #include "CMPISCMOUtilities.h"
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 110 
Line 112 
     }     }
  
 /** /**
     Function to convert CMPIValue to SCMBUnion
   */
   SCMBUnion value2SCMOValue(const CMPIValue* data,const CMPIType type)
   {
       SCMBUnion scmoData;
   
       if (!(type&CMPI_ARRAY))
       {
   
           switch (type)
           {
           case CMPI_dateTime:
               {
                   CIMDateTimeRep * cimdt =
                       CMPISCMOUtilities::scmoDateTimeFromCMPI(data->dateTime);
                   if (cimdt)
                   {
                       scmoData.dateTimeValue = *cimdt;
                   }
                   break;
               }
           case CMPI_chars:
               {
                   scmoData.extString.pchar = (char*)data;
                   if (scmoData.extString.pchar)
                   {
                       scmoData.extString.length =
                           strlen(scmoData.extString.pchar);
                   }
                   break;
               }
           case CMPI_charsptr:
               {
                   if (data && *(char**)data)
                   {
                       scmoData.extString.pchar = *(char**)data;
                       scmoData.extString.length =
                           strlen(scmoData.extString.pchar);
                   }
                   break;
               }
           case CMPI_string:
               {
                   scmoData.extString.pchar = 0;
                   if (data->string)
                   {
                       scmoData.extString.pchar = (char*)data->string->hdl;
                   }
                   if (scmoData.extString.pchar)
                   {
                       scmoData.extString.length =
                           strlen(scmoData.extString.pchar);
                   }
                   break;
               }
           case CMPI_ref:
           case CMPI_instance:
               {
                   if (data->inst)
                   {
                       scmoData.extRefPtr = (SCMOInstance*)data->inst->hdl;
                   }
                   break;
               }
           default:
               scmoData.simple.val.u64 = data->uint64;
               scmoData.simple.hasValue = 1;
               break;
           }
       }
       else
       {
           // This function does not convert array values, but only single
           // value elements.
           memset(&scmoData, sizeof(SCMBUnion), 0);
   
           PEG_TRACE_CSTRING(
               TRC_CMPIPROVIDERINTERFACE,
               Tracer::LEVEL2,
               "value2SCMOValue does not support array values!!!");
   
       }
       return scmoData;
   }
   
   
   /**
   Function to convert CMPIValue to CIMValue   Function to convert CMPIValue to CIMValue
 */ */
 CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc) CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc)
Line 140 
Line 229 
         }         }
         // When data is not NULL and data->array is also set         // When data is not NULL and data->array is also set
         CMPIArray *ar=data->array;         CMPIArray *ar=data->array;
         CMPIData *aData=(CMPIData*)ar->hdl;          CMPIData *aData=(CMPIData*)((CMPI_Array*)ar->hdl)->hdl;
  
         //Get the type of the elements in the array         //Get the type of the elements in the array
         CMPIType aType=aData->type&~CMPI_ARRAY;         CMPIType aType=aData->type&~CMPI_ARRAY;
Line 217 
Line 306 
             switch( aType )             switch( aType )
             {             {
                 case CMPI_ref:                 case CMPI_ref:
                     CopyToEncArray(CIMObjectPath,ref);                      {
                           Array<CIMObjectPath> arCIMObjectPath(aSize);
                           for (int i=0; i<aSize; i++)
                           {
                               SCMOInstance* scmoInst =
                                   (SCMOInstance*)aData[i].value.ref->hdl;
                               CIMObjectPath ref;
                               scmoInst->getCIMObjectPath(ref);
                               arCIMObjectPath[i]=ref;
                           }
                           v.set(arCIMObjectPath);
                       }
                     break;                     break;
  
                 case CMPI_dateTime:                 case CMPI_dateTime:
                     CopyToEncArray(CIMDateTime,dateTime);                     CopyToEncArray(CIMDateTime,dateTime);
                     break;                     break;
                 case CMPI_instance:                 case CMPI_instance:
                     CopyToEncArray(CIMObject,inst);                      {
                           Array<CIMObject> arCIMInstance(aSize);
                           for (int i=0; i<aSize; i++)
                           {
                               SCMOInstance* scmoInst =
                                   (SCMOInstance*)aData[i].value.inst->hdl;
                               CIMInstance inst;
                               scmoInst->getCIMInstance(inst);
                               CIMObject obj(inst);
                               arCIMInstance[i]=obj;
                           }
                           v.set(arCIMInstance);
                       }
                     break;                     break;
                 case CMPI_boolean:                 case CMPI_boolean:
                     CopyToArray(Boolean,boolean);                     CopyToArray(Boolean,boolean);
Line 340 
Line 452 
             case CMPI_instance:             case CMPI_instance:
                 if( data->inst && data->inst->hdl )                 if( data->inst && data->inst->hdl )
                 {                 {
                     v.set(*((CIMObject*) data->inst->hdl));                      SCMOInstance* scmoInst = (SCMOInstance*)data->inst->hdl;
                       CIMInstance inst;
                       scmoInst->getCIMInstance(inst);
                       CIMObject obj(inst);
                       v.set(obj);
                 }                 }
                 else                 else
                 {                 {
Line 351 
Line 467 
             case CMPI_ref:             case CMPI_ref:
                 if( data->ref && data->ref->hdl )                 if( data->ref && data->ref->hdl )
                 {                 {
                     v.set(*((CIMObjectPath*)data->ref->hdl));                      SCMOInstance* scmoInst = (SCMOInstance*)data->ref->hdl;
                       CIMObjectPath ref;
                       scmoInst->getCIMObjectPath(ref);
                       v.set(ref);
                 }                 }
                 else                 else
                 {                 {
Line 489 
Line 608 
             switch( aType )             switch( aType )
             {             {
                 case CMPI_ref:                 case CMPI_ref:
                     CopyFromEncArray(CIMObjectPath,CMPIObjectPath,ref);                      {
                           Array<CIMObjectPath> arRef;
                           v.get(arRef);
                           for (int i=0; i<aSize; i++)
                           {
                               SCMOInstance* scmoRef =
                                   CMPISCMOUtilities::
                                   getSCMOFromCIMObjectPath(arRef[i]);
                               aData[i].value.ref=
                                   reinterpret_cast<CMPIObjectPath*>(
                                       new CMPI_Object(
                                           scmoRef,
                                           CMPI_Object::ObjectTypeObjectPath));
                           }
                       }
                     break;                     break;
  
                 case CMPI_dateTime:                 case CMPI_dateTime:
                     CopyFromEncArray(CIMDateTime,CMPIDateTime,dateTime);                     CopyFromEncArray(CIMDateTime,CMPIDateTime,dateTime);
                     break;                     break;
   
                 case CMPI_instance:                 case CMPI_instance:
                     if (v.getType() == CIMTYPE_OBJECT)                     if (v.getType() == CIMTYPE_OBJECT)
                     {                     {
Line 502 
Line 636 
                         v.get(tmpObjs);                         v.get(tmpObjs);
                         for (int i = 0; i < aSize ; ++i)                         for (int i = 0; i < aSize ; ++i)
                         {                         {
                           aData[i].value.inst = reinterpret_cast<CMPIInstance*>(                              CIMInstance inst = CIMInstance(tmpObjs[i]);
                                 new CMPI_Object(new CIMInstance(tmpObjs[i])));                              SCMOInstance* scmoInst =
                                   CMPISCMOUtilities::getSCMOFromCIMInstance(inst);
                               aData[i].value.inst =
                                   reinterpret_cast<CMPIInstance*>(
                                       new CMPI_Object(
                                           scmoInst,
                                           CMPI_Object::ObjectTypeInstance));
                         }                         }
                     }                     }
                     else                     else
                     {                     {
                         CopyFromEncArray(CIMInstance,CMPIInstance,inst);                          Array<CIMInstance> arInst;
                           v.get(arInst);
                           for (int i = 0; i < aSize ; ++i)
                           {
                               SCMOInstance* scmoInst =
                                   CMPISCMOUtilities::
                                   getSCMOFromCIMInstance(arInst[i]);
                               aData[i].value.inst =
                                   reinterpret_cast<CMPIInstance*>
                                   (new CMPI_Object(
                                       scmoInst,
                                       CMPI_Object::ObjectTypeInstance));
                           }
                     }                     }
                     break;                     break;
                 case CMPI_boolean:                 case CMPI_boolean:
Line 533 
Line 685 
                     return CMPI_RC_ERR_NOT_SUPPORTED;                     return CMPI_RC_ERR_NOT_SUPPORTED;
             }             }
         data->value.array = reinterpret_cast<CMPIArray*>(         data->value.array = reinterpret_cast<CMPIArray*>(
         new CMPI_Object(aData-1));          new CMPI_Object(new CMPI_Array(aData-1)));
     }  // end of array porocessing     }  // end of array porocessing
  
     //Start of non-array processing     //Start of non-array processing
Line 598 
Line 750 
         }         }
     }     }
  
     //Checking for remaining encapulated and simple types      //Checking for remaining encapsulated and simple types
     else     else
         switch( t )         switch( t )
         {         {
Line 606 
Line 758 
                 {                 {
                     CIMObjectPath ref;                     CIMObjectPath ref;
                     v.get(ref);                     v.get(ref);
                       SCMOInstance* scmoRef =
                          CMPISCMOUtilities:: getSCMOFromCIMObjectPath(ref);
                     data->value.ref = reinterpret_cast<CMPIObjectPath*>(                     data->value.ref = reinterpret_cast<CMPIObjectPath*>(
                     new CMPI_Object(new CIMObjectPath(ref)));                      new CMPI_Object(scmoRef,CMPI_Object::ObjectTypeObjectPath));
                 }                 }
                 break;                 break;
  
Line 624 
Line 778 
                     {                     {
                         v.get(inst);                         v.get(inst);
                     }                     }
                       SCMOInstance* scmoInst =
                           CMPISCMOUtilities::getSCMOFromCIMInstance(inst);
                     data->value.inst = reinterpret_cast<CMPIInstance*>(                     data->value.inst = reinterpret_cast<CMPIInstance*>(
                     new CMPI_Object(new CIMInstance(inst)));                      new CMPI_Object(scmoInst, CMPI_Object::ObjectTypeInstance));
                 }                 }
                 break;                 break;
  
Line 692 
Line 847 
     return(CMPIType)t;     return(CMPIType)t;
 } }
  
 //Function to convert CMPIType to CIMType  
 CIMType type2CIMType(CMPIType pt)  
 {  
     switch( pt )  
     {  
         case CMPI_null:  
             return(CIMType)0;  
   
         case CMPI_boolean:  
             return CIMTYPE_BOOLEAN;  
   
         case CMPI_char16:  
             return CIMTYPE_CHAR16;  
   
         case CMPI_real32:  
             return CIMTYPE_REAL32;  
   
         case CMPI_real64:  
             return CIMTYPE_REAL64;  
   
         case CMPI_uint8:  
             return CIMTYPE_UINT8;  
   
         case CMPI_uint16:  
             return CIMTYPE_UINT16;  
   
         case CMPI_uint32:  
             return CIMTYPE_UINT32;  
   
         case CMPI_uint64:  
             return CIMTYPE_UINT64;  
   
         case CMPI_sint8:  
             return CIMTYPE_SINT8;  
   
         case CMPI_sint16:  
             return CIMTYPE_SINT16;  
   
         case CMPI_sint32:  
             return CIMTYPE_SINT32;  
   
         case CMPI_sint64:  
             return CIMTYPE_SINT64;  
   
         case CMPI_string:  
             return CIMTYPE_STRING;  
   
         case CMPI_chars:  
             return CIMTYPE_STRING;  
   
         case CMPI_charsptr:  
             return CIMTYPE_STRING;  
   
         case CMPI_dateTime:  
             return CIMTYPE_DATETIME;  
   
         case CMPI_ref:  
             return CIMTYPE_REFERENCE;  
         case CMPI_instance:  
             return CIMTYPE_INSTANCE;  
         default:  
             return(CIMType)0;  
     }  
 }  
   
 //Function to convert CIMKeyBindings to CMPIData  
 CMPIrc key2CMPIData(const String& v, CIMKeyBinding::Type t, CMPIData *data)  
 {  
     data->state=CMPI_keyValue;  
     switch( t )  
     {  
         case CIMKeyBinding::NUMERIC:  
             {  
                 CString vp=v.getCString();  
   
                 data->value.sint64 = 0;  
                 if( *((const char*)vp)=='-' )  
                 {  
                     sscanf(  
                         (const char*)vp,  
                         "%" PEGASUS_64BIT_CONVERSION_WIDTH "d",  
                     &data->value.sint64);  
                     data->type=CMPI_sint64;  
                 }  
                 else  
                 {  
                     sscanf(  
                         (const char*)vp,  
                         "%" PEGASUS_64BIT_CONVERSION_WIDTH "u",  
                     &data->value.uint64);  
                     data->type=CMPI_uint64;  
                 }  
             }  
             break;  
   
         case CIMKeyBinding::STRING:  
             data->value.string=string2CMPIString(v);  
             data->type=CMPI_string;  
             break;  
   
         case CIMKeyBinding::BOOLEAN:  
             data->value.boolean=(String::equalNoCase(v,"true"));  
             data->type=CMPI_boolean;  
             break;  
   
         case CIMKeyBinding::REFERENCE:  
             data->value.ref=reinterpret_cast<CMPIObjectPath*>(  
             new CMPI_Object(new CIMObjectPath(v)));  
             data->type=CMPI_ref;  
             break;  
   
         default:  
             return CMPI_RC_ERR_NOT_SUPPORTED;  
     }  
     return CMPI_RC_OK;  
 }  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  

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