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