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