pegasus/src/Pegasus/ProviderManager2/CMPI/CMPI_Value.cpp - annotate

Return to CMPI_Value.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI

1 martin 1.33 //%LICENSE////////////////////////////////////////////////////////////////
2 martin 1.34 //
3 martin 1.33 // Licensed to The Open Group (TOG) under one or more contributor license 4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with 5 // this work for additional information regarding copyright ownership. 6 // Each contributor licenses this file to you under the OpenPegasus Open 7 // Source License; you may not use this file except in compliance with the 8 // License.
9 martin 1.34 //
10 martin 1.33 // Permission is hereby granted, free of charge, to any person obtaining a 11 // copy of this software and associated documentation files (the "Software"), 12 // to deal in the Software without restriction, including without limitation 13 // the rights to use, copy, modify, merge, publish, distribute, sublicense, 14 // and/or sell copies of the Software, and to permit persons to whom the 15 // Software is furnished to do so, subject to the following conditions:
16 martin 1.34 //
17 martin 1.33 // The above copyright notice and this permission notice shall be included 18 // in all copies or substantial portions of the Software.
19 martin 1.34 //
20 martin 1.33 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 martin 1.34 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 martin 1.33 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 martin 1.34 //
28 martin 1.33 //////////////////////////////////////////////////////////////////////////
29 schuur 1.1 // 30 //%///////////////////////////////////////////////////////////////////////////// 31
32 schuur 1.5 #include "CMPI_Version.h"
33 schuur 1.2
34 r.kieninger 1.35.4.11 #include <Pegasus/Common/Tracer.h>
35 schuur 1.1 #include "CMPI_String.h"
36 schuur 1.11 #include "CMPI_Value.h"
37 r.kieninger 1.35.4.3 #include "CMPISCMOUtilities.h"
38 schuur 1.1 39 PEGASUS_USING_STD; 40 PEGASUS_NAMESPACE_BEGIN 41
42 kavita.gupta 1.27 #define CopyToArray(pt,ct) \ 43 { \ 44 Array<pt> ar##pt(aSize); \ 45 for (int i=0; i<aSize; i++) \ 46 { \ 47 ar##pt[i]=aData[i].value.ct; \ 48 } \
49 venkat.puvvada 1.29 v.set(ar##pt); \
50 kavita.gupta 1.27 } 51 52 #define CopyToStringArray(pt,ct) \ 53 { \ 54 Array<pt> ar##pt(aSize); \ 55 for (int i=0; i<aSize; i++) \ 56 { \ 57 ar##pt[i]=String(((char*)aData[i].value.ct)); \ 58 } \
59 venkat.puvvada 1.29 v.set(ar##pt); \
60 kavita.gupta 1.27 } 61 62 #define CopyCharsptrToStringArray(pt,ct) \ 63 { \ 64 Array<pt> ar##pt(aSize); \ 65 for (int i=0; i<aSize; i++) \ 66 { \ 67 ar##pt[i]=String(((char*)aData[i].value.ct)); \ 68 }\
69 venkat.puvvada 1.29 v.set(ar##pt); \
70 kavita.gupta 1.27 } 71 72 #define CopyToEncArray(pt,ct) \ 73 { \ 74 Array<pt> ar##pt(aSize); \ 75 for (int i=0; i<aSize; i++) \ 76 { \ 77 ar##pt[i]=((pt)aData[i].value.ct->hdl); \
78 venkat.puvvada 1.29 } \ 79 v.set(ar##pt); \ 80 } 81 82 #define CopyFromArray(pt,ct) \ 83 { \ 84 Array<pt> ar##pt; \ 85 v.get(ar##pt); \ 86 for (int i=0; i<aSize; i++) \ 87 { \ 88 aData[i].value.ct=ar##pt[i]; \ 89 } \ 90 } 91 92 #define CopyFromStringArray(pt,ct) \ 93 { \ 94 Array<pt> ar##pt; \ 95 v.get(ar##pt); \ 96 for (int i=0; i<aSize; i++) \ 97 { \ 98 aData[i].value.ct=reinterpret_cast<CMPIString>(\ 99 venkat.puvvada 1.29 new CMPI_Object(ar##pt[i])); \ 100 } \ 101 } 102 103 #define CopyFromEncArray(pt,ct,cn) \ 104 { \ 105 Array<pt> ar##pt; \ 106 v.get(ar##pt); \ 107 for (int i=0; i<aSize; i++) \ 108 { \ 109 aData[i].value.cn=reinterpret_cast<ct>(\ 110 new CMPI_Object(new pt(ar##pt[i]))); \
111 kavita.gupta 1.27 } \ 112 } 113
114 venkat.puvvada 1.28 /**
115 r.kieninger 1.35.4.3 Function to convert CMPIValue to SCMBUnion 116 / 117 SCMBUnion value2SCMOValue(const CMPIValue data,const CMPIType type) 118 { 119 SCMBUnion scmoData; 120 121 if (!(type&CMPI_ARRAY)) 122 { 123 124 switch (type) 125 { 126 case CMPI_dateTime: 127 {
128 marek 1.35.4.8 CIMDateTimeRep * cimdt =
129 r.kieninger 1.35.4.3 CMPISCMOUtilities::scmoDateTimeFromCMPI(data->dateTime); 130 if (cimdt) 131 { 132 scmoData.dateTimeValue = cimdt; 133 } 134 break; 135 } 136 case CMPI_chars: 137 { 138 scmoData.extString.pchar = (char)data; 139 if (scmoData.extString.pchar) 140 {
141 marek 1.35.4.8 scmoData.extString.length =
142 r.kieninger 1.35.4.3 strlen(scmoData.extString.pchar); 143 } 144 break; 145 } 146 case CMPI_charsptr: 147 { 148 if (data && (char)data) 149 { 150 scmoData.extString.pchar = (char**)data;
151 marek 1.35.4.8 scmoData.extString.length =
152 r.kieninger 1.35.4.3 strlen(scmoData.extString.pchar); 153 } 154 break; 155 } 156 case CMPI_string: 157 {
158 r.kieninger 1.35.4.11 scmoData.extString.pchar = 0;
159 r.kieninger 1.35.4.10 if (data->string) 160 { 161 scmoData.extString.pchar = (char*)data->string->hdl; 162 }
163 r.kieninger 1.35.4.3 if (scmoData.extString.pchar) 164 {
165 marek 1.35.4.8 scmoData.extString.length =
166 r.kieninger 1.35.4.3 strlen(scmoData.extString.pchar); 167 } 168 break; 169 } 170 case CMPI_ref: 171 case CMPI_instance: 172 { 173 if (data->inst) 174 { 175 scmoData.extRefPtr = (SCMOInstance*)data->inst->hdl; 176 } 177 break; 178 }
179 r.kieninger 1.35.4.11 default: 180 scmoData.simple.val.u64 = data->uint64; 181 scmoData.simple.hasValue = 1; 182 break;
183 r.kieninger 1.35.4.3 } 184 } 185 else 186 {
187 r.kieninger 1.35.4.11 // This function does not convert array values, but only single 188 // value elements. 189 memset(&scmoData, sizeof(SCMBUnion), 0); 190 191 PEG_TRACE_CSTRING( 192 TRC_CMPIPROVIDERINTERFACE, 193 Tracer::LEVEL2, 194 "value2SCMOValue does not support array values!!!"); 195
196 r.kieninger 1.35.4.3 } 197 return scmoData; 198 } 199 200 201 /**
202 venkat.puvvada 1.28 Function to convert CMPIValue to CIMValue 203 */
204 kavita.gupta 1.27 CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc) 205 {
206 venkat.puvvada 1.28 CIMValue v; 207 if( rc )
208 kavita.gupta 1.27 { 209 *rc=CMPI_RC_OK; 210 }
211 schuur 1.1
212 venkat.puvvada 1.28 /** 213 check data for NULL if type is not CMPIArray. 214 / 215 if( !(type & CMPI_ARRAY) && !data ) 216 { 217 return CIMValue(type2CIMType(type), false); 218 } 219 /* 220 Case when type is CMPIArray 221 */ 222 if( type & CMPI_ARRAY )
223 kavita.gupta 1.27 { 224 //Return if data itself is NULL or Array is NULL
225 venkat.puvvada 1.28 if( data == NULL \|\| data->array == NULL )
226 kavita.gupta 1.27 {
227 venkat.puvvada 1.28 CMPIType aType=type&~CMPI_ARRAY; 228 return CIMValue(type2CIMType(aType),true); 229 }
230 kavita.gupta 1.27 // When data is not NULL and data->array is also set
231 venkat.puvvada 1.28 CMPIArray *ar=data->array;
232 thilo.boehm 1.35.4.1 CMPIData aData=(CMPIData)((CMPI_Array*)ar->hdl)->hdl;
233 kavita.gupta 1.27 234 //Get the type of the elements in the array
235 venkat.puvvada 1.28 CMPIType aType=aData->type&~CMPI_ARRAY;
236 kavita.gupta 1.27
237 venkat.puvvada 1.28 int aSize=aData->value.sint32; 238 aData++;
239 schuur 1.1
240 kavita.gupta 1.27 // Checks for Signed Integers
241 venkat.puvvada 1.28 if( (aType & (CMPI_UINT\|CMPI_SINT))==CMPI_SINT )
242 kavita.gupta 1.27 {
243 venkat.puvvada 1.28 switch( aType )
244 kavita.gupta 1.27 { 245 case CMPI_sint32: 246 CopyToArray(Sint32,sint32); 247 break; 248 249 case CMPI_sint16: 250 CopyToArray(Sint16,sint16); 251 break; 252 253 case CMPI_sint8: 254 CopyToArray(Sint8,sint8); 255 break; 256 257 case CMPI_sint64: 258 CopyToArray(Sint64,sint64); 259 break;
260 schuur 1.11
261 venkat.puvvada 1.28 default: ; 262 } 263 } 264 else 265 if( aType == CMPI_chars )
266 kavita.gupta 1.27 {
267 marek 1.31 CopyToStringArray(String,string->hdl)
268 kavita.gupta 1.27 }
269 kumpf 1.35 else
270 venkat.puvvada 1.28 if( aType == CMPI_charsptr )
271 kavita.gupta 1.27 { 272 CopyCharsptrToStringArray(String,chars) 273 }
274 kumpf 1.35 else
275 venkat.puvvada 1.28 if( aType == CMPI_string )
276 kavita.gupta 1.27 { 277 CopyToStringArray(String,string->hdl) 278 } 279 280 281 // Checks for Unsigned Integers
282 venkat.puvvada 1.28 else 283 if( (aType & (CMPI_UINT\|CMPI_SINT))==CMPI_UINT )
284 kavita.gupta 1.27 {
285 venkat.puvvada 1.28 switch( aType )
286 kavita.gupta 1.27 { 287 case CMPI_uint32: 288 CopyToArray(Uint32,uint32); 289 break; 290 case CMPI_uint16: 291 CopyToArray(Uint16,uint16); 292 break; 293 case CMPI_uint8: 294 CopyToArray(Uint8,uint8); 295 break; 296 case CMPI_uint64: 297 CopyToArray(Uint64,uint64); 298 break;
299 venkat.puvvada 1.28 default: ; 300 }
301 kavita.gupta 1.27 302
303 venkat.puvvada 1.28 }
304 kavita.gupta 1.27 else 305 {
306 venkat.puvvada 1.28 switch( aType )
307 kavita.gupta 1.27 { 308 case CMPI_ref:
309 r.kieninger 1.35.4.6 { 310 Array<CIMObjectPath> arCIMObjectPath(aSize); 311 for (int i=0; i<aSize; i++) 312 {
313 marek 1.35.4.8 SCMOInstance* scmoInst =
314 r.kieninger 1.35.4.6 (SCMOInstance*)aData[i].value.ref->hdl; 315 CIMObjectPath ref; 316 scmoInst->getCIMObjectPath(ref); 317 arCIMObjectPath[i]=ref; 318 } 319 v.set(arCIMObjectPath); 320 }
321 kavita.gupta 1.27 break; 322 323 case CMPI_dateTime: 324 CopyToEncArray(CIMDateTime,dateTime); 325 break; 326 case CMPI_instance:
327 marek 1.35.4.8 { 328 Array<CIMObject> arCIMInstance(aSize); 329 for (int i=0; i<aSize; i++)
330 r.kieninger 1.35.4.6 {
331 marek 1.35.4.8 SCMOInstance* scmoInst =
332 r.kieninger 1.35.4.6 (SCMOInstance*)aData[i].value.inst->hdl; 333 CIMInstance inst; 334 scmoInst->getCIMInstance(inst); 335 CIMObject obj(inst); 336 arCIMInstance[i]=obj; 337 } 338 v.set(arCIMInstance); 339 }
340 kavita.gupta 1.27 break; 341 case CMPI_boolean: 342 CopyToArray(Boolean,boolean); 343 break; 344 345 case CMPI_char16: 346 CopyToArray(Char16,char16); 347 break; 348 349 case CMPI_real32: 350 CopyToArray(Real32,real32); 351 break; 352 353 case CMPI_real64: 354 CopyToArray(Real64,real64); 355 break; 356
357 venkat.puvvada 1.28 default: 358 if( rc )
359 kavita.gupta 1.27 { 360 *rc=CMPI_RC_ERR_NOT_SUPPORTED; 361 } 362 }
363 venkat.puvvada 1.28 } 364 return CIMValue(v); 365 } // end of array processing
366 kavita.gupta 1.27 //Start of non - array types processing
367 venkat.puvvada 1.28 else 368 if( type == CMPI_chars )
369 kavita.gupta 1.27 { 370 v.set(String((char*)data));
371 venkat.puvvada 1.28 } 372 else 373 if( type == CMPI_charsptr )
374 kavita.gupta 1.27 {
375 venkat.puvvada 1.28 if( data && (char*)data )
376 kavita.gupta 1.27 { 377 v.set(String((char*)data)); 378 } 379 else 380 {
381 schuur 1.11 return CIMValue(CIMTYPE_STRING,false);
382 venkat.puvvada 1.28 }
383 kavita.gupta 1.27 }
384 schuur 1.11
385 kavita.gupta 1.27 //Checks for Signed integers
386 venkat.puvvada 1.28 else 387 if( (type & (CMPI_UINT\|CMPI_SINT))==CMPI_SINT )
388 kavita.gupta 1.27 {
389 venkat.puvvada 1.28 switch( type )
390 kavita.gupta 1.27 { 391 case CMPI_sint32: 392 v.set((Sint32)data->sint32); 393 break; 394 395 case CMPI_sint16: 396 v.set((Sint16)data->sint16); 397 break; 398 399 case CMPI_sint8: 400 v.set((Sint8)data->sint8); 401 break; 402 403 case CMPI_sint64: 404 v.set((Sint64)data->sint64); 405 break;
406 venkat.puvvada 1.28 default: ; 407 } 408 } 409 else 410 if( type == CMPI_string )
411 kavita.gupta 1.27 {
412 venkat.puvvada 1.28 if( data->string && data->string->hdl )
413 kavita.gupta 1.27 { 414 v.set(String((char*)data->string->hdl)); 415 } 416 else 417 { 418 return CIMValue(CIMTYPE_STRING,false); 419 } 420 }
421 schuur 1.1
422 kavita.gupta 1.27 //Checks for Unsigned Integers
423 venkat.puvvada 1.28 else 424 if( (type & (CMPI_UINT\|CMPI_SINT))==CMPI_UINT )
425 kavita.gupta 1.27 {
426 venkat.puvvada 1.28 switch( type )
427 kavita.gupta 1.27 { 428 case CMPI_uint32: 429 v.set((Uint32)data->uint32); 430 break; 431 432 case CMPI_uint16: 433 v.set((Uint16)data->uint16); 434 break; 435 436 case CMPI_uint8: 437 v.set((Uint8)data->uint8); 438 break; 439 440 case CMPI_uint64: 441 v.set((Uint64)data->uint64); 442 break;
443 schuur 1.1
444 venkat.puvvada 1.28 default: ; 445 } 446 }
447 kavita.gupta 1.27 448 //Checks for remaining Encapsulated and non-encapsulated types
449 venkat.puvvada 1.28 else 450 switch( type ) 451 { 452 case CMPI_instance: 453 if( data->inst && data->inst->hdl ) 454 {
455 r.kieninger 1.35.4.4 SCMOInstance* scmoInst = (SCMOInstance*)data->inst->hdl; 456 CIMInstance inst; 457 scmoInst->getCIMInstance(inst);
458 r.kieninger 1.35.4.6 CIMObject obj(inst); 459 v.set(obj);
460 venkat.puvvada 1.28 } 461 else 462 { 463 return CIMValue(CIMTYPE_OBJECT, false);
464 kumpf 1.35 }
465 venkat.puvvada 1.28 break; 466
467 kumpf 1.35 case CMPI_ref:
468 venkat.puvvada 1.28 if( data->ref && data->ref->hdl ) 469 {
470 r.kieninger 1.35.4.4 SCMOInstance* scmoInst = (SCMOInstance*)data->ref->hdl; 471 CIMObjectPath ref; 472 scmoInst->getCIMObjectPath(ref); 473 v.set(ref);
474 venkat.puvvada 1.28 } 475 else 476 { 477 return CIMValue(CIMTYPE_REFERENCE, false); 478 } 479 break;
480 kumpf 1.35 case CMPI_dateTime:
481 venkat.puvvada 1.28 if( data->dateTime && data->dateTime->hdl ) 482 {
483 kumpf 1.35 v.set(((CIMDateTime)data->dateTime->hdl));
484 venkat.puvvada 1.28 } 485 else 486 { 487 return CIMValue(CIMTYPE_DATETIME, false); 488 } 489 break;
490 kavita.gupta 1.27
491 venkat.puvvada 1.28 case CMPI_boolean: 492 v.set((Boolean&)data->boolean); 493 break;
494 kavita.gupta 1.27
495 venkat.puvvada 1.28 case CMPI_char16: 496 v.set((Char16)data->char16); 497 break;
498 kavita.gupta 1.27
499 venkat.puvvada 1.28 case CMPI_real32: 500 v.set((Real32)data->real32); 501 break;
502 kavita.gupta 1.27
503 venkat.puvvada 1.28 case CMPI_real64: 504 v.set((Real64)data->real64); 505 break;
506 kavita.gupta 1.27
507 venkat.puvvada 1.28 default: 508 if( rc ) 509 { 510 *rc=CMPI_RC_ERR_NOT_SUPPORTED; 511 } 512 } 513 return CIMValue(v);
514 schuur 1.1 } 515
516 kavita.gupta 1.27 //Function to convert CIMValue to CMPIData 517 CMPIrc value2CMPIData(const CIMValue& v, CMPIType t, CMPIData *data) 518 { 519 //Initialize CMPIData object
520 venkat.puvvada 1.28 data->type=t; 521 data->state=0; 522 data->value.uint64=0;
523 schuur 1.11
524 kavita.gupta 1.27 //Check for NULL CIMValue
525 venkat.puvvada 1.28 if( v.isNull() )
526 kavita.gupta 1.27 {
527 venkat.puvvada 1.28 data->state=CMPI_nullValue; 528 return CMPI_RC_OK; 529 }
530 schuur 1.1
531 kavita.gupta 1.27 //Start of CMPIArray processing
532 venkat.puvvada 1.28 if( t & CMPI_ARRAY )
533 kavita.gupta 1.27 { 534 //Get the size of the array
535 venkat.puvvada 1.28 int aSize=v.getArraySize();
536 kavita.gupta 1.27 537 //Get the type of the element of the CMPIArray
538 venkat.puvvada 1.28 CMPIType aType=t&~CMPI_ARRAY; 539 CMPIData *aData=new CMPIData[aSize+1]; 540 aData->type=aType; 541 aData->value.sint32=aSize;
542 schuur 1.11
543 kavita.gupta 1.27 //Set the type and state for all array elements
544 venkat.puvvada 1.28 for( int i=1; i<aSize+1; i++ )
545 kavita.gupta 1.27 {
546 venkat.puvvada 1.28 aData[i].type=aType; 547 aData[i].state=0; 548 } 549 aData++;
550 schuur 1.1
551 kavita.gupta 1.27 //Check for Signed Integers
552 venkat.puvvada 1.28 if( (aType & (CMPI_UINT\|CMPI_SINT))==CMPI_SINT )
553 kavita.gupta 1.27 {
554 venkat.puvvada 1.28 switch( aType )
555 kavita.gupta 1.27 { 556 case CMPI_sint32: 557 CopyFromArray(Sint32,sint32); 558 break; 559 560 case CMPI_sint16: 561 CopyFromArray(Sint16,sint16); 562 break; 563 564 case CMPI_sint8: 565 CopyFromArray(Sint8,sint8); 566 break; 567 568 case CMPI_sint64: 569 CopyFromArray(Sint64,sint64); 570 break; 571
572 venkat.puvvada 1.28 default: ; 573 } 574 }
575 kavita.gupta 1.27 //Check for CMPI_string data type
576 venkat.puvvada 1.28 else 577 if( aType == CMPI_string )
578 kavita.gupta 1.27 { 579 CopyFromStringArray(String,string) 580 } 581 582 // Check for Unsigned Integers
583 venkat.puvvada 1.28 else 584 if( (aType & (CMPI_UINT\|CMPI_SINT))==CMPI_UINT )
585 kavita.gupta 1.27 {
586 venkat.puvvada 1.28 switch( aType )
587 kavita.gupta 1.27 { 588 case CMPI_uint32: 589 CopyFromArray(Uint32,uint32); 590 break; 591 592 case CMPI_uint16: 593 CopyFromArray(Uint16,uint16); 594 break; 595 596 case CMPI_uint8: 597 CopyFromArray(Uint8,uint8); 598 break; 599 600 case CMPI_uint64: 601 CopyFromArray(Uint64,uint64); 602 break; 603
604 venkat.puvvada 1.28 default: ; 605 } 606 } 607 else 608 switch( aType ) 609 { 610 case CMPI_ref:
611 marek 1.35.4.8 { 612 Array<CIMObjectPath> arRef; 613 v.get(arRef); 614 for (int i=0; i<aSize; i++) 615 { 616 SCMOInstance* scmoRef =
617 r.kieninger 1.35.4.5 CMPISCMOUtilities::
618 marek 1.35.4.8 getSCMOFromCIMObjectPath(arRef[i]);
619 r.kieninger 1.35.4.5 aData[i].value.ref= 620 reinterpret_cast<CMPIObjectPath*>(
621 r.kieninger 1.35.4.7 new CMPI_Object( 622 scmoRef,
623 marek 1.35.4.8 CMPI_Object::ObjectTypeObjectPath)); 624 }
625 r.kieninger 1.35.4.5 }
626 venkat.puvvada 1.28 break;
627 kavita.gupta 1.27
628 venkat.puvvada 1.28 case CMPI_dateTime: 629 CopyFromEncArray(CIMDateTime,CMPIDateTime,dateTime); 630 break;
631 r.kieninger 1.35.4.5
632 venkat.puvvada 1.28 case CMPI_instance:
633 venkat.puvvada 1.30 if (v.getType() == CIMTYPE_OBJECT) 634 { 635 Array<CIMObject> tmpObjs; 636 v.get(tmpObjs); 637 for (int i = 0; i < aSize ; ++i) 638 {
639 r.kieninger 1.35.4.5 CIMInstance inst = CIMInstance(tmpObjs[i]);
640 marek 1.35.4.8 SCMOInstance* scmoInst =
641 r.kieninger 1.35.4.5 CMPISCMOUtilities::getSCMOFromCIMInstance(inst);
642 marek 1.35.4.8 aData[i].value.inst =
643 r.kieninger 1.35.4.5 reinterpret_cast<CMPIInstance*>(
644 r.kieninger 1.35.4.7 new CMPI_Object( 645 scmoInst, 646 CMPI_Object::ObjectTypeInstance));
647 kumpf 1.35 }
648 venkat.puvvada 1.30 } 649 else 650 {
651 r.kieninger 1.35.4.5 Array<CIMInstance> arInst; 652 v.get(arInst); 653 for (int i = 0; i < aSize ; ++i) 654 {
655 marek 1.35.4.8 SCMOInstance* scmoInst =
656 r.kieninger 1.35.4.5 CMPISCMOUtilities:: 657 getSCMOFromCIMInstance(arInst[i]);
658 marek 1.35.4.8 aData[i].value.inst =
659 r.kieninger 1.35.4.7 reinterpret_cast<CMPIInstance*> 660 (new CMPI_Object(
661 marek 1.35.4.8 scmoInst,
662 r.kieninger 1.35.4.7 CMPI_Object::ObjectTypeInstance));
663 r.kieninger 1.35.4.5 }
664 venkat.puvvada 1.30 }
665 venkat.puvvada 1.28 break; 666 case CMPI_boolean: 667 CopyFromArray(Boolean,boolean); 668 break;
669 kavita.gupta 1.27
670 venkat.puvvada 1.28 case CMPI_char16: 671 CopyFromArray(Char16,char16); 672 break;
673 kavita.gupta 1.27
674 venkat.puvvada 1.28 case CMPI_real32: 675 CopyFromArray(Real32,real32); 676 break;
677 kavita.gupta 1.27
678 venkat.puvvada 1.28 case CMPI_real64: 679 CopyFromArray(Real64,real64); 680 break;
681 kavita.gupta 1.27
682 venkat.puvvada 1.28 default: 683 // Not supported for this CMPItype 684 delete [] aData; 685 return CMPI_RC_ERR_NOT_SUPPORTED; 686 }
687 kavita.gupta 1.27 data->value.array = reinterpret_cast<CMPIArray*>(
688 thilo.boehm 1.35.4.1 new CMPI_Object(new CMPI_Array(aData-1)));
689 venkat.puvvada 1.28 } // end of array porocessing
690 schuur 1.1
691 kavita.gupta 1.27 //Start of non-array processing 692 //Ckecking for Signed integers
693 kumpf 1.35 else
694 venkat.puvvada 1.28 if( (t & (CMPI_UINT\|CMPI_SINT)) == CMPI_SINT )
695 kavita.gupta 1.27 {
696 venkat.puvvada 1.28 switch( t )
697 kavita.gupta 1.27 { 698 case CMPI_sint32: 699 v.get((Sint32&)data->value.sint32); 700 break; 701 702 case CMPI_sint16: 703 v.get((Sint16&)data->value.sint16); 704 break; 705 706 case CMPI_sint8: 707 v.get((Sint8&)data->value.sint8); 708 break; 709 710 case CMPI_sint64: 711 v.get((Sint64&)data->value.sint64); 712 break; 713
714 venkat.puvvada 1.28 default: ; 715 } 716 }
717 schuur 1.1
718 kavita.gupta 1.27 //Check for CMPI_string data type
719 kumpf 1.35 else
720 venkat.puvvada 1.28 if( t == CMPI_string )
721 kavita.gupta 1.27 {
722 venkat.puvvada 1.28 String str; 723 v.get(str); 724 data->value.string=string2CMPIString(str); 725 }
726 schuur 1.1
727 kavita.gupta 1.27 //Check for Unsigned Integers
728 venkat.puvvada 1.28 else 729 if( (t & (CMPI_UINT\|CMPI_SINT)) == CMPI_UINT )
730 kavita.gupta 1.27 {
731 venkat.puvvada 1.28 switch( t )
732 kavita.gupta 1.27 { 733 case CMPI_uint32: 734 v.get((Uint32&)data->value.uint32); 735 break; 736 737 case CMPI_uint16: 738 v.get((Uint16&)data->value.uint16); 739 break; 740 741 case CMPI_uint8: 742 v.get((Uint8&)data->value.uint8); 743 break; 744 745 case CMPI_uint64: 746 v.get((Uint64&)data->value.uint64); 747 break; 748
749 venkat.puvvada 1.28 default: ; 750 } 751 }
752 schuur 1.1
753 r.kieninger 1.35.4.4 //Checking for remaining encapsulated and simple types
754 venkat.puvvada 1.28 else 755 switch( t )
756 kavita.gupta 1.27 {
757 venkat.puvvada 1.28 case CMPI_ref: 758 { 759 CIMObjectPath ref; 760 v.get(ref);
761 marek 1.35.4.8 SCMOInstance* scmoRef =
762 r.kieninger 1.35.4.4 CMPISCMOUtilities:: getSCMOFromCIMObjectPath(ref);
763 venkat.puvvada 1.28 data->value.ref = reinterpret_cast<CMPIObjectPath*>(
764 r.kieninger 1.35.4.7 new CMPI_Object(scmoRef,CMPI_Object::ObjectTypeObjectPath));
765 venkat.puvvada 1.28 } 766 break;
767 kavita.gupta 1.27
768 venkat.puvvada 1.28 case CMPI_instance: 769 { 770 CIMInstance inst; 771 if( v.getType() == CIMTYPE_OBJECT ) 772 { 773 CIMObject tmpObj; 774 v.get(tmpObj); 775 inst = CIMInstance(tmpObj); 776 } 777 else 778 { 779 v.get(inst); 780 }
781 marek 1.35.4.8 SCMOInstance* scmoInst =
782 r.kieninger 1.35.4.4 CMPISCMOUtilities::getSCMOFromCIMInstance(inst);
783 venkat.puvvada 1.28 data->value.inst = reinterpret_cast<CMPIInstance*>(
784 r.kieninger 1.35.4.7 new CMPI_Object(scmoInst, CMPI_Object::ObjectTypeInstance));
785 venkat.puvvada 1.28 } 786 break;
787 kavita.gupta 1.27
788 venkat.puvvada 1.28 case CMPI_dateTime: 789 { 790 CIMDateTime dt; 791 v.get(dt); 792 data->value.dateTime = reinterpret_cast<CMPIDateTime*>( 793 new CMPI_Object(new CIMDateTime(dt))); 794 } 795 break;
796 kavita.gupta 1.27
797 venkat.puvvada 1.28 case CMPI_boolean: 798 v.get((Boolean&)data->value.boolean); 799 break;
800 kavita.gupta 1.27
801 venkat.puvvada 1.28 case CMPI_char16: 802 v.get((Char16&)data->value.char16); 803 break;
804 kavita.gupta 1.27
805 venkat.puvvada 1.28 case CMPI_real32: 806 v.get((Real32&)data->value.real32); 807 break;
808 kavita.gupta 1.27
809 venkat.puvvada 1.28 case CMPI_real64: 810 v.get((Real64&)data->value.real64); 811 break;
812 kavita.gupta 1.27
813 venkat.puvvada 1.28 default: 814 return CMPI_RC_ERR_NOT_SUPPORTED; 815 } 816 return CMPI_RC_OK;
817 schuur 1.1 } 818
819 kavita.gupta 1.27 //Function to convert CIMType to CMPIType 820 CMPIType type2CMPIType(CIMType pt, int array) 821 { 822 static CMPIType types[] = 823 {
824 schuur 1.1 CMPI_boolean, // BOOLEAN, 825 CMPI_uint8, // UINT8, 826 CMPI_sint8, // SINT8, 827 CMPI_uint16, // UINT16, 828 CMPI_sint16, // SINT16, 829 CMPI_uint32, // UINT32, 830 CMPI_sint32, // SINT32, 831 CMPI_uint64, // UINT64, 832 CMPI_sint64, // SINT64, 833 CMPI_real32, // REAL32, 834 CMPI_real64, // REAL64, 835 CMPI_char16, // CHAR16, 836 CMPI_string, // STRING, 837 CMPI_dateTime, // DATETIME, 838 CMPI_ref, // REFERENCE
839 s.kodali 1.32 CMPI_instance, // Embedded Object 840 CMPI_instance // Embedded Instance
841 schuur 1.1 }; 842 int t=types[pt];
843 venkat.puvvada 1.28 if( array )
844 kavita.gupta 1.27 { 845 t\|=CMPI_ARRAY; 846 }
847 venkat.puvvada 1.28 return(CMPIType)t;
848 schuur 1.1 } 849 850 PEGASUS_NAMESPACE_END 851

No CVS admin address has been configured