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 venkat.puvvada 1.24.4.1 //NOCHKSRC
35
|
36 schuur 1.5 #include "CMPI_Version.h"
|
37 schuur 1.2
|
38 schuur 1.1 #include "CMPI_String.h"
|
39 schuur 1.11 #include "CMPI_Value.h"
|
40 schuur 1.1
41 PEGASUS_USING_STD;
42 PEGASUS_NAMESPACE_BEGIN
43
44 #define CopyToArray(pt,ct) { Array<pt> ar##pt(aSize); \
45 for (int i=0; i<aSize; i++) ar##pt[i]=aData[i].value.ct; \
46 v.set(ar##pt); }
47
48 #define CopyToStringArray(pt,ct) { Array<pt> ar##pt(aSize); \
49 for (int i=0; i<aSize; i++) ar##pt[i]=String(((char*)aData[i].value.ct)); \
50 v.set(ar##pt); }
51
|
52 schuur 1.12 #define CopyCharsptrToStringArray(pt,ct) { Array<pt> ar##pt(aSize); \
53 for (int i=0; i<aSize; i++) ar##pt[i]=String((*(char**)aData[i].value.ct)); \
54 v.set(ar##pt); }
55
|
56 schuur 1.1 #define CopyToEncArray(pt,ct) { Array<pt> ar##pt(aSize); \
57 for (int i=0; i<aSize; i++) ar##pt[i]=*((pt*)aData[i].value.ct->hdl); \
58 v.set(ar##pt); }
59
|
60 konrad.r 1.17 CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc) {
|
61 schuur 1.1 CIMValue v;
62 if (rc) *rc=CMPI_RC_OK;
63
64 if (type & CMPI_ARRAY) {
|
65 schuur 1.11
66 if (data==NULL || data->array==NULL) {
67 CMPIType aType=type&~CMPI_ARRAY;
68 return CIMValue(type2CIMType(aType),true);
69 }
70
|
71 schuur 1.1 CMPIArray *ar=data->array;
72 CMPIData *aData=(CMPIData*)ar->hdl;
73 CMPIType aType=aData->type&~CMPI_ARRAY;
74 int aSize=aData->value.sint32;
75 aData++;
76
|
77 schuur 1.11 if (aType & CMPI_ENC && (data==NULL || data->array==NULL)) {
78 if (aType==CMPI_chars || aType==CMPI_string)
79 return CIMValue(CIMTYPE_STRING,true);
80 if (aType==CMPI_dateTime)
81 return CIMValue(CIMTYPE_DATETIME,true);
82 if (aType==CMPI_ref)
83 return CIMValue(CIMTYPE_REFERENCE,true);
84 }
85
|
86 schuur 1.1 if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
87 switch (aType) {
88 case CMPI_sint32: CopyToArray(Sint32,sint32); break;
89 case CMPI_sint16: CopyToArray(Sint16,sint16); break;
90 case CMPI_sint8: CopyToArray(Sint8,sint8); break;
91 case CMPI_sint64: CopyToArray(Sint64,sint64); break;
92 default: ;
93 }
94 }
95
|
96 schuur 1.12 else if (aType==CMPI_chars) CopyToStringArray(String,chars)
97 else if (aType==CMPI_charsptr) CopyCharsptrToStringArray(String,chars)
98 else if (aType==CMPI_string) CopyToStringArray(String,string->hdl)
|
99 schuur 1.1
100 else if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
101 switch (aType) {
102 case CMPI_uint32: CopyToArray(Uint32,uint32); break;
103 case CMPI_uint16: CopyToArray(Uint16,uint16); break;
104 case CMPI_uint8: CopyToArray(Uint8,uint8); break;
105 case CMPI_uint64: CopyToArray(Uint64,uint64); break;
106 default: ;
107 }
108 }
109
110 else switch (aType) {
111 case CMPI_ref: CopyToEncArray(CIMObjectPath,ref); break;
112 case CMPI_dateTime: CopyToEncArray(CIMDateTime,dateTime); break;
|
113 marek 1.24 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
114 venkat.puvvada 1.24.4.1 case CMPI_instance: CopyToEncArray(CIMObject,inst); break;
|
115 marek 1.24 #endif
|
116 schuur 1.1 case CMPI_boolean: CopyToArray(Boolean,boolean); break;
117 case CMPI_char16: CopyToArray(Char16,char16); break;
118 case CMPI_real32: CopyToArray(Real32,real32); break;
119 case CMPI_real64: CopyToArray(Real64,real64); break;
120 default:
121 if (rc) *rc=CMPI_RC_ERR_NOT_SUPPORTED;
122 }
123 return CIMValue(v);
124 } // end of array processing
125
|
126 schuur 1.11
127
128 else if (type==CMPI_chars) {
129 if (data) v.set(String((char*)data));
130 else return CIMValue(CIMTYPE_STRING,false);
131 }
|
132 schuur 1.12 else if (type==CMPI_charsptr) {
133 if (data && *(char**)data) v.set(String(*(char**)data));
134 else return CIMValue(CIMTYPE_STRING,false);
135 }
|
136 schuur 1.11
137 else if (type & CMPI_ENC &&
138 (data==NULL || data->string==NULL || data->string->hdl==NULL)) {
139 if (type==CMPI_string)
140 return CIMValue(CIMTYPE_STRING,false);
141 if (type==CMPI_dateTime)
142 return CIMValue(CIMTYPE_DATETIME,false);
143 if (type==CMPI_ref)
144 return CIMValue(CIMTYPE_REFERENCE,false);
145 }
146
|
147 schuur 1.1 else if ((type & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
148 switch (type) {
149 case CMPI_sint32: v.set((Sint32)data->sint32); break;
150 case CMPI_sint16: v.set((Sint16)data->sint16); break;
151 case CMPI_sint8: v.set((Sint8)data->sint8); break;
152 case CMPI_sint64: v.set((Sint64)data->sint64); break;
153 default: ;
154 }
155 }
156
|
157 schuur 1.6 else if (type==CMPI_string) v.set(data->string->hdl ?
158 String((char*)data->string->hdl) : String::EMPTY);
|
159 schuur 1.1
160 else if ((type & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
161 switch (type) {
|
162 kumpf 1.18 case CMPI_uint32: v.set((Uint32)data->uint32); break;
163 case CMPI_uint16: v.set((Uint16)data->uint16); break;
164 case CMPI_uint8: v.set((Uint8)data->uint8); break;
165 case CMPI_uint64: v.set((Uint64)data->uint64); break;
|
166 schuur 1.1 default: ;
167 }
168 }
|
169 r.kieninger 1.21 else if (type ==CMPI_instance)
|
170 konrad.r 1.16 {
|
171 a.dunfey 1.20 v.set(*((CIMObject*) data->inst->hdl));
|
172 konrad.r 1.16 }
|
173 schuur 1.1 else switch (type) {
174 case CMPI_ref: v.set(*((CIMObjectPath*)data->ref->hdl)); break;
175 case CMPI_dateTime: v.set(*((CIMDateTime*)data->dateTime->hdl)); break;
176 case CMPI_boolean: v.set((Boolean&)data->boolean); break;
177 case CMPI_char16: v.set((Char16)data->char16); break;
178 case CMPI_real32: v.set((Real32)data->real32); break;
179 case CMPI_real64: v.set((Real64)data->real64); break;
180 default:
181 if (rc) *rc=CMPI_RC_ERR_NOT_SUPPORTED;
182 }
183 return CIMValue(v);
184 }
185
186
187
188 #define CopyFromArray(pt,ct) { Array<pt> ar##pt; \
189 v.get(ar##pt); \
190 for (int i=0; i<aSize; i++) aData[i].value.ct=ar##pt[i]; }
191
192 #define CopyFromStringArray(pt,ct) { Array<pt> ar##pt; \
193 v.get(ar##pt); \
194 schuur 1.1 for (int i=0; i<aSize; i++) { \
|
195 mreddy 1.22 aData[i].value.ct=reinterpret_cast<CMPIString*>(new CMPI_Object(ar##pt[i])); } }
|
196 schuur 1.1
197 #define CopyFromEncArray(pt,ct,cn) { Array<pt> ar##pt; \
198 v.get(ar##pt); \
199 for (int i=0; i<aSize; i++) { \
|
200 mreddy 1.22 aData[i].value.cn=reinterpret_cast<ct*>(new CMPI_Object(new pt(ar##pt[i]))); } }
|
201 schuur 1.1
202
203 CMPIrc value2CMPIData(const CIMValue& v, CMPIType t, CMPIData *data) {
204
205 data->type=t;
|
206 schuur 1.11 data->state=0;
207 data->value.uint64=0;
208
209 if (v.isNull()) {
210 data->state=CMPI_nullValue;
211 return CMPI_RC_OK;
212 }
|
213 schuur 1.1
214 if (t & CMPI_ARRAY) {
215 int aSize=v.getArraySize();
216 CMPIType aType=t&~CMPI_ARRAY;
217 CMPIData *aData=new CMPIData[aSize+1];
218 aData->type=aType;
219 aData->value.sint32=aSize;
|
220 schuur 1.11
221 for (int i=1; i<aSize+1; i++) {
222 aData[i].type=aType;
223 aData[i].state=0;
224 }
|
225 schuur 1.1 aData++;
226
|
227 schuur 1.11 if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
|
228 schuur 1.1 switch (aType) {
229 case CMPI_sint32: CopyFromArray(Sint32,sint32); break;
230 case CMPI_sint16: CopyFromArray(Sint16,sint16); break;
231 case CMPI_sint8: CopyFromArray(Sint8,sint8); break;
232 case CMPI_sint64: CopyFromArray(Sint64,sint64); break;
233 default: ;
234 }
235 }
236 else if (aType==CMPI_string) CopyFromStringArray(String,string)
|
237 schuur 1.11 else if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
|
238 schuur 1.1 switch (aType) {
239 case CMPI_uint32: CopyFromArray(Uint32,uint32); break;
240 case CMPI_uint16: CopyFromArray(Uint16,uint16); break;
241 case CMPI_uint8: CopyFromArray(Uint8,uint8); break;
242 case CMPI_uint64: CopyFromArray(Uint64,uint64); break;
243 default: ;
244 }
245 }
246 else switch (aType) {
247 case CMPI_ref: CopyFromEncArray(CIMObjectPath,CMPIObjectPath,ref); break;
248 case CMPI_dateTime: CopyFromEncArray(CIMDateTime,CMPIDateTime,dateTime); break;
|
249 marek 1.24 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
250 venkat.puvvada 1.24.4.1 case CMPI_instance:
251 if (v.getType() == CIMTYPE_OBJECT)
252 {
253 Array<CIMObject> tmpObjs;
254 v.get(tmpObjs);
255 for (int i = 0; i < aSize ; ++i)
256 {
257 aData[i].value.inst = reinterpret_cast<CMPIInstance*>(
258 new CMPI_Object(new CIMInstance(tmpObjs[i])));
259 }
260 }
261 else
262 {
263 CopyFromEncArray(CIMInstance,CMPIInstance,inst);
264 }
265 break;
|
266 marek 1.24 #endif
|
267 schuur 1.1 case CMPI_boolean: CopyFromArray(Boolean,boolean); break;
268 case CMPI_char16: CopyFromArray(Char16,char16); break;
269 case CMPI_real32: CopyFromArray(Real32,real32); break;
270 case CMPI_real64: CopyFromArray(Real64,real64); break;
271 default:
272 return CMPI_RC_ERR_NOT_SUPPORTED;
273 }
|
274 mreddy 1.22 data->value.array=reinterpret_cast<CMPIArray*>(new CMPI_Object(aData-1));
|
275 schuur 1.1 } // end of array porocessing
276
277 else if ((t & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
278 switch (t) {
279 case CMPI_sint32: v.get((Sint32&)data->value.sint32); break;
280 case CMPI_sint16: v.get((Sint16&)data->value.sint16); break;
281 case CMPI_sint8: v.get((Sint8&)data->value.sint8); break;
282 case CMPI_sint64: v.get((Sint64&)data->value.sint64); break;
283 default: ;
284 }
285 }
286
287 else if (t==CMPI_string) {
288 String str;
289 v.get(str);
290 data->value.string=string2CMPIString(str);
291 }
292
293 else if ((t & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
294 switch (t) {
295 case CMPI_uint32: v.get((Uint32&)data->value.uint32); break;
296 schuur 1.1 case CMPI_uint16: v.get((Uint16&)data->value.uint16); break;
297 case CMPI_uint8: v.get((Uint8&)data->value.uint8); break;
298 case CMPI_uint64: v.get((Uint64&)data->value.uint64); break;
299 default: ;
300 }
301 }
302
303 else switch (t) {
304 case CMPI_ref: {
305 CIMObjectPath ref;
306 v.get(ref);
|
307 mreddy 1.22 data->value.ref=reinterpret_cast<CMPIObjectPath*>(new CMPI_Object(new CIMObjectPath(ref)));
|
308 schuur 1.1 }
309 break;
|
310 a.dunfey 1.20 case CMPI_instance: {
311 CIMInstance inst;
312 if(v.getType() == CIMTYPE_OBJECT)
313 {
314 CIMObject tmpObj;
315 v.get(tmpObj);
316 inst = CIMInstance(tmpObj);
317 }
318 else
319 {
320 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
321 v.get(inst);
322 #else
323 return CMPI_RC_ERR_NOT_SUPPORTED;
324 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
325 }
|
326 r.kieninger 1.21
|
327 mreddy 1.23 data->value.inst=reinterpret_cast<CMPIInstance*>(new CMPI_Object(new CIMInstance(inst)));
|
328 a.dunfey 1.20 }
329 break;
|
330 schuur 1.1 case CMPI_dateTime: {
331 CIMDateTime dt;
332 v.get(dt);
|
333 mreddy 1.22 data->value.dateTime=reinterpret_cast<CMPIDateTime*>(new CMPI_Object(new CIMDateTime(dt)));
|
334 schuur 1.1 }
335 break;
336 case CMPI_boolean: v.get((Boolean&)data->value.boolean); break;
337 case CMPI_char16: v.get((Char16&)data->value.char16); break;
338 case CMPI_real32: v.get((Real32&)data->value.real32); break;
339 case CMPI_real64: v.get((Real64&)data->value.real64); break;
340 default:
341 return CMPI_RC_ERR_NOT_SUPPORTED;
342 }
343 return CMPI_RC_OK;
344 }
345
346 CMPIType type2CMPIType(CIMType pt, int array) {
347 static CMPIType types[]={
348 CMPI_boolean, // BOOLEAN,
349 CMPI_uint8, // UINT8,
350 CMPI_sint8, // SINT8,
351 CMPI_uint16, // UINT16,
352 CMPI_sint16, // SINT16,
353 CMPI_uint32, // UINT32,
354 CMPI_sint32, // SINT32,
355 schuur 1.1 CMPI_uint64, // UINT64,
356 CMPI_sint64, // SINT64,
357 CMPI_real32, // REAL32,
358 CMPI_real64, // REAL64,
359 CMPI_char16, // CHAR16,
360 CMPI_string, // STRING,
361 CMPI_dateTime, // DATETIME,
362 CMPI_ref, // REFERENCE
|
363 a.dunfey 1.20 CMPI_instance // Embedded Object
364 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
365 , CMPI_instance // Embedded Instance
366 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
|
367 schuur 1.1 };
368 int t=types[pt];
369 if (array) t|=CMPI_ARRAY;
370 return (CMPIType)t;
371 }
372
|
373 schuur 1.11 CIMType type2CIMType(CMPIType pt) {
374 switch (pt) {
375 case CMPI_null: return (CIMType)0;
376 case CMPI_boolean: return CIMTYPE_BOOLEAN;
377 case CMPI_char16: return CIMTYPE_CHAR16;
378
379 case CMPI_real32: return CIMTYPE_REAL32;
380 case CMPI_real64: return CIMTYPE_REAL64;
381
382 case CMPI_uint8: return CIMTYPE_UINT8;
383 case CMPI_uint16: return CIMTYPE_UINT16;
384 case CMPI_uint32: return CIMTYPE_UINT32;
385 case CMPI_uint64: return CIMTYPE_UINT64;
386
387 case CMPI_sint8: return CIMTYPE_SINT8;
388 case CMPI_sint16: return CIMTYPE_SINT16;
389 case CMPI_sint32: return CIMTYPE_SINT32;
390 case CMPI_sint64: return CIMTYPE_SINT64;
391
392 case CMPI_string: return CIMTYPE_STRING;
393 case CMPI_chars: return CIMTYPE_STRING;
394 schuur 1.11 case CMPI_dateTime: return CIMTYPE_DATETIME;
395 case CMPI_ref: return CIMTYPE_REFERENCE;
396
397 default: return (CIMType)0;
398 }
399 }
400
|
401 schuur 1.2 CMPIrc key2CMPIData(const String& v, CIMKeyBinding::Type t, CMPIData *data) {
|
402 schuur 1.1 data->state=CMPI_keyValue;
403 switch (t) {
|
404 schuur 1.2 case CIMKeyBinding::NUMERIC: {
|
405 schuur 1.4 CString vp=v.getCString();
|
406 kv.le 1.13
407 data->value.sint64 = 0;
|
408 r.kieninger 1.21 if (*((const char*)vp)=='-')
409 {
410 sscanf((const char*)vp, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d",
411 &data->value.sint64);
412 data->type=CMPI_sint64;
413 }
414 else
415 {
416 sscanf((const char*)vp, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u",
417 &data->value.uint64);
418 data->type=CMPI_uint64;
419 }
|
420 schuur 1.1 }
421 break;
|
422 schuur 1.2 case CIMKeyBinding::STRING:
|
423 schuur 1.1 data->value.string=string2CMPIString(v);
424 data->type=CMPI_string;
425 break;
|
426 schuur 1.2 case CIMKeyBinding::BOOLEAN:
|
427 schuur 1.1 data->value.boolean=(String::equalNoCase(v,"true"));
428 data->type=CMPI_boolean;
429 break;
|
430 schuur 1.2 case CIMKeyBinding::REFERENCE:
|
431 mreddy 1.22 data->value.ref=reinterpret_cast<CMPIObjectPath*>(new CMPI_Object(new CIMObjectPath(v)));
|
432 schuur 1.1 data->type=CMPI_ref;
433 break;
434 default:
435 return CMPI_RC_ERR_NOT_SUPPORTED;
436 }
437 return CMPI_RC_OK;
438 }
439
440 PEGASUS_NAMESPACE_END
441
442
443
444
445
446
|
Return to
CMPI_Value.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI