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

No CVS admin address has been configured