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 ms.aruran 1.25 #include <Pegasus/Common/Tracer.h>
|
37 konrad.r 1.16 #include <string.h>
38
|
39 schuur 1.1 PEGASUS_USING_STD;
40 PEGASUS_NAMESPACE_BEGIN
41
|
42 venkat.puvvada 1.24 extern "C"
43 {
|
44 schuur 1.9
|
45 venkat.puvvada 1.24 PEGASUS_STATIC CMPIStatus arrayRelease(CMPIArray* eArray)
46 {
|
47 ms.aruran 1.25 PEG_METHOD_ENTER(
48 TRC_CMPIPROVIDERINTERFACE,
49 "CMPI_Array:arrayRelease()");
50
|
51 venkat.puvvada 1.24 CMPIData *dta = (CMPIData*)eArray->hdl;
52 if (dta)
53 {
54 delete[] dta;
55 reinterpret_cast<CMPI_Object*>(eArray)->unlinkAndDelete();
|
56 ms.aruran 1.25 PEG_METHOD_EXIT();
|
57 schuur 1.9 CMReturn(CMPI_RC_OK);
|
58 venkat.puvvada 1.24 }
|
59 ms.aruran 1.25 PEG_METHOD_EXIT();
|
60 venkat.puvvada 1.24 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
61 }
62
63 PEGASUS_STATIC CMPIArray* arrayClone(
64 const CMPIArray* eArray,
65 CMPIStatus* rc)
66 {
|
67 ms.aruran 1.25 PEG_METHOD_ENTER(
68 TRC_CMPIPROVIDERINTERFACE,
69 "CMPI_Array:arrayClone()");
|
70 venkat.puvvada 1.24 CMPIData* dta=(CMPIData*)eArray->hdl;
71
72 if (!dta)
73 {
74 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
|
75 ms.aruran 1.25 PEG_METHOD_EXIT();
|
76 venkat.puvvada 1.24 return NULL;
77 }
78 CMPIData* nDta = new CMPIData[dta->value.uint32+1];
79 CMPI_Object* obj = new CMPI_Object(nDta);
80 obj->unlink();
81 CMPIArray* nArray = reinterpret_cast<CMPIArray*>(obj);
82 CMPIStatus rrc = {CMPI_RC_OK,NULL};
83
84 if (dta->type & CMPI_ENC)
85 {
86 for (unsigned int i=1; i<=dta->value.uint32; i++)
87 {
88 nDta[i].state=CMPI_nullValue;
89 }
90 }
91
92 for (unsigned int i=0; i<=dta->value.uint32; i++)
93 {
94 nDta[i]=dta[i];
95 if (i == 0)
96 {
97 venkat.puvvada 1.24 continue;
98 }
99 if (dta->type & CMPI_ENC && dta[i].state==CMPI_goodValue)
100 {
101 if ((dta[i].type == CMPI_instance) && (dta[i].value.inst))
102 {
103 nDta[i].value.inst =
104 (dta[i].value.inst)->ft->clone(dta[i].value.inst,&rrc);
105 }
106 if ((dta[i].type == CMPI_ref) && (dta[i].value.ref))
107 {
108 nDta[i].value.ref =
109 (dta[i].value.ref)->ft->clone(dta[i].value.ref,&rrc);
110 }
111 if ((dta[i].type == CMPI_args) && (dta[i].value.args))
112 {
113 nDta[i].value.args =
114 (dta[i].value.args)->ft->clone(dta[i].value.args,&rrc);
115 }
116 if ((dta[i].type == CMPI_dateTime) && (dta[i].value.dateTime))
117 {
118 venkat.puvvada 1.24 nDta[i].value.dateTime =
119 (dta[i].value.dateTime)->ft->clone(
120 dta[i].value.dateTime,
121 &rrc);
122 }
123 if ((dta[i].type == CMPI_enumeration) && (dta[i].value.Enum))
124 {
125 nDta[i].value.Enum =
126 (dta[i].value.Enum)->ft->clone(dta[i].value.Enum,&rrc);
127 }
128 if ((dta[i].type == CMPI_filter) && (dta[i].value.filter))
129 {
130 nDta[i].value.filter =
131 (dta[i].value.filter)->ft->clone(
132 dta[i].value.filter,
133 &rrc);
134 }
135 if ((dta[i].type == CMPI_charsptr) &&
136 (dta[i].value.dataPtr.length>0))
137 {
138 nDta[i].value.dataPtr.length = dta[i].value.dataPtr.length;
139 venkat.puvvada 1.24 nDta[i].value.dataPtr.ptr =
140 malloc(nDta[i].value.dataPtr.length);
141 if (nDta[i].value.dataPtr.ptr == NULL)
142 {
143 arrayRelease(nArray);
144 if (rc)
145 {
146 *rc=rrc;
147 }
148 return NULL;
149 }
150 memcpy(
151 nDta[i].value.dataPtr.ptr,
152 dta[i].value.dataPtr.ptr,
153 dta[i].value.dataPtr.length);
154 }
155
156 if ((dta[i].type == CMPI_string) && (dta[i].value.string))
157 {
158 nDta[i].value.string =
159 (dta[i].value.string)->ft->clone(
160 venkat.puvvada 1.24 dta[i].value.string,
161 &rrc);
162 }
163 if (rrc.rc)
164 {
165 arrayRelease(nArray);
166 if (rc)
167 {
168 *rc=rrc;
169 }
|
170 ms.aruran 1.25 PEG_METHOD_EXIT();
|
171 venkat.puvvada 1.24 return NULL;
172 }
173 }
174 }
175 CMSetStatus(rc,CMPI_RC_OK);
|
176 ms.aruran 1.25 PEG_METHOD_EXIT();
|
177 venkat.puvvada 1.24 return nArray;
178 }
179
180 PEGASUS_STATIC CMPIData arrayGetElementAt(
181 const CMPIArray* eArray,
182 CMPICount pos,
183 CMPIStatus* rc)
184 {
185 CMPIData *dta = (CMPIData*)eArray->hdl;
186 CMPIData data = {0,CMPI_nullValue,{0}};
187 if (!dta)
188 {
189 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
190 return data;
191 }
192 CMSetStatus(rc,CMPI_RC_OK);
193 if (pos < dta->value.uint32)
194 {
|
195 ouyang.jian 1.31 if (dta->type == CMPI_chars && dta[pos+1].state == CMPI_goodValue)
|
196 marek 1.29 {
197 data.type = CMPI_chars;
198 data.state = CMPI_goodValue;
|
199 s.kodali 1.30 data.value.chars = (char*)CMGetCharsPtr(
200 dta[pos+1].value.string,
201 NULL);
|
202 marek 1.29 return data;
203 }
204 else
205 {
206 return dta[pos+1];
207 }
|
208 venkat.puvvada 1.24 }
209 CMSetStatus(rc,CMPI_RC_ERR_NO_SUCH_PROPERTY);
210 return data;
211 }
212
213 CMPIStatus arraySetElementAt(
214 CMPIArray* eArray,
215 CMPICount pos,
216 const CMPIValue *val,
217 CMPIType type)
218 {
|
219 ms.aruran 1.25 PEG_METHOD_ENTER(
220 TRC_CMPIPROVIDERINTERFACE,
221 "CMPI_Array:arraySetElementAt()");
|
222 venkat.puvvada 1.24 CMPIData *dta = (CMPIData*)eArray->hdl;
223 if (!dta)
224 {
|
225 ms.aruran 1.25 PEG_METHOD_EXIT();
|
226 venkat.puvvada 1.24 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
227 }
228 if (!val)
229 {
|
230 ms.aruran 1.25 PEG_METHOD_EXIT();
|
231 venkat.puvvada 1.24 CMReturn( CMPI_RC_ERR_INVALID_PARAMETER);
232 }
233 if (pos<dta->value.uint32)
234 {
235 if ((dta->type&~CMPI_ARRAY)==type)
236 {
237 dta[pos+1].state=CMPI_goodValue;
|
238 kumpf 1.27 if (type == CMPI_chars)
239 {
|
240 marek 1.29 // Store char* as CMPIString internally, this frees us from
241 // doing explicit memory management for char*.
242 dta[pos+1].value.string = reinterpret_cast<CMPIString*>(
243 new CMPI_Object((const char*) val));
244 dta[pos+1].type = CMPI_string;
|
245 kumpf 1.27 }
246 else
247 {
248 dta[pos+1].value = *val;
249 }
|
250 ms.aruran 1.25 PEG_METHOD_EXIT();
|
251 venkat.puvvada 1.24 CMReturn(CMPI_RC_OK);
252 }
253 else
254 {
255 char msg[512];
256 sprintf(msg,"arraySetElementAt(): CMPI_RC_ERR_TYPE_MISMATCH."
|
257 kavita.gupta 1.26 " Is %u - should be %u",
|
258 kumpf 1.28 (unsigned int)type, (unsigned int)dta->type);
|
259 ms.aruran 1.25 PEG_METHOD_EXIT();
|
260 venkat.puvvada 1.24 CMReturnWithString(
261 CMPI_RC_ERR_TYPE_MISMATCH,
262 reinterpret_cast<CMPIString*>(new CMPI_Object(msg)));
263 }
264 }
|
265 ms.aruran 1.25 PEG_METHOD_EXIT();
|
266 venkat.puvvada 1.24 CMReturn(CMPI_RC_ERR_NO_SUCH_PROPERTY);
267 }
268
269 PEGASUS_STATIC CMPICount arrayGetSize(
270 const CMPIArray* eArray,
271 CMPIStatus* rc)
272 {
273 CMPIData *dta = (CMPIData*)eArray->hdl;
274 if (!dta)
275 {
276 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
277 return 0;
278 }
279 CMSetStatus(rc,CMPI_RC_OK);
280 return dta->value.uint32;
281 }
282
283 PEGASUS_STATIC CMPIType arrayGetType(
284 const CMPIArray* eArray,
285 CMPIStatus* rc)
286 {
287 venkat.puvvada 1.24 CMPIData *dta = (CMPIData*)eArray->hdl;
288 if (!dta)
289 {
290 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
291 return CMPI_null;
292 }
293 CMSetStatus(rc,CMPI_RC_OK);
294 return dta->type;
295 }
296 }
|
297 schuur 1.1
|
298 venkat.puvvada 1.24 static CMPIArrayFT array_FT =
299 {
300 CMPICurrentVersion,
301 arrayRelease,
302 arrayClone,
303 arrayGetSize,
304 arrayGetType,
305 arrayGetElementAt,
306 arraySetElementAt,
|
307 schuur 1.1 };
308
|
309 venkat.puvvada 1.24 CMPIArrayFT *CMPI_Array_Ftab = &array_FT;
|
310 schuur 1.1
311 PEGASUS_NAMESPACE_END
312
313
314
315
|
Return to
CMPI_Array.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI