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
36 PEGASUS_USING_STD;
37 PEGASUS_NAMESPACE_BEGIN
38
39 #define CopyToArray(pt,ct) { Array<pt> ar##pt(aSize); \
40 for (int i=0; i<aSize; i++) ar##pt[i]=aData[i].value.ct; \
41 v.set(ar##pt); }
42
43 #define CopyToStringArray(pt,ct) { Array<pt> ar##pt(aSize); \
44 for (int i=0; i<aSize; i++) ar##pt[i]=String(((char*)aData[i].value.ct)); \
45 v.set(ar##pt); }
46
47 #define CopyToEncArray(pt,ct) { Array<pt> ar##pt(aSize); \
48 for (int i=0; i<aSize; i++) ar##pt[i]=*((pt*)aData[i].value.ct->hdl); \
49 v.set(ar##pt); }
50
51 CIMValue value2CIMValue(CMPIValue* data, CMPIType type, CMPIrc *rc) {
52 CIMValue v;
53 if (rc) *rc=CMPI_RC_OK;
54
55 schuur 1.1 if (type & CMPI_ARRAY) {
56 CMPIArray *ar=data->array;
57 CMPIData *aData=(CMPIData*)ar->hdl;
58 CMPIType aType=aData->type&~CMPI_ARRAY;
59 int aSize=aData->value.sint32;
60 aData++;
61
62 if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
63 switch (aType) {
64 case CMPI_sint32: CopyToArray(Sint32,sint32); break;
65 case CMPI_sint16: CopyToArray(Sint16,sint16); break;
66 case CMPI_sint8: CopyToArray(Sint8,sint8); break;
67 case CMPI_sint64: CopyToArray(Sint64,sint64); break;
68 default: ;
69 }
70 }
71
72 else if (aType==CMPI_chars) CopyToStringArray(String,chars)
73 else if (aType==CMPI_string) CopyToStringArray(String,string->hdl)
74
75 else if ((aType & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
76 schuur 1.1 switch (aType) {
77 case CMPI_uint32: CopyToArray(Uint32,uint32); break;
78 case CMPI_uint16: CopyToArray(Uint16,uint16); break;
79 case CMPI_uint8: CopyToArray(Uint8,uint8); break;
80 case CMPI_uint64: CopyToArray(Uint64,uint64); break;
81 default: ;
82 }
83 }
84
85 else switch (aType) {
86 case CMPI_ref: CopyToEncArray(CIMObjectPath,ref); break;
87 case CMPI_dateTime: CopyToEncArray(CIMDateTime,dateTime); break;
88 case CMPI_boolean: CopyToArray(Boolean,boolean); break;
89 case CMPI_char16: CopyToArray(Char16,char16); break;
90 case CMPI_real32: CopyToArray(Real32,real32); break;
91 case CMPI_real64: CopyToArray(Real64,real64); break;
92 default:
93 if (rc) *rc=CMPI_RC_ERR_NOT_SUPPORTED;
94 }
95 return CIMValue(v);
96 } // end of array processing
97 schuur 1.1
98 else if ((type & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
99 switch (type) {
100 case CMPI_sint32: v.set((Sint32)data->sint32); break;
101 case CMPI_sint16: v.set((Sint16)data->sint16); break;
102 case CMPI_sint8: v.set((Sint8)data->sint8); break;
103 case CMPI_sint64: v.set((Sint64)data->sint64); break;
104 default: ;
105 }
106 }
107
|
108 schuur 1.6 else if (type==CMPI_chars) v.set(data ?
109 String((char*)data) : String::EMPTY );
110 else if (type==CMPI_string) v.set(data->string->hdl ?
111 String((char*)data->string->hdl) : String::EMPTY);
|
112 schuur 1.1
113 else if ((type & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
114 switch (type) {
115 case CMPI_uint32: v.set((Uint32)data->sint32); break;
116 case CMPI_uint16: v.set((Uint16)data->sint16); break;
117 case CMPI_uint8: v.set((Uint8)data->sint8); break;
118 case CMPI_uint64: v.set((Uint64)data->sint64); break;
119 default: ;
120 }
121 }
122
123 else switch (type) {
124 case CMPI_ref: v.set(*((CIMObjectPath*)data->ref->hdl)); break;
125 case CMPI_dateTime: v.set(*((CIMDateTime*)data->dateTime->hdl)); break;
126 case CMPI_boolean: v.set((Boolean&)data->boolean); break;
127 case CMPI_char16: v.set((Char16)data->char16); break;
128 case CMPI_real32: v.set((Real32)data->real32); break;
129 case CMPI_real64: v.set((Real64)data->real64); break;
130 default:
131 if (rc) *rc=CMPI_RC_ERR_NOT_SUPPORTED;
132 }
133 schuur 1.1 return CIMValue(v);
134 }
135
136
137
138 #define CopyFromArray(pt,ct) { Array<pt> ar##pt; \
139 v.get(ar##pt); \
140 for (int i=0; i<aSize; i++) aData[i].value.ct=ar##pt[i]; }
141
142 #define CopyFromStringArray(pt,ct) { Array<pt> ar##pt; \
143 v.get(ar##pt); \
144 for (int i=0; i<aSize; i++) { \
145 aData[i].value.ct=(CMPIString*)new CMPI_Object(ar##pt[i]); } }
146
147 #define CopyFromEncArray(pt,ct,cn) { Array<pt> ar##pt; \
148 v.get(ar##pt); \
149 for (int i=0; i<aSize; i++) { \
150 aData[i].value.cn=(ct*)new CMPI_Object(new pt(ar##pt[i])); } }
151
152
153 CMPIrc value2CMPIData(const CIMValue& v, CMPIType t, CMPIData *data) {
154 schuur 1.1
155 data->type=t;
156 data->state=0;
157
158 if (t & CMPI_ARRAY) {
159 int aSize=v.getArraySize();
160 CMPIType aType=t&~CMPI_ARRAY;
161 CMPIData *aData=new CMPIData[aSize+1];
162 aData->type=aType;
163 aData->value.sint32=aSize;
164 aData++;
165
166 if (aType & (CMPI_UINT|CMPI_SINT)==CMPI_SINT) {
167 switch (aType) {
168 case CMPI_sint32: CopyFromArray(Sint32,sint32); break;
169 case CMPI_sint16: CopyFromArray(Sint16,sint16); break;
170 case CMPI_sint8: CopyFromArray(Sint8,sint8); break;
171 case CMPI_sint64: CopyFromArray(Sint64,sint64); break;
172 default: ;
173 }
174 }
175 schuur 1.1 else if (aType==CMPI_string) CopyFromStringArray(String,string)
176 else if (aType & (CMPI_UINT|CMPI_SINT)==CMPI_UINT) {
177 switch (aType) {
178 case CMPI_uint32: CopyFromArray(Uint32,uint32); break;
179 case CMPI_uint16: CopyFromArray(Uint16,uint16); break;
180 case CMPI_uint8: CopyFromArray(Uint8,uint8); break;
181 case CMPI_uint64: CopyFromArray(Uint64,uint64); break;
182 default: ;
183 }
184 }
185 else switch (aType) {
186 case CMPI_ref: CopyFromEncArray(CIMObjectPath,CMPIObjectPath,ref); break;
187 case CMPI_dateTime: CopyFromEncArray(CIMDateTime,CMPIDateTime,dateTime); break;
188 case CMPI_boolean: CopyFromArray(Boolean,boolean); break;
189 case CMPI_char16: CopyFromArray(Char16,char16); break;
190 case CMPI_real32: CopyFromArray(Real32,real32); break;
191 case CMPI_real64: CopyFromArray(Real64,real64); break;
192 default:
193 return CMPI_RC_ERR_NOT_SUPPORTED;
194 }
195 data->value.array=(CMPIArray*)new CMPI_Object(aData-1);
196 schuur 1.1 } // end of array porocessing
197
198 else if ((t & (CMPI_UINT|CMPI_SINT))==CMPI_SINT) {
199 switch (t) {
200 case CMPI_sint32: v.get((Sint32&)data->value.sint32); break;
201 case CMPI_sint16: v.get((Sint16&)data->value.sint16); break;
202 case CMPI_sint8: v.get((Sint8&)data->value.sint8); break;
203 case CMPI_sint64: v.get((Sint64&)data->value.sint64); break;
204 default: ;
205 }
206 }
207
208 else if (t==CMPI_string) {
209 String str;
210 v.get(str);
211 data->value.string=string2CMPIString(str);
212 }
213
214 else if ((t & (CMPI_UINT|CMPI_SINT))==CMPI_UINT) {
215 switch (t) {
216 case CMPI_uint32: v.get((Uint32&)data->value.uint32); break;
217 schuur 1.1 case CMPI_uint16: v.get((Uint16&)data->value.uint16); break;
218 case CMPI_uint8: v.get((Uint8&)data->value.uint8); break;
219 case CMPI_uint64: v.get((Uint64&)data->value.uint64); break;
220 default: ;
221 }
222 }
223
224 else switch (t) {
225 case CMPI_ref: {
226 CIMObjectPath ref;
227 v.get(ref);
228 data->value.ref=(CMPIObjectPath*)new CMPI_Object(new CIMObjectPath(ref));
229 }
230 break;
231 case CMPI_dateTime: {
232 CIMDateTime dt;
233 v.get(dt);
234 data->value.dateTime=(CMPIDateTime*)new CMPI_Object(new CIMDateTime(dt));
235 }
236 break;
237 case CMPI_boolean: v.get((Boolean&)data->value.boolean); break;
238 schuur 1.1 case CMPI_char16: v.get((Char16&)data->value.char16); break;
239 case CMPI_real32: v.get((Real32&)data->value.real32); break;
240 case CMPI_real64: v.get((Real64&)data->value.real64); break;
241 default:
242 return CMPI_RC_ERR_NOT_SUPPORTED;
243 }
244 return CMPI_RC_OK;
245 }
246
247 CMPIType type2CMPIType(CIMType pt, int array) {
248 static CMPIType types[]={
249 CMPI_boolean, // BOOLEAN,
250 CMPI_uint8, // UINT8,
251 CMPI_sint8, // SINT8,
252 CMPI_uint16, // UINT16,
253 CMPI_sint16, // SINT16,
254 CMPI_uint32, // UINT32,
255 CMPI_sint32, // SINT32,
256 CMPI_uint64, // UINT64,
257 CMPI_sint64, // SINT64,
258 CMPI_real32, // REAL32,
259 schuur 1.1 CMPI_real64, // REAL64,
260 CMPI_char16, // CHAR16,
261 CMPI_string, // STRING,
262 CMPI_dateTime, // DATETIME,
263 CMPI_ref, // REFERENCE
264 };
265 int t=types[pt];
266 if (array) t|=CMPI_ARRAY;
267 return (CMPIType)t;
268 }
269
|
270 schuur 1.2 CMPIrc key2CMPIData(const String& v, CIMKeyBinding::Type t, CMPIData *data) {
|
271 schuur 1.1 data->state=CMPI_keyValue;
272 switch (t) {
|
273 schuur 1.2 case CIMKeyBinding::NUMERIC: {
|
274 schuur 1.4 // const char *vp=v.getCString();
275 CString vp=v.getCString();
|
276 schuur 1.1 #ifdef PEGASUS_PLATFORM_ZOS_ZSERIES_IBM
|
277 schuur 1.4 data->value.sint64=strtoll((const char*)vp, NULL, 10);
278 #elif defined(PEGASUS_OS_HPUX) || defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
|
279 schuur 1.3 data->value.sint64 = 0;
|
280 schuur 1.4 sscanf((const char*)vp, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d",
|
281 schuur 1.3 &data->value.sint64);
|
282 schuur 1.1 #else
|
283 schuur 1.4 data->value.sint64=atoll((const char*)vp);
|
284 schuur 1.1 #endif
285 data->type=CMPI_sint64;
|
286 schuur 1.4 // delete vp;
|
287 schuur 1.1 }
288 break;
|
289 schuur 1.2 case CIMKeyBinding::STRING:
|
290 schuur 1.1 data->value.string=string2CMPIString(v);
291 data->type=CMPI_string;
292 break;
|
293 schuur 1.2 case CIMKeyBinding::BOOLEAN:
|
294 schuur 1.1 data->value.boolean=(String::equalNoCase(v,"true"));
295 data->type=CMPI_boolean;
296 break;
|
297 schuur 1.2 case CIMKeyBinding::REFERENCE:
|
298 schuur 1.1 data->value.ref=(CMPIObjectPath*)new CMPI_Object(new CIMObjectPath(v));
299 data->type=CMPI_ref;
300 break;
301 default:
302 return CMPI_RC_ERR_NOT_SUPPORTED;
303 }
304 return CMPI_RC_OK;
305 }
306
307 PEGASUS_NAMESPACE_END
308
309
310
311
312
313
|
Return to
CMPI_Value.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI