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