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