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

Return to CIMValue.cpp CVS log

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

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

No CVS admin address has been configured