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

version 1.35, 2008/12/16 18:56:55 version 1.35.4.15, 2009/11/12 15:14:49
Line 31 
Line 31 
  
 #include "CMPI_Version.h" #include "CMPI_Version.h"
  
   #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Common/ArrayIterator.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 113 
     }     }
  
 /** /**
     Function to convert CMPIValue to SCMBUnion
   */
   SCMBUnion value2SCMOValue(const CMPIValue* data,const CMPIType type)
   {
       SCMBUnion scmoData;
   
       PEGASUS_ASSERT(!(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;
           }
           case CMPI_boolean:
           {
               scmoData.simple.val.u64 = data->boolean;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_uint8:
           {
               scmoData.simple.val.u64 = data->uint8;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_uint16:
           {
               scmoData.simple.val.u64 = data->uint16;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_uint32:
           {
               scmoData.simple.val.u64 = data->uint32;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_uint64:
           {
               scmoData.simple.val.u64 = data->uint64;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_sint8:
           {
               scmoData.simple.val.s64 = data->sint8;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_sint16:
           {
               scmoData.simple.val.s64 = data->sint16;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_sint32:
           {
               scmoData.simple.val.s64 = data->sint32;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_sint64:
           {
               scmoData.simple.val.s64 = data->sint64;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_real32:
           {
               scmoData.simple.val.r32 = data->real32;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_real64:
           {
               scmoData.simple.val.r64 = data->real64;
               scmoData.simple.hasValue = 1;
               break;
           }
           case CMPI_char16:
           {
               scmoData.simple.val.u64 = data->char16;
               scmoData.simple.hasValue = 1;
               break;
           }
           default:
           {
               // received a non-valid CMPIType as input
               // place a trace message and do nothing
               PEG_TRACE((TRC_CMPIPROVIDERINTERFACE,Tracer::LEVEL1,
                   "value2SCMOValue() received invalid CMPIType(%hu).",type));
               fprintf(stderr,"value2SCMOValue() received type=%hu\n",type);
               fflush(stderr);
               PEGASUS_DEBUG_ASSERT(false);
           }
       }
       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 294 
         }         }
         // 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 371 
             switch( aType )             switch( aType )
             {             {
                 case CMPI_ref:                 case CMPI_ref:
                     CopyToEncArray(CIMObjectPath,ref);                      {
                           Array<CIMObjectPath> arCIMObjectPath(aSize);
                           ArrayIterator<CIMObjectPath> iterator(arCIMObjectPath);
                           for (int i=0; i<aSize; i++)
                           {
                               SCMOInstance* scmoInst =
                                   (SCMOInstance*)aData[i].value.ref->hdl;
                               scmoInst->getCIMObjectPath(iterator[i]);
                           }
                           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);
                           ArrayIterator<CIMObject> iterator(arCIMInstance);
                           for (int i=0; i<aSize; i++)
                           {
                               SCMOInstance* scmoInst =
                                   (SCMOInstance*)aData[i].value.inst->hdl;
                               CIMInstance inst;
                               scmoInst->getCIMInstance(inst);
                               CIMObject obj(inst);
                               iterator[i]=obj;
                           }
                           v.set(arCIMInstance);
                       }
                     break;                     break;
                 case CMPI_boolean:                 case CMPI_boolean:
                     CopyToArray(Boolean,boolean);                     CopyToArray(Boolean,boolean);
Line 340 
Line 517 
             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 532 
             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 370 
Line 554 
                 break;                 break;
  
             case CMPI_boolean:             case CMPI_boolean:
                 v.set((Boolean&)data->boolean);                  {
                       Boolean tmp=data->boolean;
                       v.set(tmp);
                 break;                 break;
                   }
  
             case CMPI_char16:             case CMPI_char16:
                 v.set((Char16)data->char16);                 v.set((Char16)data->char16);
Line 486 
Line 673 
             }             }
         }         }
         else         else
           {
             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 705 
                         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 532 
Line 753 
                     delete [] aData;                     delete [] aData;
                     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 820 
         }         }
     }     }
  
     //Checking for remaining encapulated and simple types      //Checking for remaining encapsulated and simple types
     else     else
         switch( t )         switch( t )
         {         {
Line 606 
Line 828 
                 {                 {
                     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 848 
                     {                     {
                         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 640 
Line 865 
                 break;                 break;
  
             case CMPI_boolean:             case CMPI_boolean:
                 v.get((Boolean&)data->value.boolean);              {
                   Boolean tmp=0;
                   v.get(tmp);
                   data->value.boolean = (CMPIBoolean)(tmp);
                 break;                 break;
               }
  
             case CMPI_char16:             case CMPI_char16:
                 v.get((Char16&)data->value.char16);                 v.get((Char16&)data->value.char16);
Line 692 
Line 921 
     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.15
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2