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