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

Return to CIMValue.cpp CVS log

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

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

No CVS admin address has been configured