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

version 1.35, 2008/12/16 18:56:55 version 1.35.4.5, 2009/10/06 10:07:54
Line 33 
Line 33 
  
 #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 77 
Line 78 
         v.set(ar##pt); \         v.set(ar##pt); \
     }     }
  
   #define CopyToInstanceArray() \
       { \
           Array<CIMInstance> arCIMInstance(aSize); \
           for (int i=0; i<aSize; i++) \
           { \
               SCMOInstance* scmoInst = (SCMOInstance*)aData[i].value.inst->hdl; \
               CIMInstance inst; \
               scmoInst->getCIMInstance(inst); \
               arCIMInstance[i]=inst; \
           } \
           v.set(arCIMInstance); \
       }
   
   #define CopyToObjectPathArray() \
       { \
           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); \
       }
   
 #define CopyFromArray(pt,ct) \ #define CopyFromArray(pt,ct) \
     { \     { \
         Array<pt> ar##pt; \         Array<pt> ar##pt; \
Line 110 
Line 137 
     }     }
  
 /** /**
     Function to convert CMPIValue to SCMBUnion
   */
   SCMBUnion value2SCMOValue(const CMPIValue* data,const CMPIType type)
   {
       SCMBUnion scmoData;
       scmoData.simple.val.u64 = data->uint64;
       scmoData.simple.hasValue = 1;
   
       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 = (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;
               }
           }
       }
       else
       {
           //Array Implementation goes here ....
       }
       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 241 
         }         }
         // 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 318 
             switch( aType )             switch( aType )
             {             {
                 case CMPI_ref:                 case CMPI_ref:
                     CopyToEncArray(CIMObjectPath,ref);                      CopyToObjectPathArray();
                     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);                      CopyToInstanceArray();
                     break;                     break;
                 case CMPI_boolean:                 case CMPI_boolean:
                     CopyToArray(Boolean,boolean);                     CopyToArray(Boolean,boolean);
Line 340 
Line 441 
             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);
                       v.set((CIMObject)inst);
                 }                 }
                 else                 else
                 {                 {
Line 351 
Line 455 
             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 596 
             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));
                           }
                       }
                     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 622 
                         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,true));
                         }                         }
                     }                     }
                     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, true));
                           }
                     }                     }
                     break;                     break;
                 case CMPI_boolean:                 case CMPI_boolean:
Line 533 
Line 667 
                     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 732 
         }         }
     }     }
  
     //Checking for remaining encapulated and simple types      //Checking for remaining encapsulated and simple types
     else     else
         switch( t )         switch( t )
         {         {
Line 606 
Line 740 
                 {                 {
                     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));
                 }                 }
                 break;                 break;
  
Line 624 
Line 760 
                     {                     {
                         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, true));
                 }                 }
                 break;                 break;
  
Line 692 
Line 829 
     return(CMPIType)t;     return(CMPIType)t;
 } }
  
 //Function to convert CMPIType to CIMType  //Function to convert a key string into CMPIData
 CIMType type2CIMType(CMPIType pt)  // Note: For a key of type reference, the key parameter is expected
   //       to point to an SCMOInstance rather than just a string!!!
   CMPIrc scmoKey2CMPIData(const char* key, CIMKeyBinding::Type t, CMPIData *data)
 { {
     switch( pt )      data->state=CMPI_keyValue;
       switch( t )
     {     {
         case CMPI_null:          case CIMKeyBinding::NUMERIC:
             return(CIMType)0;              {
                   data->value.sint64 = 0;
         case CMPI_boolean:                  if( *(key)=='-' )
             return CIMTYPE_BOOLEAN;                  {
                       sscanf(key,
         case CMPI_char16:                             "%" PEGASUS_64BIT_CONVERSION_WIDTH "d",
             return CIMTYPE_CHAR16;                             &data->value.sint64);
                       data->type=CMPI_sint64;
         case CMPI_real32:                  }
             return CIMTYPE_REAL32;                  else
                   {
         case CMPI_real64:                      sscanf(key,
             return CIMTYPE_REAL64;                             "%" PEGASUS_64BIT_CONVERSION_WIDTH "u",
                              &data->value.uint64);
         case CMPI_uint8:                      data->type=CMPI_uint64;
             return CIMTYPE_UINT8;                  }
               }
         case CMPI_uint16:              break;
             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:          case CIMKeyBinding::STRING:
             return CIMTYPE_STRING;              data->value.string=string2CMPIString(key);
               data->type=CMPI_string;
               break;
  
         case CMPI_charsptr:          case CIMKeyBinding::BOOLEAN:
             return CIMTYPE_STRING;              data->value.boolean=(0==strcasecmp(key,"true"));
               data->type=CMPI_boolean;
               break;
  
         case CMPI_dateTime:          case CIMKeyBinding::REFERENCE:
             return CIMTYPE_DATETIME;              {
                   // TBD: Verify that the SCMOInstance.getKeyBinding really
                   //      returns references a pointer to SCMOInstance !!!
                   SCMOInstance* orgRef = (SCMOInstance*)key;
                   SCMOInstance* newRef = new SCMOInstance(orgRef->clone(true));
                   data->value.ref=
                       reinterpret_cast<CMPIObjectPath*>(new CMPI_Object(newRef));
                   data->type=CMPI_ref;
               }
               break;
  
         case CMPI_ref:  
             return CIMTYPE_REFERENCE;  
         case CMPI_instance:  
             return CIMTYPE_INSTANCE;  
         default:         default:
             return(CIMType)0;              return CMPI_RC_ERR_NOT_SUPPORTED;
     }     }
       return CMPI_RC_OK;
 } }
  
   
 //Function to convert CIMKeyBindings to CMPIData //Function to convert CIMKeyBindings to CMPIData
 CMPIrc key2CMPIData(const String& v, CIMKeyBinding::Type t, CMPIData *data) CMPIrc key2CMPIData(const String& v, CIMKeyBinding::Type t, CMPIData *data)
 { {

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