1 karl 1.19 //%2006////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.14 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.14 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.15 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.19 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 schuur 1.1 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
|
20 r.kieninger 1.21 //
|
21 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
|
34 schuur 1.5 #include "CMPI_Version.h"
|
35 schuur 1.2
|
36 schuur 1.1 #include "CMPI_String.h"
|
37 schuur 1.11 #include "CMPI_Value.h"
|
38 schuur 1.1
39 PEGASUS_USING_STD;
40 PEGASUS_NAMESPACE_BEGIN
41
42 #define CopyToArray(pt,ct) { Array<pt> ar##pt(aSize); \
43 for (int i=0; i<aSize; i++) ar##pt[i]=aData[i].value.ct; \
44 v.set(ar##pt); }
45
46 #define CopyToStringArray(pt,ct) { Array<pt> ar##pt(aSize); \
47 for (int i=0; i<aSize; i++) ar##pt[i]=String(((char*)aData[i].value.ct)); \
48 v.set(ar##pt); }
49
|
50 schuur 1.12 #define CopyCharsptrToStringArray(pt,ct) { Array<pt> ar##pt(aSize); \
51 for (int i=0; i<aSize; i++) ar##pt[i]=String((*(char**)aData[i].value.ct)); \
52 v.set(ar##pt); }
53
|
54 schuur 1.1 #define CopyToEncArray(pt,ct) { Array<pt> ar##pt(aSize); \
55 for (int i=0; i<aSize; i++) ar##pt[i]=*((pt*)aData[i].value.ct->hdl); \
56 v.set(ar##pt); }
57
|
58 konrad.r 1.17 CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc) {
|
59 schuur 1.1 CIMValue v;
60 if (rc) *rc=CMPI_RC_OK;
61
|
62 venkat.puvvada 1.26 // check data for NULL if type is not CMPIArray.
63 if ( !(type & CMPI_ARRAY) && !data)
64 {
65 return CIMValue(type2CIMType(type), false);
66 }
|
67 schuur 1.1 if (type & CMPI_ARRAY) {
|
68 schuur 1.11
69 if (data==NULL || data->array==NULL) {
70 CMPIType aType=type&~CMPI_ARRAY;
71 return CIMValue(type2CIMType(aType),true);
72 }
73
|
74 schuur 1.1 CMPIArray *ar=data->array;
75 CMPIData *aData=(CMPIData*)ar->hdl;
76 CMPIType aType=aData->type&~CMPI_ARRAY;
77 int aSize=aData->value.sint32;
78 aData++;
79
|
80 schuur 1.11 if (aType & CMPI_ENC && (data==NULL || data->array==NULL)) {
81 if (aType==CMPI_chars || aType==CMPI_string)
82 return CIMValue(CIMTYPE_STRING,true);
83 if (aType==CMPI_dateTime)
84 return CIMValue(CIMTYPE_DATETIME,true);
85 if (aType==CMPI_ref)
86 return CIMValue(CIMTYPE_REFERENCE,true);
87 }
88
|
89 schuur 1.1 if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
90 switch (aType) {
91 case CMPI_sint32: CopyToArray(Sint32,sint32); break;
92 case CMPI_sint16: CopyToArray(Sint16,sint16); break;
93 case CMPI_sint8: CopyToArray(Sint8,sint8); break;
94 case CMPI_sint64: CopyToArray(Sint64,sint64); break;
95 default: ;
96 }
97 }
98
|
99 schuur 1.12 else if (aType==CMPI_chars) CopyToStringArray(String,chars)
100 else if (aType==CMPI_charsptr) CopyCharsptrToStringArray(String,chars)
101 else if (aType==CMPI_string) CopyToStringArray(String,string->hdl)
|
102 schuur 1.1
103 else if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
104 switch (aType) {
105 case CMPI_uint32: CopyToArray(Uint32,uint32); break;
106 case CMPI_uint16: CopyToArray(Uint16,uint16); break;
107 case CMPI_uint8: CopyToArray(Uint8,uint8); break;
108 case CMPI_uint64: CopyToArray(Uint64,uint64); break;
109 default: ;
110 }
111 }
112
113 else switch (aType) {
114 case CMPI_ref: CopyToEncArray(CIMObjectPath,ref); break;
115 case CMPI_dateTime: CopyToEncArray(CIMDateTime,dateTime); break;
|
116 marek 1.24 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
117 case CMPI_instance: CopyToEncArray(CIMInstance,inst); break;
118 #endif
|
119 schuur 1.1 case CMPI_boolean: CopyToArray(Boolean,boolean); break;
120 case CMPI_char16: CopyToArray(Char16,char16); break;
121 case CMPI_real32: CopyToArray(Real32,real32); break;
122 case CMPI_real64: CopyToArray(Real64,real64); break;
123 default:
124 if (rc) *rc=CMPI_RC_ERR_NOT_SUPPORTED;
125 }
126 return CIMValue(v);
127 } // end of array processing
128
|
129 schuur 1.11
130
131 else if (type==CMPI_chars) {
132 if (data) v.set(String((char*)data));
133 else return CIMValue(CIMTYPE_STRING,false);
134 }
|
135 schuur 1.12 else if (type==CMPI_charsptr) {
136 if (data && *(char**)data) v.set(String(*(char**)data));
137 else return CIMValue(CIMTYPE_STRING,false);
138 }
|
139 schuur 1.11
140 else if (type & CMPI_ENC &&
141 (data==NULL || data->string==NULL || data->string->hdl==NULL)) {
142 if (type==CMPI_string)
143 return CIMValue(CIMTYPE_STRING,false);
144 if (type==CMPI_dateTime)
145 return CIMValue(CIMTYPE_DATETIME,false);
146 if (type==CMPI_ref)
147 return CIMValue(CIMTYPE_REFERENCE,false);
148 }
149
|
150 schuur 1.1 else if ((type & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
151 switch (type) {
152 case CMPI_sint32: v.set((Sint32)data->sint32); break;
153 case CMPI_sint16: v.set((Sint16)data->sint16); break;
154 case CMPI_sint8: v.set((Sint8)data->sint8); break;
155 case CMPI_sint64: v.set((Sint64)data->sint64); break;
156 default: ;
157 }
158 }
159
|
160 venkat.puvvada 1.26 else if (type==CMPI_string) v.set( data->string && data->string->hdl ?
|
161 schuur 1.6 String((char*)data->string->hdl) : String::EMPTY);
|
162 schuur 1.1
163 else if ((type & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
164 switch (type) {
|
165 kumpf 1.18 case CMPI_uint32: v.set((Uint32)data->uint32); break;
166 case CMPI_uint16: v.set((Uint16)data->uint16); break;
167 case CMPI_uint8: v.set((Uint8)data->uint8); break;
168 case CMPI_uint64: v.set((Uint64)data->uint64); break;
|
169 schuur 1.1 default: ;
170 }
171 }
|
172 r.kieninger 1.21 else if (type ==CMPI_instance)
|
173 konrad.r 1.16 {
|
174 venkat.puvvada 1.26 if (data->inst && data->inst->hdl)
175 {
|
176 a.dunfey 1.20 v.set(*((CIMObject*) data->inst->hdl));
|
177 konrad.r 1.16 }
|
178 venkat.puvvada 1.26 else
179 {
180 return CIMValue(CIMTYPE_OBJECT, false);
181 }
182 }
|
183 schuur 1.1 else switch (type) {
|
184 venkat.puvvada 1.26 case CMPI_ref:
185 if (data->ref && data->ref->hdl)
186 {
187 v.set(*((CIMObjectPath*)data->ref->hdl));
188 }
189 else
190 {
191 return CIMValue(CIMTYPE_REFERENCE, false);
192 }
193 break;
194 case CMPI_dateTime:
195 if (data->dateTime && data->dateTime->hdl)
196 {
197 v.set(*((CIMDateTime*)data->dateTime->hdl));
198 }
199 else
200 {
201 return CIMValue(CIMTYPE_DATETIME, false);
202 }
203 break;
|
204 schuur 1.1 case CMPI_boolean: v.set((Boolean&)data->boolean); break;
205 case CMPI_char16: v.set((Char16)data->char16); break;
206 case CMPI_real32: v.set((Real32)data->real32); break;
207 case CMPI_real64: v.set((Real64)data->real64); break;
208 default:
209 if (rc) *rc=CMPI_RC_ERR_NOT_SUPPORTED;
210 }
211 return CIMValue(v);
212 }
213
214
215
216 #define CopyFromArray(pt,ct) { Array<pt> ar##pt; \
217 v.get(ar##pt); \
218 for (int i=0; i<aSize; i++) aData[i].value.ct=ar##pt[i]; }
219
220 #define CopyFromStringArray(pt,ct) { Array<pt> ar##pt; \
221 v.get(ar##pt); \
222 for (int i=0; i<aSize; i++) { \
|
223 mreddy 1.22 aData[i].value.ct=reinterpret_cast<CMPIString*>(new CMPI_Object(ar##pt[i])); } }
|
224 schuur 1.1
225 #define CopyFromEncArray(pt,ct,cn) { Array<pt> ar##pt; \
226 v.get(ar##pt); \
227 for (int i=0; i<aSize; i++) { \
|
228 mreddy 1.22 aData[i].value.cn=reinterpret_cast<ct*>(new CMPI_Object(new pt(ar##pt[i]))); } }
|
229 schuur 1.1
230
231 CMPIrc value2CMPIData(const CIMValue& v, CMPIType t, CMPIData *data) {
232
233 data->type=t;
|
234 schuur 1.11 data->state=0;
235 data->value.uint64=0;
236
237 if (v.isNull()) {
238 data->state=CMPI_nullValue;
239 return CMPI_RC_OK;
240 }
|
241 schuur 1.1
242 if (t & CMPI_ARRAY) {
243 int aSize=v.getArraySize();
244 CMPIType aType=t&~CMPI_ARRAY;
245 CMPIData *aData=new CMPIData[aSize+1];
246 aData->type=aType;
247 aData->value.sint32=aSize;
|
248 schuur 1.11
249 for (int i=1; i<aSize+1; i++) {
250 aData[i].type=aType;
251 aData[i].state=0;
252 }
|
253 schuur 1.1 aData++;
254
|
255 schuur 1.11 if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
|
256 schuur 1.1 switch (aType) {
257 case CMPI_sint32: CopyFromArray(Sint32,sint32); break;
258 case CMPI_sint16: CopyFromArray(Sint16,sint16); break;
259 case CMPI_sint8: CopyFromArray(Sint8,sint8); break;
260 case CMPI_sint64: CopyFromArray(Sint64,sint64); break;
261 default: ;
262 }
263 }
264 else if (aType==CMPI_string) CopyFromStringArray(String,string)
|
265 schuur 1.11 else if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
|
266 schuur 1.1 switch (aType) {
267 case CMPI_uint32: CopyFromArray(Uint32,uint32); break;
268 case CMPI_uint16: CopyFromArray(Uint16,uint16); break;
269 case CMPI_uint8: CopyFromArray(Uint8,uint8); break;
270 case CMPI_uint64: CopyFromArray(Uint64,uint64); break;
271 default: ;
272 }
273 }
274 else switch (aType) {
275 case CMPI_ref: CopyFromEncArray(CIMObjectPath,CMPIObjectPath,ref); break;
276 case CMPI_dateTime: CopyFromEncArray(CIMDateTime,CMPIDateTime,dateTime); break;
|
277 marek 1.24 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
278 case CMPI_instance: CopyFromEncArray(CIMInstance,CMPIInstance,inst); break;
279 #endif
|
280 schuur 1.1 case CMPI_boolean: CopyFromArray(Boolean,boolean); break;
281 case CMPI_char16: CopyFromArray(Char16,char16); break;
282 case CMPI_real32: CopyFromArray(Real32,real32); break;
283 case CMPI_real64: CopyFromArray(Real64,real64); break;
284 default:
|
285 venkat.puvvada 1.25 // Not supported for this CMPItype
286 delete [] aData;
287 return CMPI_RC_ERR_NOT_SUPPORTED;
|
288 schuur 1.1 }
|
289 mreddy 1.22 data->value.array=reinterpret_cast<CMPIArray*>(new CMPI_Object(aData-1));
|
290 schuur 1.1 } // end of array porocessing
291
292 else if ((t & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
293 switch (t) {
294 case CMPI_sint32: v.get((Sint32&)data->value.sint32); break;
295 case CMPI_sint16: v.get((Sint16&)data->value.sint16); break;
296 case CMPI_sint8: v.get((Sint8&)data->value.sint8); break;
297 case CMPI_sint64: v.get((Sint64&)data->value.sint64); break;
298 default: ;
299 }
300 }
301
302 else if (t==CMPI_string) {
303 String str;
304 v.get(str);
305 data->value.string=string2CMPIString(str);
306 }
307
308 else if ((t & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
309 switch (t) {
310 case CMPI_uint32: v.get((Uint32&)data->value.uint32); break;
311 schuur 1.1 case CMPI_uint16: v.get((Uint16&)data->value.uint16); break;
312 case CMPI_uint8: v.get((Uint8&)data->value.uint8); break;
313 case CMPI_uint64: v.get((Uint64&)data->value.uint64); break;
314 default: ;
315 }
316 }
317
318 else switch (t) {
319 case CMPI_ref: {
320 CIMObjectPath ref;
321 v.get(ref);
|
322 mreddy 1.22 data->value.ref=reinterpret_cast<CMPIObjectPath*>(new CMPI_Object(new CIMObjectPath(ref)));
|
323 schuur 1.1 }
324 break;
|
325 a.dunfey 1.20 case CMPI_instance: {
326 CIMInstance inst;
327 if(v.getType() == CIMTYPE_OBJECT)
328 {
329 CIMObject tmpObj;
330 v.get(tmpObj);
331 inst = CIMInstance(tmpObj);
332 }
333 else
334 {
335 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
336 v.get(inst);
337 #else
338 return CMPI_RC_ERR_NOT_SUPPORTED;
339 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
340 }
|
341 r.kieninger 1.21
|
342 mreddy 1.23 data->value.inst=reinterpret_cast<CMPIInstance*>(new CMPI_Object(new CIMInstance(inst)));
|
343 a.dunfey 1.20 }
344 break;
|
345 schuur 1.1 case CMPI_dateTime: {
346 CIMDateTime dt;
347 v.get(dt);
|
348 mreddy 1.22 data->value.dateTime=reinterpret_cast<CMPIDateTime*>(new CMPI_Object(new CIMDateTime(dt)));
|
349 schuur 1.1 }
350 break;
351 case CMPI_boolean: v.get((Boolean&)data->value.boolean); break;
352 case CMPI_char16: v.get((Char16&)data->value.char16); break;
353 case CMPI_real32: v.get((Real32&)data->value.real32); break;
354 case CMPI_real64: v.get((Real64&)data->value.real64); break;
355 default:
356 return CMPI_RC_ERR_NOT_SUPPORTED;
357 }
358 return CMPI_RC_OK;
359 }
360
361 CMPIType type2CMPIType(CIMType pt, int array) {
362 static CMPIType types[]={
363 CMPI_boolean, // BOOLEAN,
364 CMPI_uint8, // UINT8,
365 CMPI_sint8, // SINT8,
366 CMPI_uint16, // UINT16,
367 CMPI_sint16, // SINT16,
368 CMPI_uint32, // UINT32,
369 CMPI_sint32, // SINT32,
370 schuur 1.1 CMPI_uint64, // UINT64,
371 CMPI_sint64, // SINT64,
372 CMPI_real32, // REAL32,
373 CMPI_real64, // REAL64,
374 CMPI_char16, // CHAR16,
375 CMPI_string, // STRING,
376 CMPI_dateTime, // DATETIME,
377 CMPI_ref, // REFERENCE
|
378 a.dunfey 1.20 CMPI_instance // Embedded Object
379 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
380 , CMPI_instance // Embedded Instance
381 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
382 schuur 1.1 };
383 int t=types[pt];
384 if (array) t|=CMPI_ARRAY;
385 return (CMPIType)t;
386 }
387
|
388 schuur 1.11 CIMType type2CIMType(CMPIType pt) {
389 switch (pt) {
390 case CMPI_null: return (CIMType)0;
391 case CMPI_boolean: return CIMTYPE_BOOLEAN;
392 case CMPI_char16: return CIMTYPE_CHAR16;
393
394 case CMPI_real32: return CIMTYPE_REAL32;
395 case CMPI_real64: return CIMTYPE_REAL64;
396
397 case CMPI_uint8: return CIMTYPE_UINT8;
398 case CMPI_uint16: return CIMTYPE_UINT16;
399 case CMPI_uint32: return CIMTYPE_UINT32;
400 case CMPI_uint64: return CIMTYPE_UINT64;
401
402 case CMPI_sint8: return CIMTYPE_SINT8;
403 case CMPI_sint16: return CIMTYPE_SINT16;
404 case CMPI_sint32: return CIMTYPE_SINT32;
405 case CMPI_sint64: return CIMTYPE_SINT64;
406
407 case CMPI_string: return CIMTYPE_STRING;
408 case CMPI_chars: return CIMTYPE_STRING;
|
409 venkat.puvvada 1.26 case CMPI_charsptr: return CIMTYPE_STRING;
|
410 schuur 1.11 case CMPI_dateTime: return CIMTYPE_DATETIME;
411 case CMPI_ref: return CIMTYPE_REFERENCE;
|
412 venkat.puvvada 1.26 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
413 case CMPI_instance: return CIMTYPE_INSTANCE;
414 #endif
|
415 schuur 1.11 default: return (CIMType)0;
416 }
417 }
418
|
419 schuur 1.2 CMPIrc key2CMPIData(const String& v, CIMKeyBinding::Type t, CMPIData *data) {
|
420 schuur 1.1 data->state=CMPI_keyValue;
421 switch (t) {
|
422 schuur 1.2 case CIMKeyBinding::NUMERIC: {
|
423 schuur 1.4 CString vp=v.getCString();
|
424 kv.le 1.13
425 data->value.sint64 = 0;
|
426 r.kieninger 1.21 if (*((const char*)vp)=='-')
427 {
428 sscanf((const char*)vp, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d",
429 &data->value.sint64);
430 data->type=CMPI_sint64;
431 }
432 else
433 {
434 sscanf((const char*)vp, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u",
435 &data->value.uint64);
436 data->type=CMPI_uint64;
437 }
|
438 schuur 1.1 }
439 break;
|
440 schuur 1.2 case CIMKeyBinding::STRING:
|
441 schuur 1.1 data->value.string=string2CMPIString(v);
442 data->type=CMPI_string;
443 break;
|
444 schuur 1.2 case CIMKeyBinding::BOOLEAN:
|
445 schuur 1.1 data->value.boolean=(String::equalNoCase(v,"true"));
446 data->type=CMPI_boolean;
447 break;
|
448 schuur 1.2 case CIMKeyBinding::REFERENCE:
|
449 mreddy 1.22 data->value.ref=reinterpret_cast<CMPIObjectPath*>(new CMPI_Object(new CIMObjectPath(v)));
|
450 schuur 1.1 data->type=CMPI_ref;
451 break;
452 default:
453 return CMPI_RC_ERR_NOT_SUPPORTED;
454 }
455 return CMPI_RC_OK;
456 }
457
458 PEGASUS_NAMESPACE_END
459
460
461
462
463
464
|
Return to
CMPI_Value.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI