1 martin 1.32 //%LICENSE////////////////////////////////////////////////////////////////
|
2 martin 1.33 //
|
3 martin 1.32 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
|
9 martin 1.33 //
|
10 martin 1.32 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
|
16 martin 1.33 //
|
17 martin 1.32 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
|
19 martin 1.33 //
|
20 martin 1.32 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
21 martin 1.33 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
22 martin 1.32 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
27 martin 1.33 //
|
28 martin 1.32 //////////////////////////////////////////////////////////////////////////
|
29 schuur 1.1 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
|
32 schuur 1.4 #include "CMPI_Version.h"
|
33 schuur 1.1
34 #include "CMPI_Object.h"
35 #include "CMPI_Ftabs.h"
|
36 kavita.gupta 1.34 #include "CMPI_Array.h"
|
37 ms.aruran 1.25 #include <Pegasus/Common/Tracer.h>
|
38 konrad.r 1.16 #include <string.h>
39
|
40 schuur 1.1 PEGASUS_USING_STD;
41 PEGASUS_NAMESPACE_BEGIN
42
|
43 venkat.puvvada 1.24 extern "C"
44 {
|
45 schuur 1.9
|
46 venkat.puvvada 1.24 PEGASUS_STATIC CMPIStatus arrayRelease(CMPIArray* eArray)
47 {
|
48 ms.aruran 1.25 PEG_METHOD_ENTER(
49 TRC_CMPIPROVIDERINTERFACE,
50 "CMPI_Array:arrayRelease()");
|
51 kavita.gupta 1.34 CMPIStatus rrc = {CMPI_RC_OK,NULL};
52 CMPI_Array *arr = (CMPI_Array*)eArray->hdl;
53 if (!arr)
54 {
55 PEG_METHOD_EXIT();
56 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
57 }
58 CMPIData* dta=(CMPIData*)arr->hdl;
59 if (!dta)
60 {
61 PEG_METHOD_EXIT();
62 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
63 }
|
64 ms.aruran 1.25
|
65 thilo.boehm 1.35 if (arr->isCloned != 0)
|
66 venkat.puvvada 1.24 {
|
67 kavita.gupta 1.34 for (unsigned int i=1; i<=dta->value.uint32; i++)
68 {
69 if (dta->type & CMPI_ENC && dta[i].state==CMPI_goodValue)
70 {
71 switch (dta[i].type)
72 {
73 case CMPI_instance:
74 if (dta[i].value.inst)
75 {
76 rrc = (dta[i].value.inst)->ft->release(
77 dta[i].value.inst);
78 }
79 break;
80 case CMPI_ref:
81 if (dta[i].value.ref)
82 {
83 rrc = (dta[i].value.ref)->ft->release(
84 dta[i].value.ref);
85 }
86 break;
87 case CMPI_args:
88 kavita.gupta 1.34 if (dta[i].value.args)
89 {
90 rrc = (dta[i].value.args)->ft->release(
91 dta[i].value.args);
92 }
93 break;
94 case CMPI_dateTime:
95 if (dta[i].value.dateTime)
96 {
97 rrc = (dta[i].value.dateTime)->ft->release(
98 dta[i].value.dateTime);
99 }
100 break;
101 case CMPI_enumeration:
102 if (dta[i].value.Enum)
103 {
104 rrc = (dta[i].value.Enum)->ft->release(
105 dta[i].value.Enum);
106 }
107 break;
108 case CMPI_filter:
109 kavita.gupta 1.34 if (dta[i].value.filter)
110 {
111 rrc = (dta[i].value.filter)->ft->release(
112 dta[i].value.filter);
113 }
114 break;
115 case CMPI_charsptr:
116 if (dta[i].value.dataPtr.ptr)
117 {
118 free(dta[i].value.dataPtr.ptr);
119 }
120 break;
121 case CMPI_string:
122 if (dta[i].value.string)
123 {
124 rrc = (dta[i].value.string)->ft->release(
125 dta[i].value.string);
126 }
127 break;
128 }
129 }
130 kavita.gupta 1.34 }
|
131 venkat.puvvada 1.24 }
|
132 kavita.gupta 1.34 delete[] dta;
133 delete arr;
134 reinterpret_cast<CMPI_Object*>(eArray)->unlinkAndDelete();
|
135 ms.aruran 1.25 PEG_METHOD_EXIT();
|
136 kavita.gupta 1.34 CMReturn(CMPI_RC_OK);
|
137 venkat.puvvada 1.24 }
138
139 PEGASUS_STATIC CMPIArray* arrayClone(
140 const CMPIArray* eArray,
141 CMPIStatus* rc)
142 {
|
143 ms.aruran 1.25 PEG_METHOD_ENTER(
144 TRC_CMPIPROVIDERINTERFACE,
145 "CMPI_Array:arrayClone()");
|
146 kavita.gupta 1.34 CMPI_Array *arr = (CMPI_Array*)eArray->hdl;
147 if (!arr)
148 {
149 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
150 PEG_METHOD_EXIT();
151 return NULL;
152 }
153 CMPIData* dta=(CMPIData*)arr->hdl;
|
154 venkat.puvvada 1.24 if (!dta)
155 {
156 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
|
157 ms.aruran 1.25 PEG_METHOD_EXIT();
|
158 venkat.puvvada 1.24 return NULL;
159 }
160 CMPIData* nDta = new CMPIData[dta->value.uint32+1];
|
161 kavita.gupta 1.34 CMPI_Array* nArr = new CMPI_Array(nDta, true);
162 CMPI_Object* obj = new CMPI_Object(nArr);
|
163 venkat.puvvada 1.24 obj->unlink();
164 CMPIArray* nArray = reinterpret_cast<CMPIArray*>(obj);
165 CMPIStatus rrc = {CMPI_RC_OK,NULL};
166
167 if (dta->type & CMPI_ENC)
168 {
169 for (unsigned int i=1; i<=dta->value.uint32; i++)
170 {
171 nDta[i].state=CMPI_nullValue;
172 }
173 }
174
175 for (unsigned int i=0; i<=dta->value.uint32; i++)
176 {
177 nDta[i]=dta[i];
178 if (i == 0)
179 {
180 continue;
181 }
182 if (dta->type & CMPI_ENC && dta[i].state==CMPI_goodValue)
183 {
|
184 kavita.gupta 1.34 switch (dta[i].type)
|
185 venkat.puvvada 1.24 {
|
186 kavita.gupta 1.34 case CMPI_instance:
187 if (dta[i].value.inst)
188 {
189 nDta[i].value.inst =
190 (dta[i].value.inst)->ft->clone(
191 dta[i].value.inst,
192 &rrc);
193 }
194 break;
|
195 thilo.boehm 1.35
|
196 kavita.gupta 1.34 case CMPI_ref:
197 if (dta[i].value.ref)
198 {
199 nDta[i].value.ref = (dta[i].value.ref)->ft->clone(
200 dta[i].value.ref,
201 &rrc);
202 }
203 break;
204
205 case CMPI_args:
206 if (dta[i].value.args)
207 {
208 nDta[i].value.args =
209 (dta[i].value.args)->ft->clone(
210 dta[i].value.args,
211 &rrc);
212 }
213 break;
214
215 case CMPI_dateTime:
216 if (dta[i].value.dateTime)
217 kavita.gupta 1.34 {
218 nDta[i].value.dateTime =
219 (dta[i].value.dateTime)->ft->clone(
220 dta[i].value.dateTime,
221 &rrc);
222 }
223 break;
224
225 case CMPI_enumeration:
226 if (dta[i].value.Enum)
227 {
228 nDta[i].value.Enum =
229 (dta[i].value.Enum)->ft->clone(
230 dta[i].value.Enum,
231 &rrc);
232 }
233 break;
234
235 case CMPI_filter:
236 if (dta[i].value.filter)
237 {
238 kavita.gupta 1.34 nDta[i].value.filter =
239 (dta[i].value.filter)->ft->clone(
240 dta[i].value.filter,
241 &rrc);
242 }
243 break;
244
245 case CMPI_charsptr:
246 if (dta[i].value.dataPtr.length>0)
|
247 venkat.puvvada 1.24 {
|
248 thilo.boehm 1.35 nDta[i].value.dataPtr.length =
|
249 kavita.gupta 1.34 dta[i].value.dataPtr.length;
250 nDta[i].value.dataPtr.ptr =
251 malloc(nDta[i].value.dataPtr.length);
252 if (nDta[i].value.dataPtr.ptr == NULL)
253 {
254 arrayRelease(nArray);
255 if (rc)
256 {
257 *rc=rrc;
258 }
259 return NULL;
260 }
261 memcpy(
262 nDta[i].value.dataPtr.ptr,
263 dta[i].value.dataPtr.ptr,
264 dta[i].value.dataPtr.length);
|
265 venkat.puvvada 1.24 }
|
266 kavita.gupta 1.34 break;
|
267 venkat.puvvada 1.24
|
268 kavita.gupta 1.34 case CMPI_string:
269 if (dta[i].value.string)
270 {
271 nDta[i].value.string =
272 (dta[i].value.string)->ft->clone(
273 dta[i].value.string,
274 &rrc);
275 }
276 break;
|
277 venkat.puvvada 1.24 }
278 if (rrc.rc)
279 {
280 arrayRelease(nArray);
281 if (rc)
282 {
283 *rc=rrc;
284 }
|
285 ms.aruran 1.25 PEG_METHOD_EXIT();
|
286 venkat.puvvada 1.24 return NULL;
287 }
288 }
289 }
|
290 kavita.gupta 1.34
|
291 venkat.puvvada 1.24 CMSetStatus(rc,CMPI_RC_OK);
|
292 ms.aruran 1.25 PEG_METHOD_EXIT();
|
293 venkat.puvvada 1.24 return nArray;
294 }
295
296 PEGASUS_STATIC CMPIData arrayGetElementAt(
297 const CMPIArray* eArray,
298 CMPICount pos,
299 CMPIStatus* rc)
300 {
301 CMPIData data = {0,CMPI_nullValue,{0}};
|
302 kavita.gupta 1.34 CMPI_Array *arr = (CMPI_Array*)eArray->hdl;
303 if (!arr)
304 {
305 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
306 return data;
307 }
308
309 CMPIData *dta = (CMPIData*)arr->hdl;
|
310 venkat.puvvada 1.24 if (!dta)
311 {
312 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
313 return data;
314 }
315 CMSetStatus(rc,CMPI_RC_OK);
316 if (pos < dta->value.uint32)
317 {
|
318 ouyang.jian 1.31 if (dta->type == CMPI_chars && dta[pos+1].state == CMPI_goodValue)
|
319 marek 1.29 {
320 data.type = CMPI_chars;
321 data.state = CMPI_goodValue;
|
322 s.kodali 1.30 data.value.chars = (char*)CMGetCharsPtr(
323 dta[pos+1].value.string,
324 NULL);
|
325 marek 1.29 return data;
326 }
327 else
328 {
329 return dta[pos+1];
330 }
|
331 venkat.puvvada 1.24 }
332 CMSetStatus(rc,CMPI_RC_ERR_NO_SUCH_PROPERTY);
333 return data;
334 }
335
336 CMPIStatus arraySetElementAt(
337 CMPIArray* eArray,
338 CMPICount pos,
339 const CMPIValue *val,
340 CMPIType type)
341 {
|
342 ms.aruran 1.25 PEG_METHOD_ENTER(
343 TRC_CMPIPROVIDERINTERFACE,
344 "CMPI_Array:arraySetElementAt()");
|
345 kavita.gupta 1.34 CMPI_Array *arr = (CMPI_Array*)eArray->hdl;
346 if (!arr)
347 {
348 PEG_METHOD_EXIT();
349 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
350 }
351
352 CMPIData *dta = (CMPIData*)arr->hdl;
|
353 venkat.puvvada 1.24 if (!dta)
354 {
|
355 ms.aruran 1.25 PEG_METHOD_EXIT();
|
356 venkat.puvvada 1.24 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
357 }
358 if (!val)
359 {
|
360 ms.aruran 1.25 PEG_METHOD_EXIT();
|
361 venkat.puvvada 1.24 CMReturn( CMPI_RC_ERR_INVALID_PARAMETER);
362 }
363 if (pos<dta->value.uint32)
364 {
|
365 kavita.gupta 1.34 if (type == CMPI_null)
366 {
367 dta[pos+1].state=CMPI_nullValue;
368 PEG_METHOD_EXIT();
369 CMReturn(CMPI_RC_OK);
370 }
371 else if ((dta->type&~CMPI_ARRAY)==type)
|
372 venkat.puvvada 1.24 {
373 dta[pos+1].state=CMPI_goodValue;
|
374 kumpf 1.27 if (type == CMPI_chars)
375 {
|
376 marek 1.29 // Store char* as CMPIString internally, this frees us from
377 // doing explicit memory management for char*.
378 dta[pos+1].value.string = reinterpret_cast<CMPIString*>(
379 new CMPI_Object((const char*) val));
380 dta[pos+1].type = CMPI_string;
|
381 kumpf 1.27 }
382 else
383 {
384 dta[pos+1].value = *val;
385 }
|
386 ms.aruran 1.25 PEG_METHOD_EXIT();
|
387 venkat.puvvada 1.24 CMReturn(CMPI_RC_OK);
388 }
389 else
390 {
391 char msg[512];
392 sprintf(msg,"arraySetElementAt(): CMPI_RC_ERR_TYPE_MISMATCH."
|
393 kavita.gupta 1.26 " Is %u - should be %u",
|
394 kumpf 1.28 (unsigned int)type, (unsigned int)dta->type);
|
395 ms.aruran 1.25 PEG_METHOD_EXIT();
|
396 venkat.puvvada 1.24 CMReturnWithString(
397 CMPI_RC_ERR_TYPE_MISMATCH,
398 reinterpret_cast<CMPIString*>(new CMPI_Object(msg)));
399 }
400 }
|
401 ms.aruran 1.25 PEG_METHOD_EXIT();
|
402 venkat.puvvada 1.24 CMReturn(CMPI_RC_ERR_NO_SUCH_PROPERTY);
403 }
404
405 PEGASUS_STATIC CMPICount arrayGetSize(
406 const CMPIArray* eArray,
407 CMPIStatus* rc)
408 {
|
409 kavita.gupta 1.34 CMPI_Array *arr = (CMPI_Array*)eArray->hdl;
410 if (!arr)
411 {
412 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
413 return 0;
414 }
415 CMPIData *dta = (CMPIData*)arr->hdl;
|
416 venkat.puvvada 1.24 if (!dta)
417 {
418 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
419 return 0;
420 }
421 CMSetStatus(rc,CMPI_RC_OK);
422 return dta->value.uint32;
423 }
424
425 PEGASUS_STATIC CMPIType arrayGetType(
426 const CMPIArray* eArray,
427 CMPIStatus* rc)
428 {
|
429 kavita.gupta 1.34 CMPI_Array *arr = (CMPI_Array*)eArray->hdl;
430 if (!arr)
431 {
432 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
433 return 0;
434 }
435 CMPIData *dta = (CMPIData*)arr->hdl;
|
436 venkat.puvvada 1.24 if (!dta)
437 {
438 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
439 return CMPI_null;
440 }
441 CMSetStatus(rc,CMPI_RC_OK);
442 return dta->type;
443 }
444 }
|
445 schuur 1.1
|
446 venkat.puvvada 1.24 static CMPIArrayFT array_FT =
447 {
448 CMPICurrentVersion,
449 arrayRelease,
450 arrayClone,
451 arrayGetSize,
452 arrayGetType,
453 arrayGetElementAt,
454 arraySetElementAt,
|
455 schuur 1.1 };
456
|
457 venkat.puvvada 1.24 CMPIArrayFT *CMPI_Array_Ftab = &array_FT;
|
458 schuur 1.1
459 PEGASUS_NAMESPACE_END
|
Return to
CMPI_Array.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI