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 mike  1.6 #define PEGASUS_ARRAY_T CIMValue
  40           # include "ArrayImpl.h"
  41           #undef PEGASUS_ARRAY_T
  42           

  43 mike  1.1 template<class T>
  44           inline void _Inc(ArrayRep<T>* rep)
  45           {
  46               ArrayRep<T>::inc(rep);
  47           }
  48           
  49           template<class T>
  50           inline void _Dec(ArrayRep<T>* rep)
  51           {
  52               ArrayRep<T>::dec(rep);
  53           }
  54           
  55           ////////////////////////////////////////////////////////////////////////////////
  56           //
  57           // Local helper functions:
  58           //
  59           ////////////////////////////////////////////////////////////////////////////////
  60           
  61           //------------------------------------------------------------------------------
  62           //
  63           // _SignedIntToStr()
  64 mike  1.1 //
  65           //------------------------------------------------------------------------------
  66           
  67           static void _SignedIntToStr(Sint64 x, char* result)
  68           {
  69               if (!result)
  70           	return;
  71           
  72               if (x == 0)
  73               {
  74           	result[0] = '0';
  75           	result[1] = '\0';
  76           	return;
  77               }
  78           
  79               char buffer[256];
  80               Uint32 len = 0;
  81               Boolean negative = false;
  82           
  83               for (Uint32 i = 0; 1; i++)
  84               {
  85 mike  1.1 	Sint64 q = x / 10;
  86           	Sint32 r = x % 10;
  87           
  88           	if (q == 0 && r == 0)
  89           	    break;
  90           
  91           	if (r < 0)
  92           	{
  93           	    r = -r;
  94           	    negative = true;
  95           	}
  96           
  97           	buffer[len++] = r + '0';
  98           
  99           	x = q ;
 100               }
 101           
 102               buffer[len] = '\0';
 103           
 104               // If buffer was negative, prepend sign:
 105           
 106 mike  1.1     char* q = result;
 107           
 108               if (negative)
 109           	*q++ = '-';
 110           
 111               // Reverse the buffer:
 112           
 113               char* p = &buffer[len];
 114           
 115               while (len--)
 116           	*q++ = *--p;
 117           
 118               *q++ = '\0';
 119           }
 120           
 121           //------------------------------------------------------------------------------
 122           //
 123           // _UnsignedIntToStr()
 124           //
 125           //------------------------------------------------------------------------------
 126           
 127 mike  1.1 static void _UnsignedIntToStr(Uint64 x, char* result)
 128           {
 129               if (!result)
 130           	return;
 131           
 132               if (x == 0)
 133               {
 134           	result[0] = '0';
 135           	result[1] = '\0';
 136           	return;
 137               }
 138           
 139               char buffer[256];
 140               Uint32 len = 0;
 141               Boolean negative = false;
 142           
 143               for (Uint32 i = 0; 1; i++)
 144               {
 145           	Sint64 q = x / 10;
 146           	Sint32 r = x % 10;
 147           
 148 mike  1.1 	if (q == 0 && r == 0)
 149           	    break;
 150           
 151           	buffer[len++] = r + '0';
 152           
 153           	x = q ;
 154               }
 155           
 156               buffer[len] = '\0';
 157           
 158               // Reverse the buffer onto output:
 159           
 160               char* q = result;
 161           
 162               char* p = &buffer[len];
 163           
 164               while (len--)
 165           	*q++ = *--p;
 166           
 167               *q++ = '\0';
 168           }
 169 mike  1.1 
 170           //------------------------------------------------------------------------------
 171           //
 172           // _toXml() routines:
 173           //
 174           //------------------------------------------------------------------------------
 175           
 176           inline void _toXml(Array<Sint8>& out, Boolean x)
 177           {
 178               out << (x ? "TRUE" : "FALSE");
 179           }
 180           
 181           template<class T>
 182           inline void _integerToXml(Array<Sint8>& out, const T& x)
 183           {
 184               char buffer[32];
 185               sprintf(buffer, "%d", x);
 186               out << (char*)buffer;
 187           }
 188           
 189           inline void _toXml(Array<Sint8>& out, Uint8 x) { _integerToXml(out, x); }
 190 mike  1.1 
 191           inline void _toXml(Array<Sint8>& out, Sint8 x) { _integerToXml(out, x); }
 192           
 193           inline void _toXml(Array<Sint8>& out, Uint16 x) { _integerToXml(out, x); }
 194           
 195           inline void _toXml(Array<Sint8>& out, Sint16 x) { _integerToXml(out, x); }
 196           
 197           inline void _toXml(Array<Sint8>& out, Uint32 x) { _integerToXml(out, x); }
 198           
 199           inline void _toXml(Array<Sint8>& out, Sint32 x) { _integerToXml(out, x); }
 200           
 201           inline void _toXml(Array<Sint8>& out, Uint64 x) 
 202           { 
 203               char buffer[128];
 204               _UnsignedIntToStr(x, buffer);
 205               out << buffer;
 206           }
 207           
 208           inline void _toXml(Array<Sint8>& out, Sint64 x) 
 209           {
 210               char buffer[128];
 211 mike  1.1     _SignedIntToStr(x, buffer);
 212               out << buffer;
 213           }
 214           
 215           void _toXml(Array<Sint8>& out, Real32 x)
 216           {
 217               // ATTN: Does this format match the CIM/XML format?
 218               char buffer[128];
 219               sprintf(buffer, "%f", x);
 220               out << buffer;
 221           }
 222           
 223           void _toXml(Array<Sint8>& out, Real64 x)
 224           {
 225               char buffer[128];
 226               sprintf(buffer, "%f", x);
 227               out << buffer;
 228           }
 229           
 230           inline void _toXml(Array<Sint8>& out, Char16 x)
 231           {
 232 mike  1.1     XmlWriter::appendSpecial(out, x);
 233           }
 234           
 235           inline void _toXml(Array<Sint8>& out, const String& x)
 236           {
 237               XmlWriter::appendSpecial(out, x);
 238           }
 239           
 240           inline void _toXml(Array<Sint8>& out, const CIMDateTime& x)
 241           {
 242               out << x.getString();
 243           }
 244           
 245           template<class T>
 246           void _toXml(Array<Sint8>& out, const T* p, Uint32 size)
 247           {
 248               while (size--)
 249               {
 250           	out << "<VALUE>";
 251           
 252           	_toXml(out, *p++);
 253 mike  1.1 
 254           	out << "</VALUE>\n";
 255               }
 256           }
 257           
 258           template<class T>
 259           void _toStr(Array<Sint8>& out, const T* p, Uint32 size)
 260           {
 261               while (size--)
 262               {
 263           	_toXml(out, *p++);
 264           	out << " ";
 265               }
 266           }
 267           
 268           ////////////////////////////////////////////////////////////////////////////////
 269           //
 270           // CIMValue
 271           //
 272           ////////////////////////////////////////////////////////////////////////////////
 273           
 274 mike  1.1 CIMValue::CIMValue()
 275           {
 276               _init();
 277           }
 278           
 279           CIMValue::CIMValue(const CIMValue& x) 
 280           { 
 281               _init(); 
 282               assign(x); 
 283           }
 284           
 285           CIMValue::~CIMValue()
 286           {
 287               clear();
 288           }
 289           
 290           void CIMValue::assign(const CIMValue& x)
 291           {
 292               if (this == &x)
 293           	return;
 294           
 295 mike  1.1     clear();
 296           
 297               _type = x._type;
 298               _isArray = x._isArray;
 299               _u._voidPtr = 0;
 300           
 301               if (_isArray)
 302               {
 303           	switch (_type)
 304           	{
 305           	    case CIMType::BOOLEAN:
 306           		_Inc(_u._booleanArray = x._u._booleanArray);
 307           		break;
 308           
 309           	    case CIMType::UINT8:
 310           		_Inc(_u._uint8Array = x._u._uint8Array);
 311           		break;
 312           
 313           	    case CIMType::SINT8:
 314           		_Inc(_u._sint8Array = x._u._sint8Array);
 315           		break;
 316 mike  1.1 
 317           	    case CIMType::UINT16:
 318           		_Inc(_u._uint16Array = x._u._uint16Array);
 319           		break;
 320           
 321           	    case CIMType::SINT16:
 322           		_Inc(_u._sint16Array = x._u._sint16Array);
 323           		break;
 324           
 325           	    case CIMType::UINT32:
 326           		_Inc(_u._uint32Array = x._u._uint32Array);
 327           		break;
 328           
 329           	    case CIMType::SINT32:
 330           		_Inc(_u._sint32Array = x._u._sint32Array);
 331           		break;
 332           
 333           	    case CIMType::UINT64:
 334           		_Inc(_u._uint64Array = x._u._uint64Array);
 335           		break;
 336           
 337 mike  1.1 	    case CIMType::SINT64:
 338           		_Inc(_u._sint64Array = x._u._sint64Array);
 339           		break;
 340           
 341           	    case CIMType::REAL32:
 342           		_Inc(_u._real32Array = x._u._real32Array);
 343           		break;
 344           
 345           	    case CIMType::REAL64:
 346           		_Inc(_u._real64Array = x._u._real64Array);
 347           		break;
 348           
 349           	    case CIMType::CHAR16:
 350           		_Inc(_u._char16Array = x._u._char16Array);
 351           		break;
 352           
 353           	    case CIMType::STRING:
 354           		_Inc(_u._stringArray = x._u._stringArray);
 355           		break;
 356           
 357           	    case CIMType::DATETIME:
 358 mike  1.1 		_Inc(_u._dateTimeArray = x._u._dateTimeArray);
 359           		break;
 360           	}
 361               }
 362               else
 363               {
 364           	switch (_type)
 365           	{
 366           	    case CIMType::NONE:
 367           		break;
 368           
 369           	    case CIMType::BOOLEAN:
 370           		_u._booleanValue = x._u._booleanValue;
 371           		break;
 372           
 373           	    case CIMType::UINT8:
 374           		_u._uint8Value = x._u._uint8Value;
 375           		break;
 376           
 377           	    case CIMType::SINT8:
 378           		_u._sint8Value = x._u._sint8Value;
 379 mike  1.1 		break;
 380           
 381           	    case CIMType::UINT16:
 382           		_u._uint16Value = x._u._uint16Value;
 383           		break;
 384           
 385           	    case CIMType::SINT16:
 386           		_u._sint16Value = x._u._sint16Value;
 387           		break;
 388           
 389           	    case CIMType::UINT32:
 390           		_u._uint32Value = x._u._uint32Value;
 391           		break;
 392           
 393           	    case CIMType::SINT32:
 394           		_u._sint32Value = x._u._sint32Value;
 395           		break;
 396           
 397           	    case CIMType::UINT64:
 398           		_u._uint64Value = x._u._uint64Value;
 399           		break;
 400 mike  1.1 
 401           	    case CIMType::SINT64:
 402           		_u._sint64Value = x._u._sint64Value;
 403           		break;
 404           
 405           	    case CIMType::REAL32:
 406           		_u._real32Value = x._u._real32Value;
 407           		break;
 408           
 409           	    case CIMType::REAL64:
 410           		_u._real64Value = x._u._real64Value;
 411           		break;
 412           
 413           	    case CIMType::CHAR16:
 414           		_u._char16Value = x._u._char16Value;
 415           		break;
 416           
 417           	    case CIMType::STRING:
 418           		_u._stringValue = new String(*(x._u._stringValue));
 419           		break;
 420           
 421 mike  1.1 	    case CIMType::DATETIME:
 422           		_u._dateTimeValue = new CIMDateTime(*(x._u._dateTimeValue));
 423           		break;
 424           
 425           	    case CIMType::REFERENCE:
 426           		_u._referenceValue 
 427           		    = new CIMReference(*(x._u._referenceValue));
 428           		break;
 429           	}
 430               }
 431           }
 432           
 433           Uint32 CIMValue::getArraySize() const
 434           {
 435               if (!_isArray)
 436           	return 0;
 437           
 438               switch (_type)
 439               {
 440           	case CIMType::NONE:
 441           	    return 0;
 442 mike  1.1 	    break;
 443           
 444           	case CIMType::BOOLEAN:
 445           	    return _u._booleanArray->size;
 446           	    break;
 447           
 448           	case CIMType::UINT8:
 449           	    return _u._uint8Array->size;
 450           	    break;
 451           
 452           	case CIMType::SINT8:
 453           	    return _u._sint8Array->size;
 454           	    break;
 455           
 456           	case CIMType::UINT16:
 457           	    return _u._uint16Array->size;
 458           	    break;
 459           
 460           	case CIMType::SINT16:
 461           	    return _u._sint16Array->size;
 462           	    break;
 463 mike  1.1 
 464           	case CIMType::UINT32:
 465           	    return _u._uint32Array->size;
 466           	    break;
 467           
 468           	case CIMType::SINT32:
 469           	    return _u._sint32Array->size;
 470           	    break;
 471           
 472           	case CIMType::UINT64:
 473           	    return _u._uint64Array->size;
 474           	    break;
 475           
 476           	case CIMType::SINT64:
 477           	    return _u._sint64Array->size;
 478           	    break;
 479           
 480           	case CIMType::REAL32:
 481           	    return _u._real32Array->size;
 482           	    break;
 483           
 484 mike  1.1 	case CIMType::REAL64:
 485           	    return _u._real64Array->size;
 486           	    break;
 487           
 488           	case CIMType::CHAR16:
 489           	    return _u._char16Array->size;
 490           	    break;
 491           
 492           	case CIMType::STRING:
 493           	    return _u._stringArray->size;
 494           	    break;
 495           
 496           	case CIMType::DATETIME:
 497           	    return _u._dateTimeArray->size;
 498           	    break;
 499           
 500           	case CIMType::REFERENCE:
 501           	    return 0;
 502               }
 503           
 504               // Unreachable!
 505 mike  1.1     return 0;
 506           }
 507           
 508           void CIMValue::clear()
 509           {
 510               if (_isArray)
 511               {
 512           	switch (_type)
 513           	{
 514           	    case CIMType::BOOLEAN:
 515           		_Dec(_u._booleanArray);
 516           		break;
 517           
 518           	    case CIMType::UINT8:
 519           		_Dec(_u._uint8Array);
 520           		break;
 521           
 522           	    case CIMType::SINT8:
 523           		_Dec(_u._sint8Array);
 524           		break;
 525           
 526 mike  1.1 	    case CIMType::UINT16:
 527           		_Dec(_u._uint16Array);
 528           		break;
 529           
 530           	    case CIMType::SINT16:
 531           		_Dec(_u._sint16Array);
 532           		break;
 533           
 534           	    case CIMType::UINT32:
 535           		_Dec(_u._uint32Array);
 536           		break;
 537           
 538           	    case CIMType::SINT32:
 539           		_Dec(_u._sint32Array);
 540           		break;
 541           
 542           	    case CIMType::UINT64:
 543           		_Dec(_u._uint64Array);
 544           		break;
 545           
 546           	    case CIMType::SINT64:
 547 mike  1.1 		_Dec(_u._sint64Array);
 548           		break;
 549           
 550           	    case CIMType::REAL32:
 551           		_Dec(_u._real32Array);
 552           		break;
 553           
 554           	    case CIMType::REAL64:
 555           		_Dec(_u._real64Array);
 556           		break;
 557           
 558           	    case CIMType::CHAR16:
 559           		_Dec(_u._char16Array);
 560           		break;
 561           
 562           	    case CIMType::STRING:
 563           		_Dec(_u._stringArray);
 564           		break;
 565           
 566           	    case CIMType::DATETIME:
 567           		_Dec(_u._dateTimeArray);
 568 mike  1.1 		break;
 569           	}
 570               }
 571               else
 572               {
 573           	switch (_type)
 574           	{
 575           	    case CIMType::BOOLEAN:
 576           	    case CIMType::UINT8:
 577           	    case CIMType::SINT8:
 578           	    case CIMType::UINT16:
 579           	    case CIMType::SINT16:
 580           	    case CIMType::UINT32:
 581           	    case CIMType::SINT32:
 582           	    case CIMType::UINT64:
 583           	    case CIMType::SINT64:
 584           	    case CIMType::REAL32:
 585           	    case CIMType::REAL64:
 586           	    case CIMType::CHAR16:
 587           		break;
 588           
 589 mike  1.1 	    case CIMType::STRING:
 590           		delete _u._stringValue;
 591           		break;
 592           
 593           	    case CIMType::DATETIME:
 594           		delete _u._dateTimeValue;
 595           		break;
 596           
 597           	    case CIMType::REFERENCE:
 598           		delete _u._referenceValue;
 599           		break;
 600           	}
 601               }
 602           
 603               _init();
 604           }
 605           
 606           void CIMValue::toXml(Array<Sint8>& out) const
 607           {
 608               if (_isArray)
 609               {
 610 mike  1.1 	out << "<VALUE.ARRAY>\n";
 611           
 612           	switch (_type)
 613           	{
 614           	    case CIMType::BOOLEAN:
 615           	    {
 616           		for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)
 617           		{
 618           		    out << "<VALUE>";
 619           		    _toXml(out, Boolean(_u._booleanArray->data()[i]));
 620           		    out << "</VALUE>\n";
 621           		}
 622           		break;
 623           	    }
 624           
 625           	    case CIMType::UINT8:
 626           		_toXml(out, _u._uint8Array->data(), _u._uint8Array->size);
 627           		break;
 628           
 629           	    case CIMType::SINT8:
 630           		_toXml(out, _u._sint8Array->data(), _u._sint8Array->size);
 631 mike  1.1 		break;
 632           
 633           	    case CIMType::UINT16:
 634           		_toXml(out, _u._uint16Array->data(), _u._uint16Array->size);
 635           		break;
 636           
 637           	    case CIMType::SINT16:
 638           		_toXml(out, _u._sint16Array->data(), _u._sint16Array->size);
 639           		break;
 640           
 641           	    case CIMType::UINT32:
 642           		_toXml(out, _u._uint32Array->data(), _u._uint32Array->size);
 643           		break;
 644           
 645           	    case CIMType::SINT32:
 646           		_toXml(out, _u._sint32Array->data(), _u._sint32Array->size);
 647           		break;
 648           
 649           	    case CIMType::UINT64:
 650           		_toXml(out, _u._uint64Array->data(), _u._uint64Array->size);
 651           		break;
 652 mike  1.1 
 653           	    case CIMType::SINT64:
 654           		_toXml(out, _u._sint64Array->data(), _u._sint64Array->size);
 655           		break;
 656           
 657           	    case CIMType::REAL32:
 658           		_toXml(out, _u._real32Array->data(), _u._real32Array->size);
 659           		break;
 660           
 661           	    case CIMType::REAL64:
 662           		_toXml(out, _u._real64Array->data(), _u._real64Array->size);
 663           		break;
 664           
 665           	    case CIMType::CHAR16:
 666           		_toXml(out, _u._char16Array->data(), _u._char16Array->size);
 667           		break;
 668           
 669           	    case CIMType::STRING:
 670           		_toXml(out, _u._stringArray->data(), _u._stringArray->size);
 671           		break;
 672           
 673 mike  1.1 	    case CIMType::DATETIME:
 674           		_toXml(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);
 675           		break;
 676           	}
 677           
 678           	out << "</VALUE.ARRAY>\n";
 679               }
 680               else if (_type == CIMType::REFERENCE)
 681               {
 682           	_u._referenceValue->toXml(out);
 683               }
 684               else
 685               {
 686           	out << "<VALUE>";
 687           
 688           	switch (_type)
 689           	{
 690           	    case CIMType::BOOLEAN:
 691           		_toXml(out, Boolean(_u._booleanValue != 0));
 692           		break;
 693           
 694 mike  1.1 	    case CIMType::UINT8:
 695           		_toXml(out, _u._uint8Value);
 696           		break;
 697           
 698           	    case CIMType::SINT8:
 699           		_toXml(out, _u._sint8Value);
 700           		break;
 701           
 702           	    case CIMType::UINT16:
 703           		_toXml(out, _u._uint16Value);
 704           		break;
 705           
 706           	    case CIMType::SINT16:
 707           		_toXml(out, _u._sint16Value);
 708           		break;
 709           
 710           	    case CIMType::UINT32:
 711           		_toXml(out, _u._uint32Value);
 712           		break;
 713           
 714           	    case CIMType::SINT32:
 715 mike  1.1 		_toXml(out, _u._sint32Value);
 716           		break;
 717           
 718           	    case CIMType::UINT64:
 719           		_toXml(out, _u._uint64Value);
 720           		break;
 721           
 722           	    case CIMType::SINT64:
 723           		_toXml(out, _u._sint64Value);
 724           		break;
 725           
 726           	    case CIMType::REAL32:
 727           		_toXml(out, _u._real32Value);
 728           		break;
 729           
 730           	    case CIMType::REAL64:
 731           		_toXml(out, _u._real64Value);
 732           		break;
 733           
 734           	    case CIMType::CHAR16:
 735           		_toXml(out, Char16(_u._char16Value));
 736 mike  1.1 		break;
 737           
 738           	    case CIMType::STRING:
 739           		_toXml(out, *_u._stringValue);
 740           		break;
 741           
 742           	    case CIMType::DATETIME:
 743           		_toXml(out, *_u._dateTimeValue);
 744           		break;
 745           	}
 746           
 747           	out << "</VALUE>\n";
 748               }
 749           }
 750           

 751 mike  1.5 void CIMValue::print(PEGASUS_STD(ostream) &os) const

 752 mike  1.1 {
 753               Array<Sint8> tmp;
 754               toXml(tmp);
 755               tmp.append('\0');

 756 mike  1.5     os << tmp.getData() << PEGASUS_STD(endl);

 757 mike  1.1 }
 758           
 759           void CIMValue::set(Boolean x)
 760           {
 761               clear();
 762               _u._booleanValue = (Uint8)x;
 763               _type = CIMType::BOOLEAN;
 764           }
 765           
 766           void CIMValue::set(Uint8 x)
 767           {
 768               clear();
 769               _u._uint8Value = x;
 770               _type = CIMType::UINT8;
 771           }
 772           
 773           void CIMValue::set(Sint8 x)
 774           {
 775               clear();
 776               _u._sint8Value = x;
 777               _type = CIMType::SINT8;
 778 mike  1.1 }
 779           
 780           void CIMValue::set(Uint16 x)
 781           {
 782               clear();
 783               _u._uint16Value = x;
 784               _type = CIMType::UINT16;
 785           }
 786           
 787           void CIMValue::set(Sint16 x)
 788           {
 789               clear();
 790               _u._sint16Value = x;
 791               _type = CIMType::SINT16;
 792           }
 793           
 794           void CIMValue::set(Uint32 x)
 795           {
 796               clear();
 797               _u._uint32Value = x;
 798               _type = CIMType::UINT32;
 799 mike  1.1 }
 800           
 801           void CIMValue::set(Sint32 x)
 802           {
 803               clear();
 804               _u._sint32Value = x;
 805               _type = CIMType::SINT32;
 806           }
 807           
 808           void CIMValue::set(Uint64 x)
 809           {
 810               clear();
 811               _u._uint64Value = x;
 812               _type = CIMType::UINT64;
 813           }
 814           
 815           void CIMValue::set(Sint64 x)
 816           {
 817               clear();
 818               _u._sint64Value = x;
 819               _type = CIMType::SINT64;
 820 mike  1.1 }
 821           
 822           void CIMValue::set(Real32 x)
 823           {
 824               clear();
 825               _u._real32Value = x;
 826               _type = CIMType::REAL32;
 827           }
 828           
 829           void CIMValue::set(Real64 x)
 830           {
 831               clear();
 832               _u._real64Value = x;
 833               _type = CIMType::REAL64;
 834           }
 835           
 836           void CIMValue::set(const Char16& x)
 837           {
 838               clear();
 839               _u._char16Value = x;
 840               _type = CIMType::CHAR16;
 841 mike  1.1 }
 842           
 843           void CIMValue::set(const String& x)
 844           {
 845               clear();
 846               _u._stringValue = new String(x);
 847               _type = CIMType::STRING;
 848           }
 849           
 850           void CIMValue::set(const char* x) 
 851           { 
 852               set(String(x)); 
 853           }
 854           
 855           void CIMValue::set(const CIMDateTime& x)
 856           {
 857               clear();
 858               _u._dateTimeValue = new CIMDateTime(x);
 859               _type = CIMType::DATETIME;
 860           }
 861           
 862 mike  1.1 void CIMValue::set(const CIMReference& x)
 863           {
 864               clear();
 865               _u._referenceValue = new CIMReference(x);
 866               _type = CIMType::REFERENCE;
 867           }
 868           
 869           void CIMValue::set(const Array<Boolean>& x)
 870           {
 871               clear();
 872               _Inc(_u._booleanArray = x._rep);
 873               _type = CIMType::BOOLEAN;
 874               _isArray = true;
 875           }
 876           
 877           void CIMValue::set(const Array<Uint8>& x)
 878           {
 879               clear();
 880               _Inc(_u._uint8Array = x._rep);
 881               _type = CIMType::UINT8;
 882               _isArray = true;
 883 mike  1.1 }
 884           
 885           void CIMValue::set(const Array<Sint8>& x)
 886           {
 887               clear();
 888               _Inc(_u._sint8Array = x._rep);
 889               _type = CIMType::SINT8;
 890               _isArray = true;
 891           }
 892           
 893           void CIMValue::set(const Array<Uint16>& x)
 894           {
 895               clear();
 896               _Inc(_u._uint16Array = x._rep);
 897               _type = CIMType::UINT16;
 898               _isArray = true;
 899           }
 900           
 901           void CIMValue::set(const Array<Sint16>& x)
 902           {
 903               clear();
 904 mike  1.1     _Inc(_u._sint16Array = x._rep);
 905               _type = CIMType::SINT16;
 906               _isArray = true;
 907           }
 908           
 909           void CIMValue::set(const Array<Uint32>& x)
 910           {
 911               clear();
 912               _Inc(_u._uint32Array = x._rep);
 913               _type = CIMType::UINT32;
 914               _isArray = true;
 915           }
 916           
 917           void CIMValue::set(const Array<Sint32>& x)
 918           {
 919               clear();
 920               _Inc(_u._sint32Array = x._rep);
 921               _type = CIMType::SINT32;
 922               _isArray = true;
 923           }
 924           
 925 mike  1.1 void CIMValue::set(const Array<Uint64>& x)
 926           {
 927               clear();
 928               _Inc(_u._uint64Array = x._rep);
 929               _type = CIMType::UINT64;
 930               _isArray = true;
 931           }
 932           
 933           void CIMValue::set(const Array<Sint64>& x)
 934           {
 935               clear();
 936               _Inc(_u._sint64Array = x._rep);
 937               _type = CIMType::SINT64;
 938               _isArray = true;
 939           }
 940           
 941           void CIMValue::set(const Array<Real32>& x)
 942           {
 943               clear();
 944               _Inc(_u._real32Array = x._rep);
 945               _type = CIMType::REAL32;
 946 mike  1.1     _isArray = true;
 947           }
 948           
 949           void CIMValue::set(const Array<Real64>& x)
 950           {
 951               clear();
 952               _Inc(_u._real64Array = x._rep);
 953               _type = CIMType::REAL64;
 954               _isArray = true;
 955           }
 956           
 957           void CIMValue::set(const Array<Char16>& x)
 958           {
 959               clear();
 960               _Inc(_u._char16Array = x._rep);
 961               _type = CIMType::CHAR16;
 962               _isArray = true;
 963           }
 964           
 965           void CIMValue::set(const Array<String>& x)
 966           {
 967 mike  1.1     clear();
 968               _Inc(_u._stringArray = x._rep);
 969               _type = CIMType::STRING;
 970               _isArray = true;
 971           } 
 972           
 973           void CIMValue::set(const Array<CIMDateTime>& x)
 974           {
 975               clear();
 976               _Inc(_u._dateTimeArray = x._rep);
 977               _type = CIMType::DATETIME;
 978               _isArray = true;
 979           }
 980           
 981           void CIMValue::get(Boolean& x) const
 982           {
 983               if (_type != CIMType::BOOLEAN || _isArray)
 984           	throw TypeMismatch();
 985           
 986               x = _u._booleanValue != 0;
 987           }
 988 mike  1.1 
 989           void CIMValue::get(Uint8& x) const
 990           {
 991               if (_type != CIMType::UINT8 || _isArray)
 992           	throw TypeMismatch();
 993           
 994               x = _u._uint8Value;
 995           }
 996           
 997           void CIMValue::get(Sint8& x) const
 998           {
 999               if (_type != CIMType::SINT8 || _isArray)
1000           	throw TypeMismatch();
1001           
1002               x = _u._sint8Value;
1003           }
1004           
1005           void CIMValue::get(Uint16& x) const
1006           {
1007               if (_type != CIMType::UINT16 || _isArray)
1008           	throw TypeMismatch();
1009 mike  1.1 
1010               x = _u._uint16Value;
1011           }
1012           
1013           void CIMValue::get(Sint16& x) const
1014           {
1015               if (_type != CIMType::SINT16 || _isArray)
1016           	throw TypeMismatch();
1017           
1018               x = _u._sint16Value;
1019           }
1020           
1021           void CIMValue::get(Uint32& x) const
1022           {
1023               if (_type != CIMType::UINT32 || _isArray)
1024           	throw TypeMismatch();
1025           
1026               x = _u._uint32Value;
1027           }
1028           
1029           void CIMValue::get(Sint32& x) const
1030 mike  1.1 {
1031               if (_type != CIMType::SINT32 || _isArray)
1032           	throw TypeMismatch();
1033           
1034               x = _u._sint32Value;
1035           }
1036           
1037           void CIMValue::get(Uint64& x) const
1038           {
1039               if (_type != CIMType::UINT64 || _isArray)
1040           	throw TypeMismatch();
1041           
1042               x = _u._uint64Value;
1043           }
1044           
1045           void CIMValue::get(Sint64& x) const
1046           {
1047               if (_type != CIMType::SINT64 || _isArray)
1048           	throw TypeMismatch();
1049           
1050               x = _u._sint64Value;
1051 mike  1.1 }
1052           
1053           void CIMValue::get(Real32& x) const
1054           {
1055               if (_type != CIMType::REAL32 || _isArray)
1056           	throw TypeMismatch();
1057           
1058               x = _u._real32Value;
1059           }
1060           
1061           void CIMValue::get(Real64& x) const
1062           {
1063               if (_type != CIMType::REAL64 || _isArray)
1064           	throw TypeMismatch();
1065           
1066               x = _u._real64Value;
1067           }
1068           
1069           void CIMValue::get(Char16& x) const
1070           {
1071               if (_type != CIMType::CHAR16 || _isArray)
1072 mike  1.1 	throw TypeMismatch();
1073           
1074               x = _u._char16Value;
1075           }
1076           
1077           void CIMValue::get(String& x) const
1078           {
1079               if (_type != CIMType::STRING || _isArray)
1080           	throw TypeMismatch();
1081           
1082               x = *_u._stringValue;
1083           }
1084           
1085           void CIMValue::get(CIMDateTime& x) const
1086           {
1087               if (_type != CIMType::DATETIME || _isArray)
1088           	throw TypeMismatch();
1089           
1090               x = *_u._dateTimeValue;
1091           }
1092           
1093 mike  1.1 void CIMValue::get(CIMReference& x) const
1094           {
1095               if (_type != CIMType::REFERENCE || _isArray)
1096           	throw TypeMismatch();
1097           
1098               x = *_u._referenceValue;
1099           }
1100           
1101           void CIMValue::get(Array<Boolean>& x) const
1102           {
1103               if (_type != CIMType::BOOLEAN || !_isArray)
1104           	throw TypeMismatch();
1105           
1106               x.set(_u._booleanArray);
1107           }
1108           
1109           void CIMValue::get(Array<Uint8>& x) const
1110           {
1111               if (_type != CIMType::UINT8 || !_isArray)
1112           	throw TypeMismatch();
1113           
1114 mike  1.1     x.set(_u._uint8Array);
1115           }
1116           
1117           void CIMValue::get(Array<Sint8>& x) const
1118           {
1119               if (_type != CIMType::SINT8 || !_isArray)
1120           	throw TypeMismatch();
1121           
1122               x.set(_u._sint8Array);
1123           }
1124           
1125           void CIMValue::get(Array<Uint16>& x) const
1126           {
1127               if (_type != CIMType::UINT16 || !_isArray)
1128           	throw TypeMismatch();
1129           
1130               x.set(_u._uint16Array);
1131           }
1132           
1133           void CIMValue::get(Array<Sint16>& x) const
1134           {
1135 mike  1.1     if (_type != CIMType::SINT16 || !_isArray)
1136           	throw TypeMismatch();
1137           
1138               x.set(_u._sint16Array);
1139           }
1140           
1141           void CIMValue::get(Array<Uint32>& x) const
1142           {
1143               if (_type != CIMType::UINT32 || !_isArray)
1144           	throw TypeMismatch();
1145           
1146               x.set(_u._uint32Array);
1147           }
1148           
1149           void CIMValue::get(Array<Sint32>& x) const
1150           {
1151               if (_type != CIMType::SINT32 || !_isArray)
1152           	throw TypeMismatch();
1153           
1154               x.set(_u._sint32Array);
1155           }
1156 mike  1.1 
1157           void CIMValue::get(Array<Uint64>& x) const
1158           {
1159               if (_type != CIMType::UINT64 || !_isArray)
1160           	throw TypeMismatch();
1161           
1162               x.set(_u._uint64Array);
1163           }
1164           
1165           void CIMValue::get(Array<Sint64>& x) const
1166           {
1167               if (_type != CIMType::SINT64 || !_isArray)
1168           	throw TypeMismatch();
1169           
1170               x.set(_u._sint64Array);
1171           }
1172           
1173           void CIMValue::get(Array<Real32>& x) const
1174           {
1175               if (_type != CIMType::REAL32 || !_isArray)
1176           	throw TypeMismatch();
1177 mike  1.1 
1178               x.set(_u._real32Array);
1179           }
1180           
1181           void CIMValue::get(Array<Real64>& x) const
1182           {
1183               if (_type != CIMType::REAL64 || !_isArray)
1184           	throw TypeMismatch();
1185           
1186               x.set(_u._real64Array);
1187           }
1188           
1189           void CIMValue::get(Array<Char16>& x) const
1190           {
1191               if (_type != CIMType::CHAR16 || !_isArray)
1192           	throw TypeMismatch();
1193           
1194               x.set(_u._char16Array);
1195           }
1196           
1197           void CIMValue::get(Array<String>& x) const
1198 mike  1.1 {
1199               if (_type != CIMType::STRING || !_isArray)
1200           	throw TypeMismatch();
1201           
1202               x.set(_u._stringArray);
1203           }
1204           
1205           void CIMValue::get(Array<CIMDateTime>& x) const
1206           {
1207               if (_type != CIMType::DATETIME || !_isArray)
1208           	throw TypeMismatch();
1209           
1210               x.set(_u._dateTimeArray);
1211           }
1212           
1213           void CIMValue::_init()
1214           {
1215               _type = CIMType::NONE;
1216               _isArray = false;
1217               _u._voidPtr = 0;
1218           }
1219 mike  1.1 
1220           Boolean operator==(const CIMValue& x, const CIMValue& y)
1221           {
1222               if (!x.typeCompatible(y))
1223           	return false;
1224           
1225               if (x._isArray)
1226               {
1227           	switch (x._type)
1228           	{
1229           	    case CIMType::BOOLEAN:
1230           		return Array<Boolean>(x._u._booleanArray) ==
1231           		    Array<Boolean>(y._u._booleanArray);
1232           
1233           	    case CIMType::UINT8:
1234           		return Array<Uint8>(x._u._uint8Array) ==
1235           		    Array<Uint8>(y._u._uint8Array);
1236           
1237           	    case CIMType::SINT8:
1238           		return Array<Sint8>(x._u._sint8Array) ==
1239           		    Array<Sint8>(y._u._sint8Array);
1240 mike  1.1 
1241           	    case CIMType::UINT16:
1242           		return Array<Uint16>(x._u._uint16Array) ==
1243           		    Array<Uint16>(y._u._uint16Array);
1244           
1245           	    case CIMType::SINT16:
1246           		return Array<Sint16>(x._u._sint16Array) ==
1247           		    Array<Sint16>(y._u._sint16Array);
1248           
1249           	    case CIMType::UINT32:
1250           		return Array<Uint32>(x._u._uint32Array) ==
1251           		    Array<Uint32>(y._u._uint32Array);
1252           
1253           	    case CIMType::SINT32:
1254           		return Array<Sint32>(x._u._sint32Array) ==
1255           		    Array<Sint32>(y._u._sint32Array);
1256           
1257           	    case CIMType::UINT64:
1258           		return Array<Uint64>(x._u._uint64Array) ==
1259           		    Array<Uint64>(y._u._uint64Array);
1260           
1261 mike  1.1 	    case CIMType::SINT64:
1262           		return Array<Sint64>(x._u._sint64Array) ==
1263           		    Array<Sint64>(y._u._sint64Array);
1264           
1265           	    case CIMType::REAL32:
1266           		return Array<Real32>(x._u._real32Array) ==
1267           		    Array<Real32>(y._u._real32Array);
1268           
1269           	    case CIMType::REAL64:
1270           		return Array<Real64>(x._u._real64Array) ==
1271           		    Array<Real64>(y._u._real64Array);
1272           
1273           	    case CIMType::CHAR16:
1274           		return Array<Char16>(x._u._char16Array) ==
1275           		    Array<Char16>(y._u._char16Array);
1276           
1277           	    case CIMType::STRING:
1278           		return Array<String>(x._u._stringArray) ==
1279           		    Array<String>(y._u._stringArray);
1280           
1281           	    case CIMType::DATETIME:
1282 mike  1.1 		return Array<CIMDateTime>(x._u._dateTimeArray) ==
1283           		    Array<CIMDateTime>(y._u._dateTimeArray);
1284           	}
1285               }
1286               else
1287               {
1288           	switch (x._type)
1289           	{
1290           	    case CIMType::BOOLEAN:
1291           		return x._u._booleanValue == y._u._booleanValue;
1292           
1293           	    case CIMType::UINT8:
1294           		return x._u._uint8Value == y._u._uint8Value;
1295           
1296           	    case CIMType::SINT8:
1297           		return x._u._sint8Value == y._u._sint8Value;
1298           
1299           	    case CIMType::UINT16:
1300           		return x._u._uint16Value == y._u._uint16Value;
1301           
1302           	    case CIMType::SINT16:
1303 mike  1.1 		return x._u._sint16Value == y._u._sint16Value;
1304           
1305           	    case CIMType::UINT32:
1306           		return x._u._uint32Value == y._u._uint32Value;
1307           
1308           	    case CIMType::SINT32:
1309           		return x._u._sint32Value == y._u._sint32Value;
1310           
1311           	    case CIMType::UINT64:
1312           		return x._u._uint64Value == y._u._uint64Value;
1313           
1314           	    case CIMType::SINT64:
1315           		return x._u._sint64Value == y._u._sint64Value;
1316           
1317           	    case CIMType::REAL32:
1318           		return x._u._real32Value == y._u._real32Value;
1319           
1320           	    case CIMType::REAL64:
1321           		return x._u._real64Value == y._u._real64Value;
1322           
1323           	    case CIMType::CHAR16:
1324 mike  1.1 		return x._u._char16Value == y._u._char16Value;
1325           
1326           	    case CIMType::STRING:

1327 mike  1.2 		return String::equal(*x._u._stringValue, *y._u._stringValue);

1328 mike  1.1 
1329           	    case CIMType::DATETIME:
1330           		return *x._u._dateTimeValue == *y._u._dateTimeValue;
1331           
1332           	    case CIMType::REFERENCE:
1333           		return *x._u._referenceValue == *y._u._referenceValue;
1334           	}
1335               }
1336           
1337               // Unreachable!
1338               return false;
1339           }
1340           
1341           void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)
1342           {
1343               clear();
1344           
1345               if (isArray)
1346               {
1347           	switch (type)
1348           	{
1349 mike  1.1 	    case CIMType::BOOLEAN:
1350           		set(Array<Boolean>(arraySize));
1351           		break;
1352           
1353           	    case CIMType::UINT8:
1354           		set(Array<Uint8>(arraySize));
1355           		break;
1356           
1357           	    case CIMType::SINT8:
1358           		set(Array<Sint8>(arraySize));
1359           		break;
1360           
1361           	    case CIMType::UINT16:
1362           		set(Array<Uint16>(arraySize));
1363           		break;
1364           
1365           	    case CIMType::SINT16:
1366           		set(Array<Sint16>(arraySize));
1367           		break;
1368           
1369           	    case CIMType::UINT32:
1370 mike  1.1 		set(Array<Uint32>(arraySize));
1371           		break;
1372           
1373           	    case CIMType::SINT32:
1374           		set(Array<Sint32>(arraySize));
1375           		break;
1376           
1377           	    case CIMType::UINT64:
1378           		set(Array<Uint64>(arraySize));
1379           		break;
1380           
1381           	    case CIMType::SINT64:
1382           		set(Array<Sint64>(arraySize));
1383           		break;
1384           
1385           	    case CIMType::REAL32:
1386           		set(Array<Real32>(arraySize));
1387           		break;
1388           
1389           	    case CIMType::REAL64:
1390           		set(Array<Real64>(arraySize));
1391 mike  1.1 		break;
1392           
1393           	    case CIMType::CHAR16:
1394           		set(Array<Char16>(arraySize));
1395           		break;
1396           
1397           	    case CIMType::STRING:
1398           		set(Array<String>(arraySize));
1399           		break;
1400           
1401           	    case CIMType::DATETIME:
1402           		set(Array<CIMDateTime>(arraySize));
1403           		break;
1404           	}
1405               }
1406               else
1407               {
1408           	switch (type)
1409           	{
1410           	    case CIMType::BOOLEAN:
1411           		set(false);
1412 mike  1.1 		break;
1413           
1414           	    case CIMType::UINT8:
1415           		set(Uint8(0));
1416           		break;
1417           
1418           	    case CIMType::SINT8:
1419           		set(Sint8(0));
1420           		break;
1421           
1422           	    case CIMType::UINT16:
1423           		set(Uint16(0));
1424           		break;
1425           
1426           	    case CIMType::SINT16:
1427           		set(Sint16(0));
1428           		break;
1429           
1430           	    case CIMType::UINT32:
1431           		set(Uint32(0));
1432           		break;
1433 mike  1.1 
1434           	    case CIMType::SINT32:
1435           		set(Sint32(0));
1436           		break;
1437           
1438           	    case CIMType::UINT64:
1439           		set(Uint64(0));
1440           		break;
1441           
1442           	    case CIMType::SINT64:
1443           		set(Sint64(0));
1444           		break;
1445           
1446           	    case CIMType::REAL32:
1447           		set(Real32(0.0));
1448           		break;
1449           
1450           	    case CIMType::REAL64:
1451           		set(Real64(0.0));
1452           		break;
1453           
1454 mike  1.1 	    case CIMType::CHAR16:
1455           		set(Char16(0));
1456           		break;
1457           
1458           	    case CIMType::STRING:
1459           		set(String());
1460           		break;
1461           
1462           	    case CIMType::DATETIME:
1463           		set(CIMDateTime());
1464           		break;
1465           
1466           	    case CIMType::REFERENCE:
1467           		set(CIMReference());
1468           		break;
1469           	}
1470               }
1471           }
1472           
1473           String CIMValue::toString() const
1474           {
1475 mike  1.1     Array<Sint8> out;
1476           
1477               if (_isArray)
1478               {
1479           	switch (_type)
1480           	{
1481           	    case CIMType::BOOLEAN:
1482           	    {
1483           		for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)
1484           		{
1485           		    _toXml(out, Boolean(_u._booleanArray->data()[i]));
1486           
1487           		    out << " ";
1488           		}
1489           		break;
1490           	    }
1491           
1492           	    case CIMType::UINT8:
1493           		_toStr(out, _u._uint8Array->data(), _u._uint8Array->size);
1494           		break;
1495           
1496 mike  1.1 	    case CIMType::SINT8:
1497           		_toStr(out, _u._sint8Array->data(), _u._sint8Array->size);
1498           		break;
1499           
1500           	    case CIMType::UINT16:
1501           		_toStr(out, _u._uint16Array->data(), _u._uint16Array->size);
1502           		break;
1503           
1504           	    case CIMType::SINT16:
1505           		_toStr(out, _u._sint16Array->data(), _u._sint16Array->size);
1506           		break;
1507           
1508           	    case CIMType::UINT32:
1509           		_toStr(out, _u._uint32Array->data(), _u._uint32Array->size);
1510           		break;
1511           
1512           	    case CIMType::SINT32:
1513           		_toStr(out, _u._sint32Array->data(), _u._sint32Array->size);
1514           		break;
1515           
1516           	    case CIMType::UINT64:
1517 mike  1.1 		_toStr(out, _u._uint64Array->data(), _u._uint64Array->size);
1518           		break;
1519           
1520           	    case CIMType::SINT64:
1521           		_toStr(out, _u._sint64Array->data(), _u._sint64Array->size);
1522           		break;
1523           
1524           	    case CIMType::REAL32:
1525           		_toStr(out, _u._real32Array->data(), _u._real32Array->size);
1526           		break;
1527           
1528           	    case CIMType::REAL64:
1529           		_toStr(out, _u._real64Array->data(), _u._real64Array->size);
1530           		break;
1531           
1532           	    case CIMType::CHAR16:
1533           		_toStr(out, _u._char16Array->data(), _u._char16Array->size);
1534           		break;
1535           
1536           	    case CIMType::STRING:
1537           		_toStr(out, _u._stringArray->data(), _u._stringArray->size);
1538 mike  1.1 		break;
1539           
1540           	    case CIMType::DATETIME:
1541           		_toStr(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);
1542           		break;
1543           	}
1544               }
1545               else if (_type == CIMType::REFERENCE)
1546               {
1547           	// ATTN: work on this:
1548               }
1549               else
1550               {
1551           	switch (_type)
1552           	{
1553           	    case CIMType::BOOLEAN:
1554           		_toXml(out, Boolean(_u._booleanValue != 0));
1555           		break;
1556           
1557           	    case CIMType::UINT8:
1558           		_toXml(out, _u._uint8Value);
1559 mike  1.1 		break;
1560           
1561           	    case CIMType::SINT8:
1562           		_toXml(out, _u._sint8Value);
1563           		break;
1564           
1565           	    case CIMType::UINT16:
1566           		_toXml(out, _u._uint16Value);
1567           		break;
1568           
1569           	    case CIMType::SINT16:
1570           		_toXml(out, _u._sint16Value);
1571           		break;
1572           
1573           	    case CIMType::UINT32:
1574           		_toXml(out, _u._uint32Value);
1575           		break;
1576           
1577           	    case CIMType::SINT32:
1578           		_toXml(out, _u._sint32Value);
1579           		break;
1580 mike  1.1 
1581           	    case CIMType::UINT64:
1582           		_toXml(out, _u._uint64Value);
1583           		break;
1584           
1585           	    case CIMType::SINT64:
1586           		_toXml(out, _u._sint64Value);
1587           		break;
1588           
1589           	    case CIMType::REAL32:
1590           		_toXml(out, _u._real32Value);
1591           		break;
1592           
1593           	    case CIMType::REAL64:
1594           		_toXml(out, _u._real64Value);
1595           		break;
1596           
1597           	    case CIMType::CHAR16:
1598           		_toXml(out, Char16(_u._char16Value));
1599           		break;
1600           
1601 mike  1.1 	    case CIMType::STRING:
1602           		_toXml(out, *_u._stringValue);
1603           		break;
1604           
1605           	    case CIMType::DATETIME:
1606           		_toXml(out, *_u._dateTimeValue);
1607           		break;
1608           	}
1609               }
1610           
1611               out.append('\0');
1612               return out.getData();
1613           }
1614           
1615           PEGASUS_NAMESPACE_END