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