pegasus/src/Pegasus/Common/CIMValue.cpp - annotate

Return to CIMValue.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

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

No CVS admin address has been configured