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

Return to CIMValue.cpp CVS log

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

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

No CVS admin address has been configured