1 karl 1.66 //%2006////////////////////////////////////////////////////////////////////////
|
2 mike 1.11 //
|
3 karl 1.50 // 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 karl 1.45 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.50 // 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.53 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.66 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 mike 1.11 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
|
15 mike 1.12 // 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 mike 1.11 // 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 kumpf 1.33 //
|
21 mike 1.12 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
|
22 mike 1.11 // 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 mike 1.12 // 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 mike 1.11 // 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 schuur 1.49 //
|
32 mike 1.11 // Author: Mike Brasher (mbrasher@bmc.com)
33 //
|
34 mike 1.12 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
|
35 karl 1.13 // Karl Schopmeyer, (k.schopmeyer@opengroup.org)
|
36 kumpf 1.36 // Carol Ann Krug Graves, Hewlett-Packard Company
|
37 david.dillard 1.52 // (carolann_graves@hp.com)
|
38 schuur 1.49 // Adriann Schuur (schuur@de.ibm.com) PEP 164
|
39 dave.sudlik 1.51 // Dave Sudlik, IBM (dsudlik@us.ibm.com)
|
40 david.dillard 1.52 // David Dillard, VERITAS Software Corp.
41 // (david.dillard@veritas.com)
|
42 mike 1.62 // Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
|
43 mike 1.11 //
44 //%/////////////////////////////////////////////////////////////////////////////
45
46 #include <cstring>
47 #include <cstdio>
48 #include <cctype>
49 #include "CIMValue.h"
|
50 kumpf 1.26 #include "Union.h"
|
51 mike 1.11 #include "Indentor.h"
52 #include "XmlWriter.h"
|
53 david 1.44 #include "CommonUTF.h"
|
54 schuur 1.49 #include "CIMValueRep.h"
|
55 mike 1.62 #include "Config.h"
56 #include "CIMType.h"
57 #include "String.h"
58 #include "CIMDateTime.h"
59 #include "CIMObjectPath.h"
60 #include "CIMObject.h"
61 #include "Array.h"
|
62 jim.wunderlich 1.63 #include <Pegasus/Common/PegasusAssert.h>
|
63 mike 1.62
|
64 mike 1.11 PEGASUS_NAMESPACE_BEGIN
65
66 #define PEGASUS_ARRAY_T CIMValue
67 # include "ArrayImpl.h"
68 #undef PEGASUS_ARRAY_T
69
|
70 mike 1.62 // ATTN: By getting a CIMObject from a CIMValue, the client of CIMValue can
71 // modify the internals of that CIMObject and thus change what CIMValue
72 // itself refers to. There are two solutions: clone() at ever juncture or
73 // force CIMValue to make its own unique copy when the client calls get()
74 // to get a CIMObject.
|
75 a.arora 1.48
|
76 mike 1.62 //==============================================================================
|
77 mike 1.11 //
|
78 mike 1.62 // _toString() routines:
|
79 mike 1.11 //
|
80 mike 1.62 //==============================================================================
|
81 mike 1.11
|
82 mike 1.60 inline void _toString(Buffer& out, Boolean x)
|
83 mike 1.11 {
|
84 kumpf 1.29 XmlWriter::append(out, x);
|
85 mike 1.11 }
86
|
87 mike 1.62 inline void _toString(Buffer& out, Uint8 x)
88 {
89 XmlWriter::append(out, Uint32(x));
90 }
91
92 inline void _toString(Buffer& out, Sint8 x)
93 {
94 XmlWriter::append(out, Sint32(x));
95 }
96
97 inline void _toString(Buffer& out, Uint16 x)
98 {
99 XmlWriter::append(out, Uint32(x));
100 }
101
102 inline void _toString(Buffer& out, Sint16 x)
103 {
104 XmlWriter::append(out, Sint32(x));
105 }
106
107 inline void _toString(Buffer& out, Uint32 x)
108 mike 1.62 {
109 XmlWriter::append(out, x);
110 }
111
112 inline void _toString(Buffer& out, Sint32 x)
113 {
114 XmlWriter::append(out, x);
115 }
116
117 inline void _toString(Buffer& out, Uint64 x)
118 {
119 XmlWriter::append(out, x);
120 }
121
122 inline void _toString(Buffer& out, Sint64 x)
123 {
124 XmlWriter::append(out, x);
125 }
126
127 inline void _toString(Buffer& out, Real32 x)
128 {
129 mike 1.62 XmlWriter::append(out, Real64(x));
130 }
131
132 inline void _toString(Buffer& out, Real64 x)
133 {
134 XmlWriter::append(out, x);
135 }
|
136 kumpf 1.22
|
137 mike 1.60 inline void _toString(Buffer& out, Char16 x)
|
138 mike 1.12 {
|
139 david 1.44 // We need to convert the Char16 to UTF8 then append the UTF8
140 // character into the array.
141 // NOTE: The UTF8 character could be several bytes long.
142 // WARNING: This function will put in replacement character for
143 // all characters that have surogate pairs.
144
145 char str[6];
146 memset(str,0x00,sizeof(str));
147 char* charIN = (char *)&x;
148
149 const Uint16 *strsrc = (Uint16 *)charIN;
150 Uint16 *endsrc = (Uint16 *)&charIN[1];
151
152 Uint8 *strtgt = (Uint8 *)str;
153 Uint8 *endtgt = (Uint8 *)&str[5];
154
|
155 mike 1.62 UTF16toUTF8(&strsrc, endsrc, &strtgt, endtgt);
|
156 david.dillard 1.52 out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1);
|
157 mike 1.12 }
158
|
159 mike 1.60 inline void _toString(Buffer& out, const String& x)
|
160 mike 1.12 {
161 out << x;
162 }
|
163 mike 1.11
|
164 mike 1.60 inline void _toString(Buffer& out, const CIMDateTime& x)
|
165 mike 1.11 {
|
166 kumpf 1.38 out << x.toString();
|
167 mike 1.11 }
168
|
169 mike 1.60 inline void _toString(Buffer& out, const CIMObjectPath& x)
|
170 kumpf 1.15 {
171 out << x.toString();
172 }
173
|
174 mike 1.60 inline void _toString(Buffer& out, const CIMObject& x)
|
175 dave.sudlik 1.51 {
176 out << x.toString();
177 }
178
|
179 mike 1.12 template<class T>
|
180 mike 1.60 void _toString(Buffer& out, const T* p, Uint32 size)
|
181 mike 1.12 {
182 while (size--)
183 {
|
184 kumpf 1.26 _toString(out, *p++);
|
185 mike 1.61 out.append(' ');
|
186 mike 1.12 }
187 }
188
|
189 mike 1.62 //==============================================================================
190 //
191 // CIMValueRep
192 //
193 //==============================================================================
194
195 CIMValueRep CIMValueRep::_emptyRep((int*)0);
196
197 void CIMValueRep::release()
198 {
199 if (isArray)
200 {
201 switch (type)
202 {
203 case CIMTYPE_BOOLEAN:
204 CIMValueType<Boolean>::destructArray(this);
205 break;
206
207 case CIMTYPE_UINT8:
208 CIMValueType<Uint8>::destructArray(this);
209 break;
210 mike 1.62
211 case CIMTYPE_SINT8:
212 CIMValueType<Sint8>::destructArray(this);
213 break;
214
215 case CIMTYPE_UINT16:
216 CIMValueType<Uint16>::destructArray(this);
217 break;
218
219 case CIMTYPE_SINT16:
220 CIMValueType<Sint16>::destructArray(this);
221 break;
222
223 case CIMTYPE_UINT32:
224 CIMValueType<Uint32>::destructArray(this);
225 break;
226
227 case CIMTYPE_SINT32:
228 CIMValueType<Sint32>::destructArray(this);
229 break;
230
231 mike 1.62 case CIMTYPE_UINT64:
232 CIMValueType<Uint64>::destructArray(this);
233 break;
234
235 case CIMTYPE_SINT64:
236 CIMValueType<Sint64>::destructArray(this);
237 break;
238
239 case CIMTYPE_REAL32:
240 CIMValueType<Real32>::destructArray(this);
241 break;
242
243 case CIMTYPE_REAL64:
244 CIMValueType<Real64>::destructArray(this);
245 break;
246
247 case CIMTYPE_CHAR16:
248 CIMValueType<Char16>::destructArray(this);
249 break;
250
251 case CIMTYPE_STRING:
252 mike 1.62 CIMValueType<String>::destructArray(this);
253 break;
254
255 case CIMTYPE_DATETIME:
256 CIMValueType<CIMDateTime>::destructArray(this);
257 break;
258
259 case CIMTYPE_REFERENCE:
260 CIMValueType<CIMObjectPath>::destructArray(this);
261 break;
262
263 case CIMTYPE_OBJECT:
264 CIMValueType<CIMObject>::destructArray(this);
265 break;
266 }
267 }
268 else
269 {
270 switch (type)
271 {
272 case CIMTYPE_BOOLEAN:
273 mike 1.62 case CIMTYPE_UINT8:
274 case CIMTYPE_SINT8:
275 case CIMTYPE_UINT16:
276 case CIMTYPE_SINT16:
277 case CIMTYPE_UINT32:
278 case CIMTYPE_SINT32:
279 case CIMTYPE_UINT64:
280 case CIMTYPE_SINT64:
281 case CIMTYPE_REAL32:
282 case CIMTYPE_REAL64:
283 case CIMTYPE_CHAR16:
284 break;
|
285 mike 1.11
|
286 mike 1.62 case CIMTYPE_STRING:
287 CIMValueType<String>::destruct(this);
288 break;
289
290 case CIMTYPE_DATETIME:
291 CIMValueType<CIMDateTime>::destruct(this);
292 break;
293
294 case CIMTYPE_REFERENCE:
295 CIMValueType<CIMObjectPath>::destruct(this);
296 break;
297
298 case CIMTYPE_OBJECT:
299 CIMValueType<CIMObject>::destruct(this);
300 break;
301 }
302 }
303 }
304
305 //==============================================================================
|
306 mike 1.11 //
|
307 kumpf 1.26 // CIMValue
308 //
|
309 mike 1.62 //==============================================================================
|
310 mike 1.11
|
311 mike 1.62 static inline void _release(CIMValueRep*& rep)
|
312 kumpf 1.26 {
|
313 mike 1.62 if (rep->refs.get() == 1)
314 rep->release();
315 else
316 {
317 CIMValueRep::unref(rep);
318 rep = new CIMValueRep;
319 }
|
320 mike 1.11 }
321
|
322 a.arora 1.48 CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)
|
323 mike 1.11 {
|
324 mike 1.62 _rep = new CIMValueRep;
325
326 switch (type)
327 {
328 case CIMTYPE_BOOLEAN:
329 CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize);
330 break;
331
332 case CIMTYPE_UINT8:
333 CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize);
334 break;
335
336 case CIMTYPE_SINT8:
337 CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize);
338 break;
339
340 case CIMTYPE_UINT16:
341 CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize);
342 break;
343
344 case CIMTYPE_SINT16:
345 mike 1.62 CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize);
346 break;
347
348 case CIMTYPE_UINT32:
349 CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize);
350 break;
351
352 case CIMTYPE_SINT32:
353 CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize);
354 break;
355
356 case CIMTYPE_UINT64:
357 CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize);
358 break;
359
360 case CIMTYPE_SINT64:
361 CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize);
362 break;
363
364 case CIMTYPE_REAL32:
365 CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize);
366 mike 1.62 break;
367
368 case CIMTYPE_REAL64:
369 CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize);
370 break;
371
372 case CIMTYPE_CHAR16:
373 CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize);
374 break;
375
376 case CIMTYPE_STRING:
377 CIMValueType<String>::setNull(_rep, type, isArray, arraySize);
378 break;
379
380 case CIMTYPE_DATETIME:
381 CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize);
382 break;
383
384 case CIMTYPE_REFERENCE:
385 CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize);
386 break;
387 mike 1.62
388 case CIMTYPE_OBJECT:
389 CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize);
390 break;
391
392 default:
|
393 jim.wunderlich 1.63 PEGASUS_ASSERT(0);
|
394 mike 1.62 }
|
395 mike 1.11 }
396
|
397 a.arora 1.48 CIMValue::CIMValue(Boolean x)
|
398 mike 1.12 {
|
399 mike 1.62 _rep = new CIMValueRep;
400 CIMValueType<Boolean>::set(_rep, x);
|
401 mike 1.12 }
402
|
403 a.arora 1.48 CIMValue::CIMValue(Uint8 x)
|
404 mike 1.12 {
|
405 mike 1.62 _rep = new CIMValueRep;
406 CIMValueType<Uint8>::set(_rep, x);
|
407 mike 1.12 }
408
|
409 a.arora 1.48 CIMValue::CIMValue(Sint8 x)
|
410 mike 1.11 {
|
411 mike 1.62 _rep = new CIMValueRep;
412 CIMValueType<Sint8>::set(_rep, x);
|
413 mike 1.11 }
414
|
415 a.arora 1.48 CIMValue::CIMValue(Uint16 x)
|
416 mike 1.11 {
|
417 mike 1.62 _rep = new CIMValueRep;
418 CIMValueType<Uint16>::set(_rep, x);
|
419 mike 1.11 }
420
|
421 a.arora 1.48 CIMValue::CIMValue(Sint16 x)
|
422 mike 1.11 {
|
423 mike 1.62 _rep = new CIMValueRep;
424 CIMValueType<Sint16>::set(_rep, x);
|
425 mike 1.11 }
426
|
427 a.arora 1.48 CIMValue::CIMValue(Uint32 x)
|
428 mike 1.11 {
|
429 mike 1.62 _rep = new CIMValueRep;
430 CIMValueType<Uint32>::set(_rep, x);
|
431 mike 1.11 }
432
|
433 a.arora 1.48 CIMValue::CIMValue(Sint32 x)
|
434 mike 1.11 {
|
435 mike 1.62 _rep = new CIMValueRep;
436 CIMValueType<Sint32>::set(_rep, x);
|
437 mike 1.11 }
438
|
439 a.arora 1.48 CIMValue::CIMValue(Uint64 x)
|
440 mike 1.11 {
|
441 mike 1.62 _rep = new CIMValueRep;
442 CIMValueType<Uint64>::set(_rep, x);
|
443 mike 1.11 }
444
|
445 a.arora 1.48 CIMValue::CIMValue(Sint64 x)
|
446 mike 1.11 {
|
447 mike 1.62 _rep = new CIMValueRep;
448 CIMValueType<Sint64>::set(_rep, x);
|
449 mike 1.11 }
450
|
451 a.arora 1.48 CIMValue::CIMValue(Real32 x)
|
452 mike 1.11 {
|
453 mike 1.62 _rep = new CIMValueRep;
454 CIMValueType<Real32>::set(_rep, x);
|
455 mike 1.11 }
456
|
457 a.arora 1.48 CIMValue::CIMValue(Real64 x)
|
458 mike 1.11 {
|
459 mike 1.62 _rep = new CIMValueRep;
460 CIMValueType<Real64>::set(_rep, x);
|
461 mike 1.11 }
462
|
463 a.arora 1.48 CIMValue::CIMValue(const Char16& x)
|
464 mike 1.11 {
|
465 mike 1.62 _rep = new CIMValueRep;
466 CIMValueType<Char16>::set(_rep, x);
|
467 mike 1.11 }
468
|
469 a.arora 1.48 CIMValue::CIMValue(const String& x)
|
470 mike 1.11 {
|
471 mike 1.62 _rep = new CIMValueRep;
472 CIMValueType<String>::set(_rep, x);
|
473 mike 1.11 }
474
|
475 a.arora 1.48 CIMValue::CIMValue(const CIMDateTime& x)
|
476 mike 1.11 {
|
477 mike 1.62 _rep = new CIMValueRep;
478 CIMValueType<CIMDateTime>::set(_rep, x);
|
479 mike 1.11 }
480
|
481 a.arora 1.48 CIMValue::CIMValue(const CIMObjectPath& x)
|
482 mike 1.11 {
|
483 mike 1.62 _rep = new CIMValueRep;
484 CIMValueType<CIMObjectPath>::set(_rep, x);
|
485 mike 1.11 }
486
|
487 dave.sudlik 1.51 CIMValue::CIMValue(const CIMObject& x)
488 {
|
489 mike 1.62 if (x.isUninitialized())
490 {
491 // Bug 3373, throw exception if uninitialized object is passed to set().
492 throw UninitializedObjectException();
493 }
|
494 kumpf 1.59
|
495 mike 1.62 _rep = new CIMValueRep;
496 CIMValueType<CIMObject>::set(_rep, x.clone());
|
497 dave.sudlik 1.51 }
498
|
499 a.arora 1.48 CIMValue::CIMValue(const Array<Boolean>& x)
|
500 mike 1.12 {
|
501 mike 1.62 _rep = new CIMValueRep;
502 CIMValueType<Boolean>::setArray(_rep, x);
|
503 mike 1.11 }
504
|
505 a.arora 1.48 CIMValue::CIMValue(const Array<Uint8>& x)
|
506 mike 1.11 {
|
507 mike 1.62 _rep = new CIMValueRep;
508 CIMValueType<Uint8>::setArray(_rep, x);
|
509 mike 1.11 }
510
|
511 a.arora 1.48 CIMValue::CIMValue(const Array<Sint8>& x)
|
512 mike 1.11 {
|
513 mike 1.62 _rep = new CIMValueRep;
514 CIMValueType<Sint8>::setArray(_rep, x);
|
515 mike 1.11 }
516
|
517 a.arora 1.48 CIMValue::CIMValue(const Array<Uint16>& x)
|
518 mike 1.11 {
|
519 mike 1.62 _rep = new CIMValueRep;
520 CIMValueType<Uint16>::setArray(_rep, x);
|
521 mike 1.11 }
522
|
523 a.arora 1.48 CIMValue::CIMValue(const Array<Sint16>& x)
|
524 mike 1.11 {
|
525 mike 1.62 _rep = new CIMValueRep;
526 CIMValueType<Sint16>::setArray(_rep, x);
|
527 mike 1.11 }
528
|
529 a.arora 1.48 CIMValue::CIMValue(const Array<Uint32>& x)
|
530 mike 1.11 {
|
531 mike 1.62 _rep = new CIMValueRep;
532 CIMValueType<Uint32>::setArray(_rep, x);
|
533 mike 1.11 }
534
|
535 a.arora 1.48 CIMValue::CIMValue(const Array<Sint32>& x)
|
536 mike 1.11 {
|
537 mike 1.62 _rep = new CIMValueRep;
538 CIMValueType<Sint32>::setArray(_rep, x);
|
539 mike 1.11 }
540
|
541 a.arora 1.48 CIMValue::CIMValue(const Array<Uint64>& x)
|
542 mike 1.11 {
|
543 mike 1.62 _rep = new CIMValueRep;
544 CIMValueType<Uint64>::setArray(_rep, x);
|
545 mike 1.11 }
546
|
547 a.arora 1.48 CIMValue::CIMValue(const Array<Sint64>& x)
|
548 mike 1.11 {
|
549 mike 1.62 _rep = new CIMValueRep;
550 CIMValueType<Sint64>::setArray(_rep, x);
|
551 mike 1.11 }
552
|
553 a.arora 1.48 CIMValue::CIMValue(const Array<Real32>& x)
|
554 mike 1.11 {
|
555 mike 1.62 _rep = new CIMValueRep;
556 CIMValueType<Real32>::setArray(_rep, x);
|
557 mike 1.11 }
558
|
559 a.arora 1.48 CIMValue::CIMValue(const Array<Real64>& x)
|
560 mike 1.11 {
|
561 mike 1.62 _rep = new CIMValueRep;
562 CIMValueType<Real64>::setArray(_rep, x);
|
563 mike 1.11 }
564
|
565 a.arora 1.48 CIMValue::CIMValue(const Array<Char16>& x)
|
566 mike 1.11 {
|
567 mike 1.62 _rep = new CIMValueRep;
568 CIMValueType<Char16>::setArray(_rep, x);
|
569 mike 1.11 }
570
|
571 a.arora 1.48 CIMValue::CIMValue(const Array<String>& x)
|
572 mike 1.11 {
|
573 mike 1.62 _rep = new CIMValueRep;
574 CIMValueType<String>::setArray(_rep, x);
|
575 mike 1.11 }
576
|
577 a.arora 1.48 CIMValue::CIMValue(const Array<CIMDateTime>& x)
|
578 mike 1.11 {
|
579 mike 1.62 _rep = new CIMValueRep;
580 CIMValueType<CIMDateTime>::setArray(_rep, x);
|
581 mike 1.11 }
582
|
583 a.arora 1.48 CIMValue::CIMValue(const Array<CIMObjectPath>& x)
|
584 mike 1.11 {
|
585 mike 1.62 _rep = new CIMValueRep;
586 CIMValueType<CIMObjectPath>::setArray(_rep, x);
|
587 mike 1.11 }
588
|
589 dave.sudlik 1.51 CIMValue::CIMValue(const Array<CIMObject>& x)
590 {
|
591 mike 1.62 Array<CIMObject> tmp;
|
592 kumpf 1.59
|
593 mike 1.62 for (Uint32 i = 0, n = x.size(); i < n; i++)
594 {
595 if (x[i].isUninitialized())
596 {
597 // Bug 3373, throw exception on uninitialized object.
598 _rep = &CIMValueRep::_emptyRep;
599 throw UninitializedObjectException();
600 }
|
601 kumpf 1.59
|
602 mike 1.62 tmp.append(x[i].clone());
603 }
|
604 dave.sudlik 1.51
|
605 mike 1.62 _rep = new CIMValueRep;
606 CIMValueType<CIMObject>::setArray(_rep, tmp);
|
607 mike 1.12 }
|
608 mike 1.11
|
609 mike 1.62 void CIMValue::clear()
|
610 mike 1.11 {
|
611 mike 1.62 CIMValueRep::unref(_rep);
612 _rep = &CIMValueRep::_emptyRep;
|
613 mike 1.11 }
614
|
615 kumpf 1.26 CIMValue& CIMValue::operator=(const CIMValue& x)
|
616 kumpf 1.15 {
|
617 mike 1.62 if (_rep != x._rep)
|
618 kumpf 1.26 {
|
619 mike 1.62 CIMValueRep::unref(_rep);
620 CIMValueRep::ref(_rep = x._rep);
|
621 kumpf 1.26 }
622
|
623 mike 1.62 return *this;
|
624 kumpf 1.26 }
625
|
626 mike 1.62 void CIMValue::assign(const CIMValue& x)
|
627 kumpf 1.26 {
|
628 mike 1.62 if (_rep != x._rep)
|
629 kumpf 1.26 {
|
630 mike 1.62 CIMValueRep::unref(_rep);
631 CIMValueRep::ref(_rep = x._rep);
|
632 kumpf 1.26 }
633 }
634
635 Boolean CIMValue::typeCompatible(const CIMValue& x) const
636 {
|
637 mike 1.62 return (_rep->type == x._rep->type && _rep->isArray == x._rep->isArray);
|
638 kumpf 1.26 }
639
640 Uint32 CIMValue::getArraySize() const
641 {
|
642 mike 1.62 if (!_rep->isArray)
|
643 kumpf 1.26 return 0;
644
|
645 mike 1.62 switch (_rep->type)
|
646 kumpf 1.26 {
|
647 kumpf 1.36 case CIMTYPE_BOOLEAN:
|
648 mike 1.62 return CIMValueType<Boolean>::arraySize(_rep);
|
649 kumpf 1.26
|
650 kumpf 1.36 case CIMTYPE_UINT8:
|
651 mike 1.62 return CIMValueType<Uint8>::arraySize(_rep);
|
652 kumpf 1.26
|
653 kumpf 1.36 case CIMTYPE_SINT8:
|
654 mike 1.62 return CIMValueType<Sint8>::arraySize(_rep);
|
655 kumpf 1.26
|
656 kumpf 1.36 case CIMTYPE_UINT16:
|
657 mike 1.62 return CIMValueType<Uint16>::arraySize(_rep);
|
658 kumpf 1.26
|
659 kumpf 1.36 case CIMTYPE_SINT16:
|
660 mike 1.62 return CIMValueType<Sint16>::arraySize(_rep);
|
661 kumpf 1.26
|
662 kumpf 1.36 case CIMTYPE_UINT32:
|
663 mike 1.62 return CIMValueType<Uint32>::arraySize(_rep);
|
664 kumpf 1.26
|
665 kumpf 1.36 case CIMTYPE_SINT32:
|
666 mike 1.62 return CIMValueType<Sint32>::arraySize(_rep);
|
667 kumpf 1.26
|
668 kumpf 1.36 case CIMTYPE_UINT64:
|
669 mike 1.62 return CIMValueType<Uint64>::arraySize(_rep);
|
670 kumpf 1.26
|
671 kumpf 1.36 case CIMTYPE_SINT64:
|
672 mike 1.62 return CIMValueType<Sint64>::arraySize(_rep);
|
673 kumpf 1.26
|
674 kumpf 1.36 case CIMTYPE_REAL32:
|
675 mike 1.62 return CIMValueType<Real32>::arraySize(_rep);
|
676 kumpf 1.26
|
677 kumpf 1.36 case CIMTYPE_REAL64:
|
678 mike 1.62 return CIMValueType<Real64>::arraySize(_rep);
|
679 kumpf 1.26
|
680 kumpf 1.36 case CIMTYPE_CHAR16:
|
681 mike 1.62 return CIMValueType<Char16>::arraySize(_rep);
|
682 kumpf 1.26
|
683 kumpf 1.36 case CIMTYPE_STRING:
|
684 mike 1.62 return CIMValueType<String>::arraySize(_rep);
|
685 kumpf 1.26
|
686 kumpf 1.36 case CIMTYPE_DATETIME:
|
687 mike 1.62 return CIMValueType<CIMDateTime>::arraySize(_rep);
|
688 kumpf 1.26
|
689 kumpf 1.36 case CIMTYPE_REFERENCE:
|
690 mike 1.62 return CIMValueType<CIMObjectPath>::arraySize(_rep);
|
691 kumpf 1.42
|
692 dave.sudlik 1.51 case CIMTYPE_OBJECT:
|
693 mike 1.62 return CIMValueType<CIMObject>::arraySize(_rep);
|
694 dave.sudlik 1.51
|
695 mike 1.62 default:
|
696 jim.wunderlich 1.63 PEGASUS_ASSERT(0);
|
697 kumpf 1.26 }
698
|
699 mike 1.62 return 0;
|
700 kumpf 1.26 }
701
702 void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)
703 {
|
704 mike 1.62 //
705 // Release any memory:
706 //
|
707 kumpf 1.26
|
708 mike 1.62 _release(_rep);
|
709 kumpf 1.26
|
710 mike 1.62 //
711 // Set the null value:
712 //
|
713 kumpf 1.26
|
714 mike 1.62 switch (type)
|
715 kumpf 1.26 {
|
716 mike 1.62 case CIMTYPE_BOOLEAN:
717 CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize);
718 break;
719
720 case CIMTYPE_UINT8:
721 CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize);
722 break;
723
724 case CIMTYPE_SINT8:
725 CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize);
726 break;
727
728 case CIMTYPE_UINT16:
729 CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize);
730 break;
731
732 case CIMTYPE_SINT16:
733 CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize);
734 break;
735
736 case CIMTYPE_UINT32:
737 mike 1.62 CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize);
738 break;
739
740 case CIMTYPE_SINT32:
741 CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize);
742 break;
743
744 case CIMTYPE_UINT64:
745 CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize);
746 break;
747
748 case CIMTYPE_SINT64:
749 CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize);
750 break;
751
752 case CIMTYPE_REAL32:
753 CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize);
754 break;
755
756 case CIMTYPE_REAL64:
757 CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize);
758 mike 1.62 break;
759
760 case CIMTYPE_CHAR16:
761 CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize);
762 break;
763
764 case CIMTYPE_STRING:
765 CIMValueType<String>::setNull(_rep, type, isArray, arraySize);
766 break;
767
768 case CIMTYPE_DATETIME:
769 CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize);
770 break;
771
772 case CIMTYPE_REFERENCE:
773 CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize);
774 break;
775
776 case CIMTYPE_OBJECT:
777 CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize);
778 break;
|
779 kumpf 1.26
|
780 mike 1.62 default:
|
781 jim.wunderlich 1.63 PEGASUS_ASSERT(0);
|
782 kumpf 1.26 }
783 }
784
785 void CIMValue::set(Boolean x)
786 {
|
787 mike 1.62 _release(_rep);
788 CIMValueType<Boolean>::set(_rep, x);
|
789 kumpf 1.26 }
790
791 void CIMValue::set(Uint8 x)
792 {
|
793 mike 1.62 _release(_rep);
794 CIMValueType<Uint8>::set(_rep, x);
|
795 kumpf 1.26 }
796
797 void CIMValue::set(Sint8 x)
798 {
|
799 mike 1.62 _release(_rep);
800 CIMValueType<Sint8>::set(_rep, x);
|
801 kumpf 1.26 }
802
803 void CIMValue::set(Uint16 x)
804 {
|
805 mike 1.62 _release(_rep);
806 CIMValueType<Uint16>::set(_rep, x);
|
807 kumpf 1.26 }
808
809 void CIMValue::set(Sint16 x)
810 {
|
811 mike 1.62 _release(_rep);
812 CIMValueType<Sint16>::set(_rep, x);
|
813 kumpf 1.26 }
814
815 void CIMValue::set(Uint32 x)
816 {
|
817 mike 1.62 _release(_rep);
818 CIMValueType<Uint32>::set(_rep, x);
|
819 kumpf 1.26 }
820
821 void CIMValue::set(Sint32 x)
822 {
|
823 mike 1.62 _release(_rep);
824 CIMValueType<Sint32>::set(_rep, x);
|
825 kumpf 1.26 }
826
827 void CIMValue::set(Uint64 x)
828 {
|
829 mike 1.62 _release(_rep);
830 CIMValueType<Uint64>::set(_rep, x);
|
831 kumpf 1.26 }
832
833 void CIMValue::set(Sint64 x)
834 {
|
835 mike 1.62 _release(_rep);
836 CIMValueType<Sint64>::set(_rep, x);
|
837 kumpf 1.26 }
838
839 void CIMValue::set(Real32 x)
840 {
|
841 mike 1.62 _release(_rep);
842 CIMValueType<Real32>::set(_rep, x);
|
843 kumpf 1.26 }
844
845 void CIMValue::set(Real64 x)
846 {
|
847 mike 1.62 _release(_rep);
848 CIMValueType<Real64>::set(_rep, x);
|
849 kumpf 1.26 }
850
851 void CIMValue::set(const Char16& x)
852 {
|
853 mike 1.62 _release(_rep);
854 CIMValueType<Char16>::set(_rep, x);
|
855 kumpf 1.26 }
856
857 void CIMValue::set(const String& x)
858 {
|
859 mike 1.62 _release(_rep);
860 CIMValueType<String>::set(_rep, x);
|
861 kumpf 1.26 }
862
863 void CIMValue::set(const CIMDateTime& x)
864 {
|
865 mike 1.62 _release(_rep);
866 CIMValueType<CIMDateTime>::set(_rep, x);
|
867 kumpf 1.26 }
868
|
869 kumpf 1.31 void CIMValue::set(const CIMObjectPath& x)
|
870 kumpf 1.26 {
|
871 mike 1.62 _release(_rep);
872 CIMValueType<CIMObjectPath>::set(_rep, x);
|
873 kumpf 1.26 }
874
|
875 dave.sudlik 1.51 void CIMValue::set(const CIMObject& x)
876 {
|
877 mike 1.62 if (x.isUninitialized())
878 {
879 // Bug 3373, throw exception on uninitialized object.
880 throw UninitializedObjectException();
881 }
882
883 _release(_rep);
884 CIMValueType<CIMObject>::set(_rep, x.clone());
|
885 dave.sudlik 1.51 }
886
|
887 kumpf 1.26 void CIMValue::set(const Array<Boolean>& x)
888 {
|
889 mike 1.62 _release(_rep);
890 CIMValueType<Boolean>::setArray(_rep, x);
|
891 kumpf 1.26 }
892
893 void CIMValue::set(const Array<Uint8>& x)
894 {
|
895 mike 1.62 _release(_rep);
896 CIMValueType<Uint8>::setArray(_rep, x);
|
897 kumpf 1.26 }
898
899 void CIMValue::set(const Array<Sint8>& x)
900 {
|
901 mike 1.62 _release(_rep);
902 CIMValueType<Sint8>::setArray(_rep, x);
|
903 kumpf 1.26 }
904
905 void CIMValue::set(const Array<Uint16>& x)
906 {
|
907 mike 1.62 _release(_rep);
908 CIMValueType<Uint16>::setArray(_rep, x);
|
909 kumpf 1.26 }
910
911 void CIMValue::set(const Array<Sint16>& x)
912 {
|
913 mike 1.62 _release(_rep);
914 CIMValueType<Sint16>::setArray(_rep, x);
|
915 kumpf 1.26 }
916
917 void CIMValue::set(const Array<Uint32>& x)
918 {
|
919 mike 1.62 _release(_rep);
920 CIMValueType<Uint32>::setArray(_rep, x);
|
921 kumpf 1.26 }
922
923 void CIMValue::set(const Array<Sint32>& x)
924 {
|
925 mike 1.62 _release(_rep);
926 CIMValueType<Sint32>::setArray(_rep, x);
|
927 kumpf 1.26 }
928
929 void CIMValue::set(const Array<Uint64>& x)
930 {
|
931 mike 1.62 _release(_rep);
932 CIMValueType<Uint64>::setArray(_rep, x);
|
933 kumpf 1.26 }
934
935 void CIMValue::set(const Array<Sint64>& x)
936 {
|
937 mike 1.62 _release(_rep);
938 CIMValueType<Sint64>::setArray(_rep, x);
|
939 kumpf 1.26 }
940
941 void CIMValue::set(const Array<Real32>& x)
942 {
|
943 mike 1.62 _release(_rep);
944 CIMValueType<Real32>::setArray(_rep, x);
|
945 kumpf 1.26 }
946
947 void CIMValue::set(const Array<Real64>& x)
948 {
|
949 mike 1.62 _release(_rep);
950 CIMValueType<Real64>::setArray(_rep, x);
|
951 kumpf 1.26 }
952
953 void CIMValue::set(const Array<Char16>& x)
954 {
|
955 mike 1.62 _release(_rep);
956 CIMValueType<Char16>::setArray(_rep, x);
|
957 kumpf 1.26 }
958
959 void CIMValue::set(const Array<String>& x)
960 {
|
961 mike 1.62 _release(_rep);
962 CIMValueType<String>::setArray(_rep, x);
|
963 kumpf 1.26 }
964
965 void CIMValue::set(const Array<CIMDateTime>& x)
966 {
|
967 mike 1.62 _release(_rep);
968 CIMValueType<CIMDateTime>::setArray(_rep, x);
|
969 kumpf 1.26 }
970
|
971 kumpf 1.31 void CIMValue::set(const Array<CIMObjectPath>& x)
|
972 kumpf 1.26 {
|
973 mike 1.62 _release(_rep);
974 CIMValueType<CIMObjectPath>::setArray(_rep, x);
|
975 kumpf 1.26 }
976
|
977 mike 1.62 void CIMValue::set(const Array<CIMObject>& a)
|
978 dave.sudlik 1.51 {
|
979 mike 1.62 Array<CIMObject> tmp;
|
980 carolann.graves 1.58
|
981 mike 1.62 for (Uint32 i = 0, n = a.size(); i < n; i++)
|
982 dave.sudlik 1.57 {
|
983 mike 1.62 if (a[i].isUninitialized())
984 {
985 // Bug 3373, throw exception on uninitialized object.
986 throw UninitializedObjectException();
987 }
|
988 carolann.graves 1.58
|
989 mike 1.62 tmp.append(a[i].clone());
|
990 dave.sudlik 1.57 }
|
991 carolann.graves 1.58
|
992 mike 1.62 _release(_rep);
993 CIMValueType<CIMObject>::setArray(_rep, tmp);
|
994 dave.sudlik 1.51 }
995
|
996 kumpf 1.26 void CIMValue::get(Boolean& x) const
997 {
|
998 mike 1.62 if (_rep->type != CIMTYPE_BOOLEAN || _rep->isArray)
|
999 kumpf 1.39 throw TypeMismatchException();
|
1000 kumpf 1.26
|
1001 mike 1.62 if (!_rep->isNull)
1002 x = CIMValueType<Boolean>::ref(_rep);
|
1003 kumpf 1.26 }
1004
1005 void CIMValue::get(Uint8& x) const
1006 {
|
1007 mike 1.62 if (_rep->type != CIMTYPE_UINT8 || _rep->isArray)
|
1008 kumpf 1.39 throw TypeMismatchException();
|
1009 kumpf 1.26
|
1010 mike 1.62 if (!_rep->isNull)
1011 x = CIMValueType<Uint8>::ref(_rep);
|
1012 kumpf 1.26 }
1013
1014 void CIMValue::get(Sint8& x) const
1015 {
|
1016 mike 1.62 if (_rep->type != CIMTYPE_SINT8 || _rep->isArray)
|
1017 kumpf 1.39 throw TypeMismatchException();
|
1018 kumpf 1.26
|
1019 mike 1.62 if (!_rep->isNull)
1020 x = CIMValueType<Sint8>::ref(_rep);
|
1021 kumpf 1.26 }
1022
1023 void CIMValue::get(Uint16& x) const
1024 {
|
1025 mike 1.62 if (_rep->type != CIMTYPE_UINT16 || _rep->isArray)
|
1026 kumpf 1.39 throw TypeMismatchException();
|
1027 kumpf 1.26
|
1028 mike 1.62 if (!_rep->isNull)
1029 x = CIMValueType<Uint16>::ref(_rep);
|
1030 kumpf 1.26 }
1031
1032 void CIMValue::get(Sint16& x) const
1033 {
|
1034 mike 1.62 if (_rep->type != CIMTYPE_SINT16 || _rep->isArray)
|
1035 kumpf 1.39 throw TypeMismatchException();
|
1036 kumpf 1.26
|
1037 mike 1.62 if (!_rep->isNull)
1038 x = CIMValueType<Sint16>::ref(_rep);
|
1039 kumpf 1.26 }
|
1040 mike 1.11
|
1041 mike 1.62
|
1042 mike 1.11 void CIMValue::get(Uint32& x) const
1043 {
|
1044 mike 1.62 if (_rep->type != CIMTYPE_UINT32 || _rep->isArray)
|
1045 kumpf 1.39 throw TypeMismatchException();
|
1046 mike 1.11
|
1047 mike 1.62 if (!_rep->isNull)
1048 x = CIMValueType<Uint32>::ref(_rep);
|
1049 mike 1.11 }
1050
1051 void CIMValue::get(Sint32& x) const
1052 {
|
1053 mike 1.62 if (_rep->type != CIMTYPE_SINT32 || _rep->isArray)
|
1054 kumpf 1.39 throw TypeMismatchException();
|
1055 mike 1.11
|
1056 mike 1.62 if (!_rep->isNull)
1057 x = CIMValueType<Sint32>::ref(_rep);
|
1058 mike 1.11 }
1059
1060 void CIMValue::get(Uint64& x) const
1061 {
|
1062 mike 1.62 if (_rep->type != CIMTYPE_UINT64 || _rep->isArray)
|
1063 kumpf 1.39 throw TypeMismatchException();
|
1064 mike 1.11
|
1065 mike 1.62 if (!_rep->isNull)
1066 x = CIMValueType<Uint64>::ref(_rep);
|
1067 mike 1.11 }
1068
1069 void CIMValue::get(Sint64& x) const
1070 {
|
1071 mike 1.62 if (_rep->type != CIMTYPE_SINT64 || _rep->isArray)
|
1072 kumpf 1.39 throw TypeMismatchException();
|
1073 mike 1.11
|
1074 mike 1.62 if (!_rep->isNull)
1075 x = CIMValueType<Sint64>::ref(_rep);
|
1076 mike 1.11 }
1077
1078 void CIMValue::get(Real32& x) const
1079 {
|
1080 mike 1.62 if (_rep->type != CIMTYPE_REAL32 || _rep->isArray)
|
1081 kumpf 1.39 throw TypeMismatchException();
|
1082 mike 1.11
|
1083 mike 1.62 if (!_rep->isNull)
1084 x = CIMValueType<Real32>::ref(_rep);
|
1085 mike 1.11 }
1086
1087 void CIMValue::get(Real64& x) const
1088 {
|
1089 mike 1.62 if (_rep->type != CIMTYPE_REAL64 || _rep->isArray)
|
1090 kumpf 1.39 throw TypeMismatchException();
|
1091 mike 1.11
|
1092 mike 1.62 if (!_rep->isNull)
1093 x = CIMValueType<Real64>::ref(_rep);
|
1094 mike 1.11 }
1095
1096 void CIMValue::get(Char16& x) const
1097 {
|
1098 mike 1.62 if (_rep->type != CIMTYPE_CHAR16 || _rep->isArray)
|
1099 kumpf 1.39 throw TypeMismatchException();
|
1100 mike 1.11
|
1101 mike 1.62 if (!_rep->isNull)
1102 x = CIMValueType<Char16>::ref(_rep);
|
1103 mike 1.11 }
1104
1105 void CIMValue::get(String& x) const
1106 {
|
1107 mike 1.62 if (_rep->type != CIMTYPE_STRING || _rep->isArray)
|
1108 kumpf 1.39 throw TypeMismatchException();
|
1109 mike 1.11
|
1110 mike 1.62 if (!_rep->isNull)
1111 x = CIMValueType<String>::ref(_rep);
|
1112 mike 1.11 }
1113
1114 void CIMValue::get(CIMDateTime& x) const
1115 {
|
1116 mike 1.62 if (_rep->type != CIMTYPE_DATETIME || _rep->isArray)
|
1117 kumpf 1.39 throw TypeMismatchException();
|
1118 mike 1.11
|
1119 mike 1.62 if (!_rep->isNull)
1120 x = CIMValueType<CIMDateTime>::ref(_rep);
|
1121 mike 1.11 }
1122
|
1123 kumpf 1.31 void CIMValue::get(CIMObjectPath& x) const
|
1124 mike 1.11 {
|
1125 mike 1.62 if (_rep->type != CIMTYPE_REFERENCE || _rep->isArray)
|
1126 kumpf 1.39 throw TypeMismatchException();
|
1127 mike 1.11
|
1128 mike 1.62 if (!_rep->isNull)
1129 x = CIMValueType<CIMObjectPath>::ref(_rep);
|
1130 mike 1.11 }
1131
|
1132 dave.sudlik 1.51 void CIMValue::get(CIMObject& x) const
1133 {
|
1134 mike 1.62 if (_rep->type != CIMTYPE_OBJECT || _rep->isArray)
|
1135 dave.sudlik 1.51 throw TypeMismatchException();
1136
|
1137 mike 1.62 if (!_rep->isNull)
|
1138 dave.sudlik 1.65 // We have to clone our own unique copy since we are about to
1139 // return an object to the caller that he can modify; thereby,
1140 // changing the one we refer to as well.
|
1141 mike 1.64 x = CIMValueType<CIMObject>::ref(_rep).clone();
|
1142 dave.sudlik 1.51 }
1143
|
1144 mike 1.11 void CIMValue::get(Array<Boolean>& x) const
1145 {
|
1146 mike 1.62 if (_rep->type != CIMTYPE_BOOLEAN || !_rep->isArray)
|
1147 kumpf 1.39 throw TypeMismatchException();
|
1148 mike 1.11
|
1149 mike 1.62 if (!_rep->isNull)
1150 x = CIMValueType<Boolean>::aref(_rep);
|
1151 mike 1.11 }
1152
1153 void CIMValue::get(Array<Uint8>& x) const
1154 {
|
1155 mike 1.62 if (_rep->type != CIMTYPE_UINT8 || !_rep->isArray)
|
1156 kumpf 1.39 throw TypeMismatchException();
|
1157 mike 1.11
|
1158 mike 1.62 if (!_rep->isNull)
1159 x = CIMValueType<Uint8>::aref(_rep);
|
1160 mike 1.11 }
1161
1162 void CIMValue::get(Array<Sint8>& x) const
1163 {
|
1164 mike 1.62 if (_rep->type != CIMTYPE_SINT8 || !_rep->isArray)
|
1165 kumpf 1.39 throw TypeMismatchException();
|
1166 mike 1.11
|
1167 mike 1.62 if (!_rep->isNull)
1168 x = CIMValueType<Sint8>::aref(_rep);
|
1169 mike 1.11 }
1170
1171 void CIMValue::get(Array<Uint16>& x) const
1172 {
|
1173 mike 1.62 if (_rep->type != CIMTYPE_UINT16 || !_rep->isArray)
|
1174 kumpf 1.39 throw TypeMismatchException();
|
1175 mike 1.11
|
1176 mike 1.62 if (!_rep->isNull)
1177 x = CIMValueType<Uint16>::aref(_rep);
|
1178 mike 1.11 }
1179
1180 void CIMValue::get(Array<Sint16>& x) const
1181 {
|
1182 mike 1.62 if (_rep->type != CIMTYPE_SINT16 || !_rep->isArray)
|
1183 kumpf 1.39 throw TypeMismatchException();
|
1184 mike 1.11
|
1185 mike 1.62 if (!_rep->isNull)
1186 x = CIMValueType<Sint16>::aref(_rep);
|
1187 mike 1.11 }
1188
1189 void CIMValue::get(Array<Uint32>& x) const
1190 {
|
1191 mike 1.62 if (_rep->type != CIMTYPE_UINT32 || !_rep->isArray)
|
1192 kumpf 1.39 throw TypeMismatchException();
|
1193 mike 1.11
|
1194 mike 1.62 if (!_rep->isNull)
1195 x = CIMValueType<Uint32>::aref(_rep);
|
1196 mike 1.11 }
1197
1198 void CIMValue::get(Array<Sint32>& x) const
1199 {
|
1200 mike 1.62 if (_rep->type != CIMTYPE_SINT32 || !_rep->isArray)
|
1201 kumpf 1.39 throw TypeMismatchException();
|
1202 mike 1.11
|
1203 mike 1.62 if (!_rep->isNull)
1204 x = CIMValueType<Sint32>::aref(_rep);
|
1205 mike 1.11 }
1206
1207 void CIMValue::get(Array<Uint64>& x) const
1208 {
|
1209 mike 1.62 if (_rep->type != CIMTYPE_UINT64 || !_rep->isArray)
|
1210 kumpf 1.39 throw TypeMismatchException();
|
1211 mike 1.11
|
1212 mike 1.62 if (!_rep->isNull)
1213 x = CIMValueType<Uint64>::aref(_rep);
|
1214 mike 1.11 }
1215
1216 void CIMValue::get(Array<Sint64>& x) const
1217 {
|
1218 mike 1.62 if (_rep->type != CIMTYPE_SINT64 || !_rep->isArray)
|
1219 kumpf 1.39 throw TypeMismatchException();
|
1220 mike 1.11
|
1221 mike 1.62 if (!_rep->isNull)
1222 x = CIMValueType<Sint64>::aref(_rep);
|
1223 mike 1.11 }
1224
1225 void CIMValue::get(Array<Real32>& x) const
1226 {
|
1227 mike 1.62 if (_rep->type != CIMTYPE_REAL32 || !_rep->isArray)
|
1228 kumpf 1.39 throw TypeMismatchException();
|
1229 mike 1.11
|
1230 mike 1.62 if (!_rep->isNull)
1231 x = CIMValueType<Real32>::aref(_rep);
|
1232 mike 1.11 }
1233
1234 void CIMValue::get(Array<Real64>& x) const
1235 {
|
1236 mike 1.62 if (_rep->type != CIMTYPE_REAL64 || !_rep->isArray)
|
1237 kumpf 1.39 throw TypeMismatchException();
|
1238 mike 1.11
|
1239 mike 1.62 if (!_rep->isNull)
1240 x = CIMValueType<Real64>::aref(_rep);
|
1241 mike 1.11 }
1242
1243 void CIMValue::get(Array<Char16>& x) const
1244 {
|
1245 mike 1.62 if (_rep->type != CIMTYPE_CHAR16 || !_rep->isArray)
|
1246 kumpf 1.39 throw TypeMismatchException();
|
1247 mike 1.11
|
1248 mike 1.62 if (!_rep->isNull)
1249 x = CIMValueType<Char16>::aref(_rep);
|
1250 mike 1.11 }
1251
1252 void CIMValue::get(Array<String>& x) const
1253 {
|
1254 mike 1.62 if (_rep->type != CIMTYPE_STRING || !_rep->isArray)
|
1255 kumpf 1.39 throw TypeMismatchException();
|
1256 mike 1.11
|
1257 mike 1.62 if (!_rep->isNull)
1258 x = CIMValueType<String>::aref(_rep);
|
1259 mike 1.11 }
1260
1261 void CIMValue::get(Array<CIMDateTime>& x) const
1262 {
|
1263 mike 1.62 if (_rep->type != CIMTYPE_DATETIME || !_rep->isArray)
|
1264 kumpf 1.39 throw TypeMismatchException();
|
1265 mike 1.11
|
1266 mike 1.62 if (!_rep->isNull)
1267 x = CIMValueType<CIMDateTime>::aref(_rep);
|
1268 mike 1.11 }
1269
|
1270 kumpf 1.31 void CIMValue::get(Array<CIMObjectPath>& x) const
|
1271 kumpf 1.15 {
|
1272 mike 1.62 if (_rep->type != CIMTYPE_REFERENCE || !_rep->isArray)
|
1273 kumpf 1.39 throw TypeMismatchException();
|
1274 kumpf 1.15
|
1275 mike 1.62 if (!_rep->isNull)
1276 x = CIMValueType<CIMObjectPath>::aref(_rep);
|
1277 kumpf 1.15 }
1278
|
1279 dave.sudlik 1.51 void CIMValue::get(Array<CIMObject>& x) const
1280 {
|
1281 mike 1.62 if (_rep->type != CIMTYPE_OBJECT || !_rep->isArray)
|
1282 dave.sudlik 1.51 throw TypeMismatchException();
1283
|
1284 mike 1.62 if (!_rep->isNull)
1285 {
|
1286 dave.sudlik 1.65 x.clear();
|
1287 mike 1.62
|
1288 dave.sudlik 1.65 // We have to clone our own unique copy since we are about to
1289 // return an object to the caller that he can modify; thereby,
1290 // changing the one we refer to as well.
1291 for (Uint32 i = 0, n = CIMValueType<CIMObject>::arraySize(_rep); i < n; i++)
1292 {
1293 x.append(CIMValueType<CIMObject>::aref(_rep)[i].clone());
1294 }
|
1295 mike 1.62 }
|
1296 dave.sudlik 1.51 }
1297
|
1298 kumpf 1.35 Boolean CIMValue::equal(const CIMValue& x) const
|
1299 kumpf 1.28 {
|
1300 kumpf 1.35 if (!typeCompatible(x))
1301 return false;
1302
|
1303 mike 1.62 if (_rep->isNull != x._rep->isNull)
|
1304 kumpf 1.35 return false;
1305
|
1306 mike 1.62 if (_rep->isArray)
|
1307 kumpf 1.35 {
|
1308 mike 1.62 switch (_rep->type)
|
1309 kumpf 1.35 {
|
1310 kumpf 1.36 case CIMTYPE_BOOLEAN:
|
1311 mike 1.62 return CIMValueType<Boolean>::equalArray(_rep, x._rep);
|
1312 kumpf 1.35
|
1313 kumpf 1.36 case CIMTYPE_UINT8:
|
1314 mike 1.62 return CIMValueType<Uint8>::equalArray(_rep, x._rep);
|
1315 kumpf 1.35
|
1316 kumpf 1.36 case CIMTYPE_SINT8:
|
1317 mike 1.62 return CIMValueType<Sint8>::equalArray(_rep, x._rep);
|
1318 kumpf 1.35
|
1319 kumpf 1.36 case CIMTYPE_UINT16:
|
1320 mike 1.62 return CIMValueType<Uint16>::equalArray(_rep, x._rep);
|
1321 kumpf 1.35
|
1322 kumpf 1.36 case CIMTYPE_SINT16:
|
1323 mike 1.62 return CIMValueType<Sint16>::equalArray(_rep, x._rep);
|
1324 kumpf 1.35
|
1325 kumpf 1.36 case CIMTYPE_UINT32:
|
1326 mike 1.62 return CIMValueType<Uint32>::equalArray(_rep, x._rep);
|
1327 kumpf 1.35
|
1328 kumpf 1.36 case CIMTYPE_SINT32:
|
1329 mike 1.62 return CIMValueType<Sint32>::equalArray(_rep, x._rep);
|
1330 kumpf 1.35
|
1331 kumpf 1.36 case CIMTYPE_UINT64:
|
1332 mike 1.62 return CIMValueType<Uint64>::equalArray(_rep, x._rep);
|
1333 kumpf 1.35
|
1334 kumpf 1.36 case CIMTYPE_SINT64:
|
1335 mike 1.62 return CIMValueType<Sint64>::equalArray(_rep, x._rep);
|
1336 kumpf 1.35
|
1337 kumpf 1.36 case CIMTYPE_REAL32:
|
1338 mike 1.62 return CIMValueType<Real32>::equalArray(_rep, x._rep);
|
1339 kumpf 1.35
|
1340 kumpf 1.36 case CIMTYPE_REAL64:
|
1341 mike 1.62 return CIMValueType<Real64>::equalArray(_rep, x._rep);
|
1342 kumpf 1.35
|
1343 kumpf 1.36 case CIMTYPE_CHAR16:
|
1344 mike 1.62 return CIMValueType<Char16>::equalArray(_rep, x._rep);
|
1345 kumpf 1.35
|
1346 kumpf 1.36 case CIMTYPE_STRING:
|
1347 mike 1.62 return CIMValueType<String>::equalArray(_rep, x._rep);
|
1348 kumpf 1.35
|
1349 kumpf 1.36 case CIMTYPE_DATETIME:
|
1350 mike 1.62 return CIMValueType<CIMDateTime>::equalArray(_rep, x._rep);
|
1351 kumpf 1.35
|
1352 kumpf 1.36 case CIMTYPE_REFERENCE:
|
1353 mike 1.62 return CIMValueType<CIMObjectPath>::equalArray(_rep, x._rep);
|
1354 kumpf 1.42
|
1355 dave.sudlik 1.51 case CIMTYPE_OBJECT:
|
1356 mike 1.62 return CIMValueType<CIMObject>::equalArray(_rep, x._rep);
|
1357 dave.sudlik 1.51
|
1358 mike 1.62 default:
|
1359 jim.wunderlich 1.63 PEGASUS_ASSERT(0);
|
1360 kumpf 1.35 }
1361 }
1362 else
1363 {
|
1364 mike 1.62 switch (_rep->type)
|
1365 kumpf 1.35 {
|
1366 kumpf 1.36 case CIMTYPE_BOOLEAN:
|
1367 mike 1.62 return CIMValueType<Boolean>::equal(_rep, x._rep);
|
1368 kumpf 1.35
|
1369 kumpf 1.36 case CIMTYPE_UINT8:
|
1370 mike 1.62 return CIMValueType<Uint8>::equal(_rep, x._rep);
|
1371 kumpf 1.35
|
1372 kumpf 1.36 case CIMTYPE_SINT8:
|
1373 mike 1.62 return CIMValueType<Sint8>::equal(_rep, x._rep);
|
1374 kumpf 1.35
|
1375 kumpf 1.36 case CIMTYPE_UINT16:
|
1376 mike 1.62 return CIMValueType<Uint16>::equal(_rep, x._rep);
|
1377 kumpf 1.35
|
1378 kumpf 1.36 case CIMTYPE_SINT16:
|
1379 mike 1.62 return CIMValueType<Sint16>::equal(_rep, x._rep);
|
1380 kumpf 1.35
|
1381 kumpf 1.36 case CIMTYPE_UINT32:
|
1382 mike 1.62 return CIMValueType<Uint32>::equal(_rep, x._rep);
|
1383 kumpf 1.35
|
1384 kumpf 1.36 case CIMTYPE_SINT32:
|
1385 mike 1.62 return CIMValueType<Sint32>::equal(_rep, x._rep);
|
1386 kumpf 1.35
|
1387 kumpf 1.36 case CIMTYPE_UINT64:
|
1388 mike 1.62 return CIMValueType<Uint64>::equal(_rep, x._rep);
|
1389 kumpf 1.35
|
1390 kumpf 1.36 case CIMTYPE_SINT64:
|
1391 mike 1.62 return CIMValueType<Sint64>::equal(_rep, x._rep);
|
1392 kumpf 1.35
|
1393 kumpf 1.36 case CIMTYPE_REAL32:
|
1394 mike 1.62 return CIMValueType<Real32>::equal(_rep, x._rep);
|
1395 kumpf 1.35
|
1396 kumpf 1.36 case CIMTYPE_REAL64:
|
1397 mike 1.62 return CIMValueType<Real64>::equal(_rep, x._rep);
|
1398 kumpf 1.35
|
1399 kumpf 1.36 case CIMTYPE_CHAR16:
|
1400 mike 1.62 return CIMValueType<Char16>::equal(_rep, x._rep);
|
1401 kumpf 1.35
|
1402 kumpf 1.36 case CIMTYPE_STRING:
|
1403 mike 1.62 return CIMValueType<String>::equal(_rep, x._rep);
|
1404 kumpf 1.35
|
1405 kumpf 1.36 case CIMTYPE_DATETIME:
|
1406 mike 1.62 return CIMValueType<CIMDateTime>::equal(_rep, x._rep);
|
1407 kumpf 1.35
|
1408 kumpf 1.36 case CIMTYPE_REFERENCE:
|
1409 mike 1.62 return CIMValueType<CIMObjectPath>::equal(_rep, x._rep);
|
1410 kumpf 1.35
|
1411 dave.sudlik 1.51 case CIMTYPE_OBJECT:
|
1412 mike 1.62 return CIMValueType<CIMObject>::ref(_rep).identical(
1413 CIMValueType<CIMObject>::ref(x._rep));
|
1414 dave.sudlik 1.51
|
1415 mike 1.62 default:
|
1416 jim.wunderlich 1.63 PEGASUS_ASSERT(0);
|
1417 kumpf 1.35 }
1418 }
1419
|
1420 mike 1.62 return false;
|
1421 mike 1.11 }
1422
1423 String CIMValue::toString() const
1424 {
|
1425 mike 1.60 Buffer out;
|
1426 mike 1.11
|
1427 mike 1.62 // ATTN: Not sure what we should do with getstring for Null CIMValues
1428 // Choice return empty string or exception out.
1429
1430 if (_rep->isNull)
|
1431 kumpf 1.18 return String();
|
1432 karl 1.13
|
1433 mike 1.62 if (_rep->isArray)
|
1434 mike 1.11 {
|
1435 mike 1.62 switch (_rep->type)
|
1436 kumpf 1.26 {
|
1437 kumpf 1.36 case CIMTYPE_BOOLEAN:
|
1438 mike 1.62 {
1439 const Array<Boolean>& a = CIMValueType<Boolean>::aref(_rep);
1440 Uint32 size = a.size();
1441
|
1442 kumpf 1.26 for (Uint32 i = 0; i < size; i++)
1443 {
|
1444 mike 1.62 _toString(out, a[i]);
1445 out.append(' ');
|
1446 kumpf 1.26 }
1447 break;
|
1448 mike 1.62 }
|
1449 kumpf 1.26
|
1450 kumpf 1.36 case CIMTYPE_UINT8:
|
1451 mike 1.62 {
1452 const Array<Uint8>& a = CIMValueType<Uint8>::aref(_rep);
1453 _toString(out, a.getData(), a.size());
|
1454 kumpf 1.26 break;
|
1455 mike 1.62 }
|
1456 kumpf 1.26
|
1457 kumpf 1.36 case CIMTYPE_SINT8:
|
1458 mike 1.62 {
1459 const Array<Sint8>& a = CIMValueType<Sint8>::aref(_rep);
1460 _toString(out, a.getData(), a.size());
|
1461 kumpf 1.26 break;
|
1462 mike 1.62 }
|
1463 kumpf 1.26
|
1464 kumpf 1.36 case CIMTYPE_UINT16:
|
1465 mike 1.62 {
1466 const Array<Uint16>& a = CIMValueType<Uint16>::aref(_rep);
1467 _toString(out, a.getData(), a.size());
|
1468 kumpf 1.26 break;
|
1469 mike 1.62 }
|
1470 kumpf 1.26
|
1471 kumpf 1.36 case CIMTYPE_SINT16:
|
1472 mike 1.62 {
1473 const Array<Sint16>& a = CIMValueType<Sint16>::aref(_rep);
1474 _toString(out, a.getData(), a.size());
|
1475 kumpf 1.26 break;
|
1476 mike 1.62 }
|
1477 kumpf 1.26
|
1478 kumpf 1.36 case CIMTYPE_UINT32:
|
1479 mike 1.62 {
1480 const Array<Uint32>& a = CIMValueType<Uint32>::aref(_rep);
1481 _toString(out, a.getData(), a.size());
|
1482 kumpf 1.26 break;
|
1483 mike 1.62 }
|
1484 kumpf 1.26
|
1485 kumpf 1.36 case CIMTYPE_SINT32:
|
1486 mike 1.62 {
1487 const Array<Sint32>& a = CIMValueType<Sint32>::aref(_rep);
1488 _toString(out, a.getData(), a.size());
|
1489 kumpf 1.26 break;
|
1490 mike 1.62 }
|
1491 kumpf 1.26
|
1492 kumpf 1.36 case CIMTYPE_UINT64:
|
1493 mike 1.62 {
1494 const Array<Uint64>& a = CIMValueType<Uint64>::aref(_rep);
1495 _toString(out, a.getData(), a.size());
|
1496 kumpf 1.26 break;
|
1497 mike 1.62 }
|
1498 kumpf 1.26
|
1499 kumpf 1.36 case CIMTYPE_SINT64:
|
1500 mike 1.62 {
1501 const Array<Sint64>& a = CIMValueType<Sint64>::aref(_rep);
1502 _toString(out, a.getData(), a.size());
|
1503 kumpf 1.26 break;
|
1504 mike 1.62 }
|
1505 kumpf 1.26
|
1506 kumpf 1.36 case CIMTYPE_REAL32:
|
1507 mike 1.62 {
1508 const Array<Real32>& a = CIMValueType<Real32>::aref(_rep);
1509 _toString(out, a.getData(), a.size());
|
1510 kumpf 1.26 break;
|
1511 mike 1.62 }
|
1512 kumpf 1.26
|
1513 kumpf 1.36 case CIMTYPE_REAL64:
|
1514 mike 1.62 {
1515 const Array<Real64>& a = CIMValueType<Real64>::aref(_rep);
1516 _toString(out, a.getData(), a.size());
|
1517 kumpf 1.26 break;
|
1518 mike 1.62 }
|
1519 kumpf 1.26
|
1520 kumpf 1.36 case CIMTYPE_CHAR16:
|
1521 mike 1.62 {
1522 const Array<Char16>& a = CIMValueType<Char16>::aref(_rep);
1523 _toString(out, a.getData(), a.size());
|
1524 kumpf 1.26 break;
|
1525 mike 1.62 }
|
1526 kumpf 1.26
|
1527 kumpf 1.36 case CIMTYPE_STRING:
|
1528 mike 1.62 {
1529 const Array<String>& a = CIMValueType<String>::aref(_rep);
1530 _toString(out, a.getData(), a.size());
|
1531 kumpf 1.26 break;
|
1532 mike 1.62 }
|
1533 kumpf 1.26
|
1534 kumpf 1.36 case CIMTYPE_DATETIME:
|
1535 mike 1.62 {
1536 const Array<CIMDateTime>& a =
1537 CIMValueType<CIMDateTime>::aref(_rep);
1538 _toString(out, a.getData(), a.size());
|
1539 kumpf 1.26 break;
|
1540 mike 1.62 }
|
1541 kumpf 1.26
|
1542 kumpf 1.36 case CIMTYPE_REFERENCE:
|
1543 mike 1.62 {
1544 const Array<CIMObjectPath>& a =
1545 CIMValueType<CIMObjectPath>::aref(_rep);
1546 _toString(out, a.getData(), a.size());
|
1547 kumpf 1.26 break;
|
1548 mike 1.62 }
|
1549 kumpf 1.15
|
1550 dave.sudlik 1.51 case CIMTYPE_OBJECT:
|
1551 mike 1.62 {
1552 const Array<CIMObject>& a = CIMValueType<CIMObject>::aref(_rep);
1553 _toString(out, a.getData(), a.size());
|
1554 dave.sudlik 1.51 break;
|
1555 mike 1.62 }
|
1556 dave.sudlik 1.51
|
1557 mike 1.62 default:
|
1558 jim.wunderlich 1.63 PEGASUS_ASSERT(0);
|
1559 kumpf 1.26 }
|
1560 mike 1.11 }
1561 else
1562 {
|
1563 mike 1.62 switch (_rep->type)
|
1564 kumpf 1.26 {
|
1565 kumpf 1.36 case CIMTYPE_BOOLEAN:
|
1566 mike 1.62 _toString(out, CIMValueType<Boolean>::ref(_rep));
|
1567 kumpf 1.26 break;
1568
|
1569 kumpf 1.36 case CIMTYPE_UINT8:
|
1570 mike 1.62 _toString(out, CIMValueType<Uint8>::ref(_rep));
|
1571 kumpf 1.26 break;
1572
|
1573 kumpf 1.36 case CIMTYPE_SINT8:
|
1574 mike 1.62 _toString(out, CIMValueType<Sint8>::ref(_rep));
|
1575 kumpf 1.26 break;
1576
|
1577 kumpf 1.36 case CIMTYPE_UINT16:
|
1578 mike 1.62 _toString(out, CIMValueType<Uint16>::ref(_rep));
|
1579 kumpf 1.26 break;
1580
|
1581 kumpf 1.36 case CIMTYPE_SINT16:
|
1582 mike 1.62 _toString(out, CIMValueType<Sint16>::ref(_rep));
|
1583 kumpf 1.26 break;
1584
|
1585 kumpf 1.36 case CIMTYPE_UINT32:
|
1586 mike 1.62 _toString(out, CIMValueType<Uint32>::ref(_rep));
|
1587 kumpf 1.26 break;
1588
|
1589 kumpf 1.36 case CIMTYPE_SINT32:
|
1590 mike 1.62 _toString(out, CIMValueType<Sint32>::ref(_rep));
|
1591 kumpf 1.26 break;
1592
|
1593 kumpf 1.36 case CIMTYPE_UINT64:
|
1594 mike 1.62 _toString(out, CIMValueType<Uint64>::ref(_rep));
|
1595 kumpf 1.26 break;
1596
|
1597 kumpf 1.36 case CIMTYPE_SINT64:
|
1598 mike 1.62 _toString(out, CIMValueType<Sint64>::ref(_rep));
|
1599 kumpf 1.26 break;
1600
|
1601 kumpf 1.36 case CIMTYPE_REAL32:
|
1602 mike 1.62 _toString(out, CIMValueType<Real32>::ref(_rep));
|
1603 kumpf 1.26 break;
1604
|
1605 kumpf 1.36 case CIMTYPE_REAL64:
|
1606 mike 1.62 _toString(out, CIMValueType<Real64>::ref(_rep));
|
1607 kumpf 1.26 break;
1608
|
1609 kumpf 1.36 case CIMTYPE_CHAR16:
|
1610 mike 1.62 _toString(out, CIMValueType<Char16>::ref(_rep));
|
1611 kumpf 1.26 break;
1612
|
1613 kumpf 1.36 case CIMTYPE_STRING:
|
1614 mike 1.62 _toString(out, CIMValueType<String>::ref(_rep));
|
1615 kumpf 1.26 break;
1616
|
1617 kumpf 1.36 case CIMTYPE_DATETIME:
|
1618 mike 1.62 _toString(out, CIMValueType<CIMDateTime>::ref(_rep));
|
1619 kumpf 1.26 break;
1620
|
1621 kumpf 1.36 case CIMTYPE_REFERENCE:
|
1622 mike 1.62 _toString(out, CIMValueType<CIMObjectPath>::ref(_rep));
|
1623 kumpf 1.26 break;
|
1624 kumpf 1.15
|
1625 dave.sudlik 1.51 case CIMTYPE_OBJECT:
|
1626 mike 1.62 _toString(out, CIMValueType<CIMObject>::ref(_rep));
|
1627 dave.sudlik 1.51 break;
1628
|
1629 mike 1.62 default:
|
1630 jim.wunderlich 1.63 PEGASUS_ASSERT(0);
|
1631 kumpf 1.26 }
|
1632 mike 1.11 }
1633
1634 out.append('\0');
|
1635 mike 1.62
|
1636 mike 1.11 return out.getData();
|
1637 kumpf 1.26 }
1638
|
1639 david.dillard 1.56 #ifdef PEGASUS_USE_DEPRECATED_INTERFACES
1640
1641 CIMValue::CIMValue(char x)
1642 {
|
1643 mike 1.62 _rep = new CIMValueRep;
1644 CIMValueType<Sint8>::set(_rep, (Sint8)x);
|
1645 david.dillard 1.56 }
1646
1647 CIMValue::CIMValue(const Array<char>& x)
1648 {
|
1649 mike 1.62 _rep = new CIMValueRep;
1650 Array<Sint8> tmp((Sint8*)x.getData(), x.size());
1651 CIMValueType<Sint8>::setArray(_rep, tmp);
|
1652 david.dillard 1.56 }
1653
1654 void CIMValue::set(char x)
1655 {
1656 set(static_cast<Sint8>(x));
1657 }
1658
1659 void CIMValue::set(const Array<char>& x)
1660 {
|
1661 mike 1.62 set(*reinterpret_cast<const Array<Sint8>*>(&x));
|
1662 david.dillard 1.56 }
1663
1664 void CIMValue::get(char& x) const
1665 {
|
1666 mike 1.62 get(*reinterpret_cast<Sint8*>(&x));
|
1667 david.dillard 1.56 }
1668
1669 void CIMValue::get(Array<char>& x) const
1670 {
|
1671 mike 1.62 get(*reinterpret_cast<Array<Sint8>*>(&x));
|
1672 david.dillard 1.56 }
1673
|
1674 mike 1.62 #endif /* PEGASUS_USE_DEPRECATED_INTERFACES */
|
1675 david.dillard 1.56
|
1676 mike 1.61 void CIMValue::_get(const String*& data, Uint32& size) const
1677 {
|
1678 mike 1.62 const Array<String>& a = CIMValueType<String>::aref(_rep);
1679 data = a.getData();
1680 size = a.size();
1681 }
1682
1683 Boolean operator==(const CIMValue& x, const CIMValue& y)
1684 {
1685 return x.equal(y);
1686 }
1687
1688 Boolean operator!=(const CIMValue& x, const CIMValue& y)
1689 {
1690 return !x.equal(y);
|
1691 mike 1.61 }
|
1692 david.dillard 1.56
|
1693 mike 1.11 PEGASUS_NAMESPACE_END
|