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